@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/room-planner/components/texture-editor/texture-editor.component.js

@@ -0,0 +1,617 @@
+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 { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { TextureType } from '../../../../core/model/texture-type';
+import { Texture } from '../../../../core/model/texture';
+import { MaterialUtils } from '../../../../core/utils/material.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../core/service/homedecorator-settings.service";
+import * as i2 from "../file-drop/file-drop.component";
+import * as i3 from "@angular/material/button-toggle";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "../../../../shared/slider-input/slider-input.component";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/flex-layout/flex";
+import * as i8 from "../../../../core/pipe/localize.pipe";
+export var TextureEditorOptions;
+(function (TextureEditorOptions) {
+    TextureEditorOptions[TextureEditorOptions["None"] = 0] = "None";
+    TextureEditorOptions[TextureEditorOptions["Image"] = 1] = "Image";
+    TextureEditorOptions[TextureEditorOptions["Tiles"] = 2] = "Tiles";
+    TextureEditorOptions[TextureEditorOptions["Both"] = 3] = "Both";
+})(TextureEditorOptions || (TextureEditorOptions = {}));
+export class TextureEditorComponent {
+    constructor(_settingsService) {
+        this._settingsService = _settingsService;
+        this.textureType = TextureType;
+        this.dragNDropEnforced = false;
+        this.setTexture = new EventEmitter();
+        this.removeTexture = new EventEmitter();
+        this.imageHasBeenResized = false;
+        this._subs = [];
+        this.Options = TextureEditorOptions;
+        this.mouseDown = false;
+        this.editorWidth = 320;
+        this.editorHeight = 320;
+        this.editorMargin = 20;
+        this.minZoom = 50;
+        this.maxZoom = {
+            [TextureType.Basic]: 500,
+            [TextureType.Image]: 200,
+            [TextureType.CustomPattern]: 500,
+            [TextureType.PBR]: 500
+        };
+        this.customPatternMultiplier = 0.79;
+        this.zoomSliderMax = 4;
+        this.editorRatio = this.editorWidth / this.editorHeight;
+        this.tileRotationDeg = 0;
+        this.tileSizeMin = 5;
+        this.tileSizeMax = 300;
+        this.tileSize = this.editorWidth - 2 * this.editorMargin;
+        // private _loadTextureData: any;
+        this.createDampener = emitter => {
+            const $dampener = new Subject();
+            const dampener = $dampener
+                .pipe(debounceTime(150))
+                .subscribe(value => emitter.emit(value));
+            return {
+                emit: value => {
+                    this.redraw();
+                    $dampener.next(value);
+                },
+                release: () => dampener.unsubscribe()
+            };
+        };
+        // this.dampSetTexture = this.createDampener(this.setTexture);
+    }
+    ngOnInit() {
+        this.setTiled(false);
+        this.canvas.nativeElement.height = this.editorHeight;
+        this.canvas.nativeElement.width = this.editorWidth;
+        this.canvas.nativeElement.addEventListener('mousedown', () => this.onMouseDown());
+        this.canvas.nativeElement.addEventListener('mouseup', () => this.onMouseUp());
+        this.canvas.nativeElement.addEventListener('mousemove', e => this.onMouseMove(e));
+        this.canvas.nativeElement.addEventListener('touchstart', (e) => this.onTouchStart(e));
+        this.canvas.nativeElement.addEventListener('touchend', () => this.onTouchEnd());
+        this.canvas.nativeElement.addEventListener('touchmove', e => this.onTouchMove(e));
+        this.context = this.canvas.nativeElement.getContext('2d');
+        this.initializeTargetProps();
+        if (this.changedTexture) {
+            this.initializeTexture();
+        }
+    }
+    ngOnDestroy() {
+        // this.dampSetTexture.release();
+        this._subs.forEach((s) => { s.unsubscribe(); });
+        this.canvas.nativeElement.removeEventListener('mousedown', () => this.onMouseDown());
+        this.canvas.nativeElement.removeEventListener('mouseup', () => this.onMouseUp());
+        this.canvas.nativeElement.removeEventListener('mousemove', e => this.onMouseMove(e));
+        this.canvas.nativeElement.removeEventListener('touchstart', (e) => this.onTouchStart(e));
+        this.canvas.nativeElement.removeEventListener('touchend', () => this.onTouchEnd());
+        this.canvas.nativeElement.removeEventListener('touchmove', e => this.onTouchMove(e));
+        this.canvas = undefined;
+        this.fileInput = undefined;
+    }
+    ngOnChanges(changes) {
+        if (!this.context) {
+            return;
+        }
+        if (changes.width || changes.height) {
+            this.initializeTargetProps();
+            this.initializeTexture();
+        }
+        // if ((changes.changedTexture && changes.changedTexture.currentValue && changes.changedTexture.currentValue.type !== TextureType.CustomPattern)
+        //   || changes.texturePlane || changes.plainTexture) {
+        if (changes.changedTexture || changes.texturePlane || changes.plainTexture) {
+            this.initializeTexture();
+        }
+    }
+    handleRemoveTextureClick(event) {
+        this.imageHasBeenResized = false;
+        this.removeTexture.emit(event);
+    }
+    _loadTextureData(texture, resize = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (texture.type) {
+                case TextureType.Basic:
+                    return yield this.loadBasicTextureData(texture);
+                case TextureType.CustomPattern:
+                    return yield this._loadCustomTextureData(texture);
+                case TextureType.Image:
+                    return yield this.loadPhotoData(texture, resize);
+                case TextureType.PBR:
+                    return yield this.loadPBRTextureData(texture);
+            }
+        });
+    }
+    setPhotoImage(dataUrl, resize = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let photoImage;
+            try {
+                photoImage = yield MaterialUtils.LoadImageCached(dataUrl, resize);
+            }
+            catch (error) {
+                console.error('Cannot read image', error);
+                this.setTexture.emit(); // rollback
+                photoImage = null;
+            }
+            this.image = photoImage;
+        });
+    }
+    setTiled(value) {
+        this.tiled = value;
+    }
+    loadPhotoData(texture, resize = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setPhotoImage(texture.data, resize);
+            if (this.image) {
+                texture.data = this.image.src;
+                this.imgRatio = this.image.width / this.image.height;
+                if (this.imgRatio < this.targetRatio) {
+                    this.textureWidth = this.targetWidth;
+                    this.textureHeight = this.textureWidth / this.imgRatio;
+                }
+                else {
+                    this.textureHeight = this.targetHeight;
+                    this.textureWidth = this.textureHeight * this.imgRatio;
+                }
+                this.initializeTextureProps(texture);
+                this.setTiled(false);
+                this.redraw();
+            }
+        });
+    }
+    _setTextureImage(dataUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let textureImage;
+            try {
+                textureImage = yield MaterialUtils.LoadImageCached(dataUrl);
+            }
+            catch (error) {
+                console.error('Cannot read image', error);
+                this.setTexture.emit(); // rollback
+                textureImage = null;
+            }
+            this.image = textureImage;
+        });
+    }
+    _loadCustomTextureData(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // clearTimeout(this._loadTextureData);
+            // this._loadTextureData = setTimeout(async () => {
+            yield this._setTextureImage(texture.data);
+            if (this.image) {
+                this.imgRatio = this.image.width / this.image.height;
+                this.tileSize = texture.tileSize * 100;
+                if (this.imgRatio < 1) {
+                    this.textureWidth = this.image.width;
+                    this.textureHeight = this.textureWidth / this.imgRatio;
+                }
+                else {
+                    this.textureHeight = this.image.height;
+                    this.textureWidth = this.textureHeight * this.imgRatio;
+                }
+                this.initializeTextureProps(texture);
+                this.setTiled(true);
+                this.redraw();
+                return;
+            }
+            // }, 200);
+        });
+    }
+    loadBasicTextureData(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // clearTimeout(this._loadTextureData);
+            // this._loadTextureData = setTimeout(async () => {
+            yield this._setTextureImage(texture.url);
+            if (this.image) {
+                this.imgRatio = this.image.width / this.image.height;
+                if (this.imgRatio < this.targetRatio) {
+                    this.textureWidth = this.targetWidth;
+                    this.textureHeight = this.textureWidth / this.imgRatio;
+                }
+                else {
+                    this.textureHeight = this.targetHeight;
+                    this.textureWidth = this.textureHeight * this.imgRatio;
+                }
+                this.initializeTextureProps(texture);
+                this.setTiled(true);
+                this.redraw();
+            }
+            // }, 200);
+        });
+    }
+    loadPBRTextureData(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // clearTimeout(this._loadTextureData);
+            // this._loadTextureData = setTimeout(async () => {
+            yield this._setTextureImage(texture.url);
+            if (this.image) {
+                this.imgRatio = this.image.width / this.image.height;
+                if (this.imgRatio < this.targetRatio) {
+                    this.textureWidth = this.targetWidth;
+                    this.textureHeight = this.textureWidth / this.imgRatio;
+                }
+                else {
+                    this.textureHeight = this.targetHeight;
+                    this.textureWidth = this.textureHeight * this.imgRatio;
+                }
+                this.initializeTextureProps(texture);
+                this.setTiled(true);
+                this.redraw();
+            }
+            // }, 200);
+        });
+    }
+    initializeTexture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const texture = this.texturePlane ? this.texturePlane.getTexture() : this.plainTexture;
+            if (texture) {
+                yield this._loadTextureData(texture, false);
+            }
+        });
+    }
+    initializeTextureProps(texture) {
+        this.texture = texture;
+        const maxZoom = this.maxZoom[texture.type];
+        this.textureScale = texture.scale || 100;
+        this.textureScaleSlider = this.textureScale > 100 ?
+            (this.textureScale - 100) * this.zoomSliderMax / (maxZoom - 100)
+            : -(this.textureScale - 100) * this.zoomSliderMax / (this.minZoom - 100);
+        this.textureRotationDeg = Math.round(THREE.MathUtils.radToDeg(texture.rotation || 0));
+        if (Number.isFinite(texture.tileSize)) {
+            this.tileSize = texture.tileSize * 100;
+        }
+        else {
+            texture.tileSize = this.tileSize / 100;
+        }
+        if (Number.isFinite(texture.tileRotation)) {
+            this.tileRotationDeg = Math.round(THREE.MathUtils.radToDeg(texture.tileRotation));
+        }
+        else {
+            texture.tileRotation = THREE.MathUtils.degToRad(this.tileRotationDeg);
+        }
+        if (texture.type === TextureType.CustomPattern) {
+            this.editorScale = Math.min(this.image.width, this.image.height) / this.targetWidth;
+        }
+        else {
+            this.editorScale = this.width / this.targetWidth;
+        }
+        const offset = texture.offset || new THREE.Vector2();
+        this.textureOffsetX = offset.x / this.editorScale;
+        this.textureOffsetY = offset.y / this.editorScale;
+    }
+    initializeTargetProps() {
+        if (Number.isFinite(this.width) && Number.isFinite(this.height)) {
+            this.targetRatio = this.width / this.height;
+            if (this.targetRatio > this.editorRatio) {
+                this.targetWidth = this.editorWidth - 2 * this.editorMargin;
+                this.targetHeight = this.targetWidth / this.targetRatio;
+                this.targetPosX = this.editorMargin;
+                this.targetPosY = (this.editorHeight - this.targetHeight) / 2;
+            }
+            else {
+                this.targetHeight = this.editorHeight - 2 * this.editorMargin;
+                this.targetWidth = this.targetHeight * this.targetRatio;
+                this.targetPosX = (this.editorWidth - this.targetWidth) / 2;
+                this.targetPosY = this.editorMargin;
+            }
+        }
+    }
+    onMouseDown() {
+        this.mouseDown = true;
+    }
+    onTouchStart(event) {
+        this.mouseDown = true;
+        const touch = event.touches[0];
+        if (touch) {
+            this.lastTouchPosition = new THREE.Vector2(touch.pageX, touch.pageY);
+        }
+    }
+    onMouseUp() {
+        this.mouseDown = false;
+    }
+    onTouchEnd() {
+        this.mouseDown = false;
+        this.lastTouchPosition = null;
+    }
+    onDragOver(event) {
+        event.stopPropagation();
+        event.preventDefault();
+    }
+    onDrop(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            event.preventDefault();
+            let file;
+            if (event.dataTransfer.items) {
+                if (event.dataTransfer.items[0].kind === 'file') {
+                    file = event.dataTransfer.items[0].getAsFile();
+                }
+            }
+            else {
+                file = event.dataTransfer.files[0];
+            }
+            const data = yield MaterialUtils.ReadAndResizePhotoAsDataURL(file);
+            this.onPhotoDataChange({ data: data.src, fileName: file.name, resized: false });
+        });
+    }
+    isBasic(texture) {
+        return texture && texture.type === TextureType.Basic;
+    }
+    isPBR(texture) {
+        return texture && texture.type === TextureType.PBR;
+    }
+    isTile(texture) {
+        return texture && !texture.stretch &&
+            (texture.type === TextureType.CustomPattern ||
+                texture.type === TextureType.Basic);
+    }
+    getTextureOffset() {
+        const offset = new THREE.Vector2(this.textureOffsetX, this.textureOffsetY);
+        return offset.multiplyScalar(this.editorScale);
+    }
+    onPhotoDataChange({ data, fileName, resized }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.imageHasBeenResized = false;
+            const texture = new Texture();
+            texture.name = fileName;
+            texture.data = data;
+            texture.offset = new THREE.Vector2();
+            texture.scale = 100;
+            texture.rotation = 0;
+            texture.tileSize = 1;
+            texture.tileRotation = 0;
+            texture.type = this.tiled ? TextureType.CustomPattern : TextureType.Image;
+            yield this._loadTextureData(Texture.CreateModelFromInterface(texture));
+            // this.dampSetTexture.emit(texture);
+            this.imageHasBeenResized = resized;
+            this.setTexture.emit(texture);
+        });
+    }
+    onMouseMove(event) {
+        if (this.texture && this.mouseDown && this.texture.type !== TextureType.Basic) {
+            this.offsetTexture(event.movementX, event.movementY);
+        }
+    }
+    onTouchMove(event) {
+        event.preventDefault();
+        const touch = event.touches[0];
+        if (touch && this.lastTouchPosition && this.texture && this.mouseDown && this.texture.type !== TextureType.Basic) {
+            this.offsetTexture(touch.pageX - this.lastTouchPosition.x, touch.pageY - this.lastTouchPosition.y);
+            this.lastTouchPosition.set(touch.pageX, touch.pageY);
+        }
+    }
+    offsetTexture(x, y) {
+        this.textureOffsetX += x * (this.textureScale / 100);
+        this.textureOffsetY += y * (this.textureScale / 100);
+        this.texture.offset = this.getTextureOffset();
+        this.texture.offsetScale = this.editorScale;
+        // this.dampSetTexture.emit(this.texture);
+        this.redraw();
+        this.setTexture.emit(this.texture);
+    }
+    onRotationChange(value) {
+        this.textureRotationDeg = this.clampNumber(value, -180, 180);
+        this.texture.rotation = THREE.MathUtils.degToRad(this.textureRotationDeg);
+        // this.dampSetTexture.emit(this.texture);
+        this.redraw();
+        this.setTexture.emit(this.texture);
+    }
+    onScaleChange(value) {
+        this.textureScaleSlider =
+            Math.round(1000 * this.clampNumber(value, -this.zoomSliderMax, this.zoomSliderMax)) / 1000;
+        const oldScale = this.textureScale / 100;
+        const maxZoom = this.maxZoom[this.texture.type];
+        if (this.textureScaleSlider >= 0) {
+            this.textureScale = (maxZoom - 100) / this.zoomSliderMax * this.textureScaleSlider + 100;
+        }
+        else {
+            this.textureScale = (this.minZoom - 100) / -this.zoomSliderMax * this.textureScaleSlider + 100;
+        }
+        const newScale = this.textureScale / 100;
+        this.textureOffsetX = (this.targetWidth / 2 - (this.targetWidth / 2 - this.textureOffsetX / oldScale) * newScale / oldScale) * newScale;
+        this.textureOffsetY = (this.targetHeight / 2 -
+            (this.targetHeight / 2 - this.textureOffsetY / oldScale) *
+                newScale / oldScale) * newScale;
+        this.texture.scale = this.textureScale;
+        this.texture.offset = this.getTextureOffset();
+        // this.dampSetTexture.emit(this.texture);
+        this.redraw();
+        this.setTexture.emit(this.texture);
+    }
+    onTileSizeChange(value) {
+        this.tileSize = Math.round(1000 * this.clampNumber(value, this.tileSizeMin, this.tileSizeMax) / 1000);
+        this.texture.tileSize = this.tileSize / 100;
+        // this.dampSetTexture.emit(this.texture);
+        this.setTexture.emit(this.texture);
+    }
+    onTileRotationChange(value) {
+        this.tileRotationDeg = this.clampNumber(value, -180, 180);
+        this.texture.tileRotation = THREE.MathUtils.degToRad(this.tileRotationDeg);
+        // this.dampSetTexture.emit(this.texture);
+        this.setTexture.emit(this.texture);
+    }
+    tiledChanged(newTiled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setTiled(newTiled);
+            this.texture.type = this.tiled ? TextureType.CustomPattern : TextureType.Image;
+            yield this._loadTextureData(this.texture);
+            // this.dampSetTexture.emit(this.texture);
+            this.setTexture.emit(this.texture);
+        });
+    }
+    drawPhotoImage() {
+        const scaleNorm = this.textureScale / 100;
+        const rotationRad = THREE.MathUtils.degToRad(this.textureRotationDeg);
+        const transX = this.targetPosX + this.textureOffsetX / scaleNorm + this.textureWidth * scaleNorm / 2;
+        const transY = this.targetPosY + this.textureOffsetY / scaleNorm + this.textureHeight * scaleNorm / 2;
+        this.context.translate(transX, transY);
+        this.context.rotate(rotationRad);
+        this.context.drawImage(this.image, -this.textureWidth * scaleNorm / 2, -this.textureHeight * scaleNorm / 2, this.textureWidth * scaleNorm, this.textureHeight * scaleNorm);
+        this.context.rotate(-rotationRad);
+        this.context.translate(-transX, -transY);
+    }
+    drawBasicTextureImage() {
+        if (this.texture.stretch) {
+            const xMargin = (this.editorWidth - this.targetWidth) / 2;
+            const yMargin = (this.editorHeight - this.targetHeight) / 2;
+            this.context.drawImage(this.image, xMargin, yMargin, this.editorWidth - 2 * xMargin, this.editorHeight - 2 * yMargin);
+        }
+        else {
+            const xMargin = (this.editorWidth - this.textureWidth) / 2;
+            const yMargin = (this.editorHeight - this.textureHeight) / 2;
+            this.context.drawImage(this.image, xMargin, yMargin, this.editorWidth - 2 * xMargin, this.editorHeight - 2 * yMargin);
+        }
+    }
+    drawCustomTextureImage() {
+        const scaleNorm = this.textureScale / 100;
+        const rotationRad = THREE.MathUtils.degToRad(this.textureRotationDeg);
+        let tileRatio;
+        if (this.textureWidth < this.textureHeight) {
+            tileRatio = (this.editorWidth - 2 * this.editorMargin) / this.textureWidth;
+        }
+        else {
+            tileRatio = (this.editorHeight - 2 * this.editorMargin) / this.textureHeight;
+        }
+        const transX = this.editorMargin + this.textureOffsetX / scaleNorm + this.textureWidth * tileRatio * scaleNorm / 2;
+        const transY = this.editorMargin + this.textureOffsetY / scaleNorm + this.textureHeight * tileRatio * scaleNorm / 2;
+        this.context.translate(transX, transY);
+        this.context.rotate(rotationRad);
+        this.context.drawImage(this.image, -this.textureWidth * tileRatio * scaleNorm / 2, -this.textureHeight * tileRatio * scaleNorm / 2, this.textureWidth * tileRatio * scaleNorm, this.textureHeight * tileRatio * scaleNorm);
+        this.context.rotate(-rotationRad);
+        this.context.translate(-transX, -transY);
+    }
+    drawTextureImage() {
+        if (this.texture) {
+            if (this.texture.type === TextureType.Basic || this.texture.type === TextureType.PBR) {
+                this.drawBasicTextureImage();
+            }
+            else if (this.texture.type === TextureType.CustomPattern) {
+                this.drawCustomTextureImage();
+            }
+        }
+    }
+    drawTargetOverlay() {
+        const xMargin = (this.editorWidth - this.targetWidth) / 2;
+        const yMargin = (this.editorHeight - this.targetHeight) / 2;
+        this.context.fillStyle = 'rgba(0, 0, 0, 0.45)';
+        this.context.fillRect(0, 0, this.editorWidth, yMargin);
+        this.context.fillRect(0, yMargin, xMargin, this.targetHeight);
+        this.context.fillRect(xMargin + this.targetWidth, yMargin, xMargin, this.targetHeight);
+        this.context.fillRect(0, this.editorHeight - yMargin, this.editorWidth, yMargin);
+        // create the border
+        const borderWidth = 1;
+        this.context.fillStyle = 'rgba(255, 0, 255, 1)';
+        this.context.fillRect(xMargin, yMargin, this.targetWidth, borderWidth);
+        this.context.fillRect(xMargin, yMargin + borderWidth, borderWidth, this.targetHeight);
+        this.context.fillRect((xMargin + this.targetWidth) - borderWidth, yMargin, borderWidth, this.targetHeight);
+        this.context.fillRect(xMargin, this.editorHeight - yMargin, this.targetWidth, borderWidth);
+    }
+    drawTileOverlay() {
+        this.context.fillStyle = 'rgba(0, 0, 0, 0.45)';
+        this.context.fillRect(0, 0, this.editorWidth, this.editorMargin);
+        this.context.fillRect(0, this.editorMargin, this.editorMargin, this.editorHeight - 2 * this.editorMargin);
+        this.context.fillRect(this.editorWidth - this.editorMargin, this.editorMargin, this.editorMargin, this.editorHeight - 2 * this.editorMargin);
+        this.context.fillRect(0, this.editorHeight - this.editorMargin, this.editorWidth, this.editorMargin);
+        // create the border
+        const borderWidth = 1;
+        this.context.fillStyle = 'rgba(255, 0, 255, 1)';
+        this.context.fillRect(this.editorMargin, this.editorMargin, this.editorWidth - (this.editorMargin * 2), borderWidth);
+        this.context.fillRect(this.editorWidth - this.editorMargin, this.editorMargin, borderWidth, this.editorHeight - (this.editorMargin * 2));
+        this.context.fillRect(this.editorMargin, this.editorHeight - this.editorMargin, this.editorWidth - (this.editorMargin * 2) + borderWidth, borderWidth);
+        this.context.fillRect(this.editorMargin, this.editorMargin, borderWidth, this.editorHeight - (this.editorMargin * 2));
+    }
+    redraw(background = '#666666') {
+        this.context.fillStyle = background;
+        this.context.fillRect(-this.editorWidth, -this.editorHeight, 2 * this.editorWidth, 2 * this.editorHeight);
+        if (this.image) {
+            if (this.tiled) {
+                this.drawTextureImage();
+                if (this.texture.type === TextureType.CustomPattern) {
+                    this.drawTileOverlay();
+                }
+            }
+            else {
+                this.drawPhotoImage();
+                this.drawTargetOverlay();
+            }
+        }
+    }
+    // TODO: Reset default texture - not white
+    resetTexture() {
+        this.texture = null;
+        this.setTexture.emit(0xffffff);
+    }
+    clampNumber(number, min, max) {
+        return Math.min(Math.max(number, min), max);
+    }
+    getCroppedCanvas() {
+        this.redraw('#ffffff');
+        let myCanvas = this.canvas.nativeElement;
+        if (this.texture.type === TextureType.CustomPattern) {
+            const xMargin = this.editorMargin;
+            const yMargin = this.editorMargin;
+            myCanvas = this.cropCanvas(myCanvas, xMargin + 1, yMargin + 1, this.editorWidth - (2 * this.editorMargin) - 1, this.editorHeight - (2 * this.editorMargin) - 1);
+        }
+        else if (this.texture.type === TextureType.Image) {
+            const xMargin = (this.editorWidth - this.targetWidth) / 2;
+            const yMargin = (this.editorHeight - this.targetHeight) / 2;
+            myCanvas = this.cropCanvas(myCanvas, xMargin + 1, yMargin + 1, this.targetWidth - 2, this.targetHeight - 2);
+        }
+        this.redraw();
+        return myCanvas.toDataURL();
+    }
+    cropCanvas(sourceCanvas, left, top, width, height) {
+        const destCanvas = document.createElement('canvas');
+        destCanvas.width = width;
+        destCanvas.height = height;
+        destCanvas.getContext('2d').drawImage(sourceCanvas, left, top, width, height, // source rect with content to crop
+        0, 0, width, height); // newCanvas, same size as source rect
+        return destCanvas;
+    }
+}
+TextureEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TextureEditorComponent, deps: [{ token: i1.HomedecoratorSettingsService }], target: i0.ɵɵFactoryTarget.Component });
+TextureEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: TextureEditorComponent, selector: "rp-texture-editor", inputs: { width: "width", height: "height", texturePlane: "texturePlane", plainTexture: "plainTexture", changedTexture: "changedTexture", options: "options", dragNDropEnforced: "dragNDropEnforced" }, outputs: { setTexture: "setTexture", removeTexture: "removeTexture" }, viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true, static: true }, { propertyName: "canvas", first: true, predicate: ["canvas"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<rp-file-drop\r\n  [showDragDrop]=\"((!changedTexture || texture?.type === textureType.Basic) && options !== Options.None) || dragNDropEnforced\"\r\n  [showRemove]=\"changedTexture\"\r\n  (fileContentChanged)=\"onPhotoDataChange($event)\"\r\n  (removeClick)=\"handleRemoveTextureClick($event)\"\r\n>\r\n</rp-file-drop>\r\n\r\n<div class=\"resize-message-wrapper\" *ngIf=\"imageHasBeenResized\">\r\n  <span class=\"resize-message\" [textContent]=\"'IMAGE_RESIZED' | localize\"></span>\r\n</div>\r\n\r\n<div class=\"picture-editor\" [hidden]=\"!texture || !changedTexture || dragNDropEnforced\">\r\n  <div\r\n    class=\"picture-editor-canvas\"\r\n    [hidden]=\"options === Options.None || (texture?.type === textureType.Basic)\"\r\n    (dragover)=\"onDragOver($event)\"\r\n    (drop)=\"onDrop($event)\"\r\n  >\r\n    <div\r\n      class=\"canvas-wrapper\"\r\n      fxLayout=\"column inline\"\r\n      fxLayoutAlign=\"center center\"\r\n    >\r\n      <canvas [hidden]=\"texture && texture.stretch\" #canvas></canvas>\r\n      <mat-button-toggle-group\r\n        *ngIf=\"options === Options.Both\"\r\n        (change)=\"tiledChanged($event.value === 'texture')\"\r\n        [value]=\"tiled ? 'texture' : 'stretch'\"\r\n      >\r\n        <mat-button-toggle\r\n          value=\"stretch\"\r\n          title=\"{{'PICTURE' | localize}}\"\r\n          [checked]=\"!tiled\">\r\n          <div fxLayout=\"column\" fxLayoutAlign=\"center center\">\r\n            <mat-icon class=\"homedecorator-material-icons\">photo_size_select_large</mat-icon>\r\n            {{'SKIN_FULL_WALL' | localize}}\r\n          </div>\r\n        </mat-button-toggle>\r\n        <mat-button-toggle\r\n          value=\"texture\"\r\n          title=\"{{'TILE' | localize}}\"\r\n          [checked]=\"tiled\"\r\n          >\r\n          <div fxLayout=\"column\" fxLayoutAlign=\"center center\">\r\n            <mat-icon class=\"homedecorator-material-icons\">texture</mat-icon>\r\n            {{'CREATE_TEXTURE' | localize}}\r\n          </div>\r\n        </mat-button-toggle>\r\n      </mat-button-toggle-group>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"sliders\" *ngIf=\"texture?.type === textureType.CustomPattern\r\n    || ((texture?.type === textureType.Basic || texture?.type === textureType.PBR)\r\n    && options === Options.None)\r\n\"\r\n    >\r\n    <rp-slider-input\r\n      title=\"{{'TILE_ROTATION' | localize}}\"\r\n      min=\"-180\"\r\n      max=\"180\"\r\n      step=\"1\"\r\n      [value]=\"tileRotationDeg\"\r\n      (onChange)=\"onTileRotationChange($event)\">\r\n    </rp-slider-input>\r\n    <rp-slider-input\r\n      title=\"{{'TILE_SIZE' | localize}}\"\r\n      [min]=\"tileSizeMin\"\r\n      [max]=\"tileSizeMax\"\r\n      step=\"0.1\"\r\n      [value]=\"tileSize\"\r\n      (onChange)=\"onTileSizeChange($event)\">\r\n    </rp-slider-input>\r\n  </div>\r\n\r\n  <div class=\"sliders\" *ngIf=\"!isBasic(texture) && !isPBR(texture)\">\r\n    <rp-slider-input\r\n      title=\"{{'ROTATION' | localize}}\"\r\n      min=\"-180\"\r\n      max=\"180\"\r\n      step=\"1\"\r\n      [value]=\"textureRotationDeg\"\r\n      (onChange)=\"onRotationChange($event)\">\r\n    </rp-slider-input>\r\n    <rp-slider-input\r\n      title=\"{{'ZOOM' | localize}}\"\r\n      [min]=\"-zoomSliderMax\"\r\n      [max]=\"zoomSliderMax\"\r\n      step=\"0.1\"\r\n      [value]=\"textureScaleSlider\"\r\n      (onChange)=\"onScaleChange($event)\">\r\n    </rp-slider-input>\r\n  </div>\r\n\r\n  <!--\r\n  <footer class=\"picture-editor-footer\">\r\n    <button *ngIf=\"texture?.type !== TextureType.Basic || options === Options.None\"\r\n      mat-stroked-button color=\"warn\"\r\n      (click)=\"resetTexture()\"\r\n    >\r\n      {{ 'Remove' | localize }}\r\n    </button>\r\n  </footer>\r\n  -->\r\n</div>\r\n", styles: ["rp-texture-editor{display:block;width:100%}.picture-editor-footer{margin-bottom:16px}.picture-editor-canvas{margin-top:.75em;margin-bottom:1.5em;text-align:center}.canvas-wrapper{position:relative}.canvas-wrapper mat-button-toggle-group{text-align:center;width:320px}.canvas-wrapper mat-button-toggle{flex-basis:50%;padding:4px 0}.resize-message-wrapper{margin:10px 3px 3px;text-align:-webkit-center}.resize-message-wrapper .resize-message{color:red;font-style:italic;font-weight:bold;font-size:.9em}\n"], components: [{ type: i2.FileDropComponent, selector: "rp-file-drop", inputs: ["showDragDrop", "showRemove"], outputs: ["fileContentChanged", "removeClick"] }, { type: i3.MatButtonToggle, selector: "mat-button-toggle", inputs: ["disableRipple", "aria-labelledby", "tabIndex", "appearance", "checked", "disabled", "id", "name", "aria-label", "value"], outputs: ["change"], exportAs: ["matButtonToggle"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i5.SliderInputComponent, selector: "rp-slider-input", inputs: ["title", "min", "max", "step", "value"], outputs: ["onChange"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { type: i7.DefaultLayoutAlignDirective, selector: "  [fxLayoutAlign], [fxLayoutAlign.xs], [fxLayoutAlign.sm], [fxLayoutAlign.md],  [fxLayoutAlign.lg], [fxLayoutAlign.xl], [fxLayoutAlign.lt-sm], [fxLayoutAlign.lt-md],  [fxLayoutAlign.lt-lg], [fxLayoutAlign.lt-xl], [fxLayoutAlign.gt-xs], [fxLayoutAlign.gt-sm],  [fxLayoutAlign.gt-md], [fxLayoutAlign.gt-lg]", inputs: ["fxLayoutAlign", "fxLayoutAlign.xs", "fxLayoutAlign.sm", "fxLayoutAlign.md", "fxLayoutAlign.lg", "fxLayoutAlign.xl", "fxLayoutAlign.lt-sm", "fxLayoutAlign.lt-md", "fxLayoutAlign.lt-lg", "fxLayoutAlign.lt-xl", "fxLayoutAlign.gt-xs", "fxLayoutAlign.gt-sm", "fxLayoutAlign.gt-md", "fxLayoutAlign.gt-lg"] }, { type: i3.MatButtonToggleGroup, selector: "mat-button-toggle-group", inputs: ["appearance", "name", "vertical", "value", "multiple", "disabled"], outputs: ["valueChange", "change"], exportAs: ["matButtonToggleGroup"] }], pipes: { "localize": i8.LocalizePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TextureEditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-texture-editor',
+                    templateUrl: './texture-editor.component.html',
+                    styleUrls: ['./texture-editor.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }]; }, propDecorators: { fileInput: [{
+                type: ViewChild,
+                args: ['fileInput', { static: true }]
+            }], canvas: [{
+                type: ViewChild,
+                args: ['canvas', { static: true }]
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], texturePlane: [{
+                type: Input
+            }], plainTexture: [{
+                type: Input
+            }], changedTexture: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], dragNDropEnforced: [{
+                type: Input
+            }], setTexture: [{
+                type: Output
+            }], removeTexture: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"texture-editor.component.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/room-planner/components/texture-editor/texture-editor.component.ts","../../../../../../../../src/client/app/plugins/room-planner/components/texture-editor/texture-editor.component.html"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAc,YAAY,EAAE,KAAK,EAAgC,MAAM,EAAiB,SAAS,EAAC,MAAM,eAAe,CAAC;AACzI,OAAO,EAAC,OAAO,EAAe,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,WAAW,EAAC,MAAM,qCAAqC,CAAC;AAChE,OAAO,EAAC,OAAO,EAAC,MAAM,gCAAgC,CAAC;AAEvD,OAAO,EAAC,aAAa,EAAC,MAAM,uCAAuC,CAAC;;;;;;;;;;AAEpE,MAAM,CAAN,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAC9B,+DAAI,CAAA;IACJ,iEAAK,CAAA;IACL,iEAAK,CAAA;IACL,+DAAI,CAAA;AACN,CAAC,EALW,oBAAoB,KAApB,oBAAoB,QAK/B;AAOD,MAAM,OAAO,sBAAsB;IAkFjC,YAAoB,gBAA8C;QAA9C,qBAAgB,GAAhB,gBAAgB,CAA8B;QAjFlD,gBAAW,GAAuB,WAAW,CAAC;QAYrD,sBAAiB,GAAG,KAAK,CAAC;QACzB,eAAU,GAAG,IAAI,YAAY,EAAoB,CAAC;QAClD,kBAAa,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAEhE,wBAAmB,GAAY,KAAK,CAAC;QAEpC,UAAK,GAAmB,EAAE,CAAC;QAEnC,YAAO,GAAG,oBAAoB,CAAC;QAI/B,cAAS,GAAG,KAAK,CAAC;QAGlB,gBAAW,GAAG,GAAG,CAAC;QAClB,iBAAY,GAAG,GAAG,CAAC;QACnB,iBAAY,GAAG,EAAE,CAAC;QAClB,YAAO,GAAG,EAAE,CAAC;QACb,YAAO,GAAG;YACR,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,GAAG;YACxB,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,GAAG;YACxB,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE,GAAG;YAChC,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG;SACvB,CAAC;QACF,4BAAuB,GAAG,IAAI,CAAC;QAC/B,kBAAa,GAAG,CAAC,CAAC;QAClB,gBAAW,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC;QAUnD,oBAAe,GAAG,CAAC,CAAC;QACpB,gBAAW,GAAG,CAAC,CAAC;QAChB,gBAAW,GAAG,GAAG,CAAC;QAClB,aAAQ,GAAG,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;QAapD,iCAAiC;QAEjC,mBAAc,GAAG,OAAO,CAAC,EAAE;YACzB,MAAM,SAAS,GAAG,IAAI,OAAO,EAAE,CAAC;YAChC,MAAM,QAAQ,GAAG,SAAS;iBACvB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;iBACvB,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAC3C,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,EAAE;oBACZ,IAAI,CAAC,MAAM,EAAE,CAAC;oBACd,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACxB,CAAC;gBACD,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE;aACtC,CAAC;QACJ,CAAC,CAAA;QAGC,8DAA8D;IAChE,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC;QAEnD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QAClF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9E,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAElF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QACtF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAChF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAElF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1D,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1B;IAEH,CAAC;IAED,WAAW;QACT,iCAAiC;QACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,GAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAA,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QACjF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QACzF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QACnF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACjB,OAAO;SACR;QACD,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE;YACnC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC7B,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1B;QACD,gJAAgJ;QAChJ,uDAAuD;QACvD,IAAI,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE;YAC1E,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1B;IACH,CAAC;IAEM,wBAAwB,CAAC,KAAU;QACxC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAEa,gBAAgB,CAAC,OAAgB,EAAE,SAAkB,IAAI;;YACrE,QAAQ,OAAO,CAAC,IAAI,EAAE;gBACpB,KAAK,WAAW,CAAC,KAAK;oBACpB,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;gBAClD,KAAK,WAAW,CAAC,aAAa;oBAC5B,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;gBACpD,KAAK,WAAW,CAAC,KAAK;oBACpB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBACnD,KAAK,WAAW,CAAC,GAAG;oBAClB,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;aACjD;QACH,CAAC;KAAA;IAEK,aAAa,CAAC,OAAe,EAAE,SAAkB,IAAI;;YACzD,IAAI,UAA4B,CAAC;YACjC,IAAI;gBACF,UAAU,GAAG,MAAM,aAAa,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;aACnE;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;gBAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW;gBACnC,UAAU,GAAG,IAAI,CAAC;aACnB;YACD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;QAC1B,CAAC;KAAA;IAEO,QAAQ,CAAC,KAAc;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAEK,aAAa,CAAC,OAAgB,EAAE,SAAkB,IAAI;;YAC1D,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC/C,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;gBAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBACrD,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;oBACpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC;oBACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;qBAAM;oBACL,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC;oBACvC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;gBACD,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBACrB,IAAI,CAAC,MAAM,EAAE,CAAC;aACf;QACH,CAAC;KAAA;IAEa,gBAAgB,CAAC,OAAe;;YAC5C,IAAI,YAA8B,CAAC;YACnC,IAAI;gBACF,YAAY,GAAG,MAAM,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;aAC7D;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;gBAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW;gBACnC,YAAY,GAAG,IAAI,CAAC;aACrB;YACD,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;QAC5B,CAAC;KAAA;IAEa,sBAAsB,CAAC,OAAgB;;YACnD,uCAAuC;YACvC,mDAAmD;YACjD,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC1C,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBACrD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,GAAG,CAAC;gBACvC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE;oBACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;oBACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;qBAAM;oBACL,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;oBACvC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;gBACD,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACpB,IAAI,CAAC,MAAM,EAAE,CAAC;gBACd,OAAO;aACR;YACH,WAAW;QACb,CAAC;KAAA;IAEK,oBAAoB,CAAC,OAAgB;;YACzC,uCAAuC;YACvC,mDAAmD;YACjD,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBACrD,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;oBACpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC;oBACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;qBAAM;oBACL,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC;oBACvC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;gBACD,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACpB,IAAI,CAAC,MAAM,EAAE,CAAC;aACf;YACH,WAAW;QACb,CAAC;KAAA;IAEK,kBAAkB,CAAC,OAAgB;;YACvC,uCAAuC;YACvC,mDAAmD;YACjD,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBACrD,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;oBACpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC;oBACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;qBAAM;oBACL,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC;oBACvC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC;iBACxD;gBACD,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACpB,IAAI,CAAC,MAAM,EAAE,CAAC;aACf;YACH,WAAW;QACb,CAAC;KAAA;IAEK,iBAAiB;;YACrB,MAAM,OAAO,GACT,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;YAC3E,IAAI,OAAO,EAAE;gBACX,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;aAC7C;QACH,CAAC;KAAA;IAED,sBAAsB,CAAC,OAAgB;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,KAAK,IAAI,GAAG,CAAC;QACzC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC;YACjD,CAAC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC;YAChE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;QACtF,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACrC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,GAAG,CAAC;SACxC;aAAM;YACL,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;SACxC;QACD,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACzC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;SACnF;aAAM;YACL,OAAO,CAAC,YAAY,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SACvE;QACD,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,aAAa,EAAE;YAC9C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC;SACrF;aAAM;YACL,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC;SAClD;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QACrD,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC;QAClD,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC;IACpD,CAAC;IAED,qBAAqB;QACnB,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YAC/D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;YAC5C,IAAI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE;gBACvC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;gBAC5D,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;gBACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC;gBACpC,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;aAC/D;iBAAM;gBACL,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;gBAC9D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC;gBACxD,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;gBAC5D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC;aACrC;SACF;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;IAED,YAAY,CAAC,KAAiB;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,iBAAiB,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;SACtE;IACH,CAAC;IAED,SAAS;QACP,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAED,UAAU;QACR,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,UAAU,CAAC,KAAgB;QACzB,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAEK,MAAM,CAAC,KAAgB;;YAC3B,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,IAAU,CAAC;YACf,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,EAAE;gBAC5B,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,EAAE;oBAC/C,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;iBAChD;aACF;iBAAM;gBACL,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;aACpC;YAED,MAAM,IAAI,GAAqB,MAAM,aAAa,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;YACrF,IAAI,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;QAClF,CAAC;KAAA;IAED,OAAO,CAAC,OAAgB;QACtB,OAAO,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,CAAC;IACvD,CAAC;IAED,KAAK,CAAC,OAAgB;QACpB,OAAO,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,GAAG,CAAC;IACrD,CAAC;IAED,MAAM,CAAC,OAAgB;QACrB,OAAO,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO;YAChC,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,aAAa;gBAC3C,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,gBAAgB;QACd,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3E,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACjD,CAAC;IAEK,iBAAiB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAwD;;YACvG,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACjC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;YAC9B,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC;YACxB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;YACpB,OAAO,CAAC,MAAM,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACrC,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC;YACpB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;YACrB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;YACrB,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC;YACzB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC;YAC1E,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,CAAC;YACvE,qCAAqC;YACrC,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC;YACnC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;KAAA;IAED,WAAW,CAAC,KAAiB;QAC3B,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,EAAE;YAC7E,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;SACtD;IACH,CAAC;IAED,WAAW,CAAC,KAAiB;QAC3B,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,KAAK,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,EAAE;YAChH,IAAI,CAAC,aAAa,CAChB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,EACtC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CACvC,CAAC;YACF,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;SACtD;IACH,CAAC;IAED,aAAa,CAAC,CAAS,EAAE,CAAS;QAChC,IAAI,CAAC,cAAc,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,cAAc,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QAC5C,0CAA0C;QAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,gBAAgB,CAAC,KAAa;QAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC1E,0CAA0C;QAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,aAAa,CAAC,KAAa;QACzB,IAAI,CAAC,kBAAkB;YACrB,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC;QAC7F,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QACzC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,EAAE;YAChC,IAAI,CAAC,YAAY,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC;SAC1F;aAAM;YACL,IAAI,CAAC,YAAY,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC;SAChG;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QACzC,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAAC;QACxI,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC;YAC1C,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;gBACxD,QAAQ,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC9C,0CAA0C;QAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,gBAAgB,CAAC,KAAa;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;QACtG,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QAC5C,0CAA0C;QAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,oBAAoB,CAAC,KAAa;QAChC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAC1D,IAAI,CAAC,OAAO,CAAC,YAAY,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC3E,0CAA0C;QAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAEK,YAAY,CAAC,QAAiB;;YAClC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC;YAC/E,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1C,0CAA0C;YAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrC,CAAC;KAAA;IAED,cAAc;QACZ,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QAC1C,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,cAAc,GAAG,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,CAAC,CAAC;QACrG,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,cAAc,GAAG,SAAS,GAAG,IAAI,CAAC,aAAa,GAAG,SAAS,GAAG,CAAC,CAAC;QACtG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACjC,IAAI,CAAC,OAAO,CAAC,SAAS,CACpB,IAAI,CAAC,KAAK,EACV,CAAC,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,CAAC,EAClC,CAAC,IAAI,CAAC,aAAa,GAAG,SAAS,GAAG,CAAC,EACnC,IAAI,CAAC,YAAY,GAAG,SAAS,EAC7B,IAAI,CAAC,aAAa,GAAG,SAAS,CAC/B,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED,qBAAqB;QACnB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACxB,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YAC1D,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAC5D,IAAI,CAAC,OAAO,CAAC,SAAS,CACpB,IAAI,CAAC,KAAK,EACV,OAAO,EACP,OAAO,EACP,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,OAAO,EAC9B,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,OAAO,CAChC,CAAC;SACH;aAAM;YACL,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAC3D,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAC7D,IAAI,CAAC,OAAO,CAAC,SAAS,CACpB,IAAI,CAAC,KAAK,EACV,OAAO,EACP,OAAO,EACP,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,OAAO,EAC9B,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,OAAO,CAChC,CAAC;SACH;IACH,CAAC;IAED,sBAAsB;QACpB,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC;QAC1C,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACtE,IAAI,SAAS,CAAC;QACd,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE;YAC1C,SAAS,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;SAC5E;aAAM;YACL,SAAS,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC;SAC9E;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,cAAc,GAAG,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC;QACnH,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,cAAc,GAAG,SAAS,GAAG,IAAI,CAAC,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC;QACpH,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACjC,IAAI,CAAC,OAAO,CAAC,SAAS,CACpB,IAAI,CAAC,KAAK,EACV,CAAC,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,EAC9C,CAAC,IAAI,CAAC,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,CAAC,EAC/C,IAAI,CAAC,YAAY,GAAG,SAAS,GAAG,SAAS,EACzC,IAAI,CAAC,aAAa,GAAG,SAAS,GAAG,SAAS,CAC3C,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED,gBAAgB;QACd,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,GAAG,EAAE;gBACpF,IAAI,CAAC,qBAAqB,EAAE,CAAC;aAC9B;iBAAM,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,aAAa,EAAE;gBAC1D,IAAI,CAAC,sBAAsB,EAAE,CAAC;aAC/B;SACF;IACH,CAAC;IAED,iBAAiB;QACf,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAE5D,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,qBAAqB,CAAC;QAC/C,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACvD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACvF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,GAAG,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QAEjF,oBAAoB;QACpB,MAAM,WAAW,GAAW,CAAC,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,sBAAsB,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QACvE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACtF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3G,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,GAAG,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAC7F,CAAC;IAED,eAAe;QACb,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,qBAAqB,CAAC;QAC/C,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1G,IAAI,CAAC,OAAO,CAAC,QAAQ,CACnB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EACvD,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,YAAY,CAC7D,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAErG,oBAAoB;QACpB,MAAM,WAAW,GAAW,CAAC,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,sBAAsB,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;QACrH,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;QACzI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,GAAG,WAAW,EAAE,WAAW,CAAC,CAAC;QACvJ,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;IACxH,CAAC;IAED,MAAM,CAAC,aAAqB,SAAS;QACnC,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,UAAU,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1G,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACxB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,aAAa,EAAE;oBACnD,IAAI,CAAC,eAAe,EAAE,CAAC;iBACxB;aACF;iBAAM;gBACL,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,IAAI,CAAC,iBAAiB,EAAE,CAAC;aAC1B;SACF;IACH,CAAC;IAED,0CAA0C;IAC1C,YAAY;QACV,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED,WAAW,CAAC,MAAc,EAAE,GAAW,EAAE,GAAW;QAClD,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IAC9C,CAAC;IAED,gBAAgB;QAEd,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAEvB,IAAI,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC;QAEzC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,aAAa,EAAE;YACnD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;YAClC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;YAClC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,YAAY,GAAI,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;SAClK;aAAM,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,KAAK,EAAE;YAClD,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YAC1D,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAC5D,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;SAC7G;QAED,IAAI,CAAC,MAAM,EAAE,CAAC;QAEd,OAAO,QAAQ,CAAC,SAAS,EAAE,CAAC;IAC9B,CAAC;IAED,UAAU,CAAC,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM;QAC/C,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACpD,UAAU,CAAC,KAAK,GAAG,KAAK,CAAC;QACzB,UAAU,CAAC,MAAM,GAAG,MAAM,CAAC;QAC3B,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,YAAY,EAChD,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAG,mCAAmC;QAC9D,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAM,sCAAsC;QACnE,OAAO,UAAU,CAAC;IACpB,CAAC;;oHAhoBU,sBAAsB;wGAAtB,sBAAsB,ojBCtBnC,8sHA0GA;4FDpFa,sBAAsB;kBALlC,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,WAAW,EAAE,iCAAiC;oBAC9C,SAAS,EAAE,CAAC,iCAAiC,CAAC;iBAC/C;mHAI2C,SAAS;sBAAlD,SAAS;uBAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBACD,MAAM;sBAA5C,SAAS;uBAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAC5B,KAAK;sBAAb,KAAK;gBACG,MAAM;sBAAd,KAAK;gBAEG,YAAY;sBAApB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBAEG,OAAO;sBAAf,KAAK;gBACG,iBAAiB;sBAAzB,KAAK;gBACI,UAAU;sBAAnB,MAAM;gBACG,aAAa;sBAAtB,MAAM","sourcesContent":["import * as THREE from 'three';\r\n\r\nimport {Component, ElementRef, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, ViewChild} from '@angular/core';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {debounceTime} from 'rxjs/operators';\r\nimport {TextureType} from '../../../../core/model/texture-type';\r\nimport {Texture} from '../../../../core/model/texture';\r\nimport {HomedecoratorSettingsService} from '../../../../core/service/homedecorator-settings.service';\r\nimport {MaterialUtils} from '../../../../core/utils/material.utils';\r\n\r\nexport enum TextureEditorOptions {\r\n  None,\r\n  Image,\r\n  Tiles,\r\n  Both\r\n}\r\n\r\n@Component({\r\n  selector: 'rp-texture-editor',\r\n  templateUrl: './texture-editor.component.html',\r\n  styleUrls: ['./texture-editor.component.scss']\r\n})\r\nexport class TextureEditorComponent implements OnInit, OnChanges, OnDestroy {\r\n  public readonly textureType: typeof TextureType = TextureType;\r\n\r\n  @ViewChild('fileInput', { static: true }) fileInput: ElementRef;\r\n  @ViewChild('canvas', { static: true }) canvas: ElementRef;\r\n  @Input() width: number;\r\n  @Input() height: number;\r\n\r\n  @Input() texturePlane;\r\n  @Input() plainTexture;\r\n  @Input() changedTexture: Texture;\r\n\r\n  @Input() options: TextureEditorOptions;\r\n  @Input() dragNDropEnforced = false;\r\n  @Output() setTexture = new EventEmitter<Texture | number>();\r\n  @Output() removeTexture: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  public imageHasBeenResized: boolean = false;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  Options = TextureEditorOptions;\r\n\r\n  texture: Texture;\r\n\r\n  mouseDown = false;\r\n  lastTouchPosition: THREE.Vector2;\r\n\r\n  editorWidth = 320;\r\n  editorHeight = 320;\r\n  editorMargin = 20;\r\n  minZoom = 50;\r\n  maxZoom = {\r\n    [TextureType.Basic]: 500,\r\n    [TextureType.Image]: 200,\r\n    [TextureType.CustomPattern]: 500,\r\n    [TextureType.PBR]: 500\r\n  };\r\n  customPatternMultiplier = 0.79;\r\n  zoomSliderMax = 4;\r\n  editorRatio = this.editorWidth / this.editorHeight;\r\n  editorScale: number;\r\n\r\n  targetWidth: number;\r\n  targetHeight: number;\r\n  targetPosX: number;\r\n  targetPosY: number;\r\n  textureRotationDeg: number;\r\n  textureScale: number;\r\n  textureScaleSlider: number;\r\n  tileRotationDeg = 0;\r\n  tileSizeMin = 5;\r\n  tileSizeMax = 300;\r\n  tileSize = this.editorWidth - 2 * this.editorMargin;\r\n  tileTextureRatio: number;\r\n  textureOffsetX: number;\r\n  textureOffsetY: number;\r\n  textureWidth: number;\r\n  textureHeight: number;\r\n  image: HTMLImageElement;\r\n  imgRatio: number;\r\n  targetRatio: number;\r\n  context: CanvasRenderingContext2D;\r\n  dampSetTexture;\r\n  tiled: boolean;\r\n\r\n  // private _loadTextureData: any;\r\n\r\n  createDampener = emitter => {\r\n    const $dampener = new Subject();\r\n    const dampener = $dampener\r\n      .pipe(debounceTime(150))\r\n      .subscribe(value => emitter.emit(value));\r\n    return {\r\n      emit: value => {\r\n        this.redraw();\r\n        $dampener.next(value);\r\n      },\r\n      release: () => dampener.unsubscribe()\r\n    };\r\n  }\r\n\r\n  constructor(private _settingsService: HomedecoratorSettingsService) {\r\n    // this.dampSetTexture = this.createDampener(this.setTexture);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.setTiled(false);\r\n    this.canvas.nativeElement.height = this.editorHeight;\r\n    this.canvas.nativeElement.width = this.editorWidth;\r\n\r\n    this.canvas.nativeElement.addEventListener('mousedown', () => this.onMouseDown());\r\n    this.canvas.nativeElement.addEventListener('mouseup', () => this.onMouseUp());\r\n    this.canvas.nativeElement.addEventListener('mousemove', e => this.onMouseMove(e));\r\n\r\n    this.canvas.nativeElement.addEventListener('touchstart', (e) => this.onTouchStart(e));\r\n    this.canvas.nativeElement.addEventListener('touchend', () => this.onTouchEnd());\r\n    this.canvas.nativeElement.addEventListener('touchmove', e => this.onTouchMove(e));\r\n\r\n    this.context = this.canvas.nativeElement.getContext('2d');\r\n    this.initializeTargetProps();\r\n    if (this.changedTexture) {\r\n      this.initializeTexture();\r\n    }\r\n\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    // this.dampSetTexture.release();\r\n    this._subs.forEach((s) => {s.unsubscribe();});\r\n    this.canvas.nativeElement.removeEventListener('mousedown', () => this.onMouseDown());\r\n    this.canvas.nativeElement.removeEventListener('mouseup', () => this.onMouseUp());\r\n    this.canvas.nativeElement.removeEventListener('mousemove', e => this.onMouseMove(e));\r\n    this.canvas.nativeElement.removeEventListener('touchstart', (e) => this.onTouchStart(e));\r\n    this.canvas.nativeElement.removeEventListener('touchend', () => this.onTouchEnd());\r\n    this.canvas.nativeElement.removeEventListener('touchmove', e => this.onTouchMove(e));\r\n    this.canvas = undefined;\r\n    this.fileInput = undefined;\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (!this.context) {\r\n      return;\r\n    }\r\n    if (changes.width || changes.height) {\r\n      this.initializeTargetProps();\r\n      this.initializeTexture();\r\n    }\r\n    // if ((changes.changedTexture && changes.changedTexture.currentValue && changes.changedTexture.currentValue.type !== TextureType.CustomPattern)\r\n    //   || changes.texturePlane || changes.plainTexture) {\r\n    if (changes.changedTexture || changes.texturePlane || changes.plainTexture) {\r\n      this.initializeTexture();\r\n    }\r\n  }\r\n\r\n  public handleRemoveTextureClick(event: any): void {\r\n    this.imageHasBeenResized = false;\r\n    this.removeTexture.emit(event);\r\n  }\r\n\r\n  private async _loadTextureData(texture: Texture, resize: boolean = true): Promise<void> {\r\n    switch (texture.type) {\r\n      case TextureType.Basic:\r\n        return await this.loadBasicTextureData(texture);\r\n      case TextureType.CustomPattern:\r\n        return await this._loadCustomTextureData(texture);\r\n      case TextureType.Image:\r\n        return await this.loadPhotoData(texture, resize);\r\n      case TextureType.PBR:\r\n        return await this.loadPBRTextureData(texture);\r\n    }\r\n  }\r\n\r\n  async setPhotoImage(dataUrl: string, resize: boolean = true) {\r\n    let photoImage: HTMLImageElement;\r\n    try {\r\n      photoImage = await MaterialUtils.LoadImageCached(dataUrl, resize);\r\n    } catch (error) {\r\n      console.error('Cannot read image', error);\r\n      this.setTexture.emit(); // rollback\r\n      photoImage = null;\r\n    }\r\n    this.image = photoImage;\r\n  }\r\n\r\n  private setTiled(value: boolean) {\r\n    this.tiled = value;\r\n  }\r\n\r\n  async loadPhotoData(texture: Texture, resize: boolean = true) {\r\n    await this.setPhotoImage(texture.data, resize);\r\n    if (this.image) {\r\n      texture.data = this.image.src;\r\n      this.imgRatio = this.image.width / this.image.height;\r\n      if (this.imgRatio < this.targetRatio) {\r\n        this.textureWidth = this.targetWidth;\r\n        this.textureHeight = this.textureWidth / this.imgRatio;\r\n      } else {\r\n        this.textureHeight = this.targetHeight;\r\n        this.textureWidth = this.textureHeight * this.imgRatio;\r\n      }\r\n      this.initializeTextureProps(texture);\r\n      this.setTiled(false);\r\n      this.redraw();\r\n    }\r\n  }\r\n\r\n  private async _setTextureImage(dataUrl: string): Promise<void> {\r\n    let textureImage: HTMLImageElement;\r\n    try {\r\n      textureImage = await MaterialUtils.LoadImageCached(dataUrl);\r\n    } catch (error) {\r\n      console.error('Cannot read image', error);\r\n      this.setTexture.emit(); // rollback\r\n      textureImage = null;\r\n    }\r\n    this.image = textureImage;\r\n  }\r\n\r\n  private async _loadCustomTextureData(texture: Texture): Promise<void> {\r\n    // clearTimeout(this._loadTextureData);\r\n    // this._loadTextureData = setTimeout(async () => {\r\n      await this._setTextureImage(texture.data);\r\n      if (this.image) {\r\n        this.imgRatio = this.image.width / this.image.height;\r\n        this.tileSize = texture.tileSize * 100;\r\n        if (this.imgRatio < 1) {\r\n          this.textureWidth = this.image.width;\r\n          this.textureHeight = this.textureWidth / this.imgRatio;\r\n        } else {\r\n          this.textureHeight = this.image.height;\r\n          this.textureWidth = this.textureHeight * this.imgRatio;\r\n        }\r\n        this.initializeTextureProps(texture);\r\n        this.setTiled(true);\r\n        this.redraw();\r\n        return;\r\n      }\r\n    // }, 200);\r\n  }\r\n\r\n  async loadBasicTextureData(texture: Texture) {\r\n    // clearTimeout(this._loadTextureData);\r\n    // this._loadTextureData = setTimeout(async () => {\r\n      await this._setTextureImage(texture.url);\r\n      if (this.image) {\r\n        this.imgRatio = this.image.width / this.image.height;\r\n        if (this.imgRatio < this.targetRatio) {\r\n          this.textureWidth = this.targetWidth;\r\n          this.textureHeight = this.textureWidth / this.imgRatio;\r\n        } else {\r\n          this.textureHeight = this.targetHeight;\r\n          this.textureWidth = this.textureHeight * this.imgRatio;\r\n        }\r\n        this.initializeTextureProps(texture);\r\n        this.setTiled(true);\r\n        this.redraw();\r\n      }\r\n    // }, 200);\r\n  }\r\n\r\n  async loadPBRTextureData(texture: Texture) {\r\n    // clearTimeout(this._loadTextureData);\r\n    // this._loadTextureData = setTimeout(async () => {\r\n      await this._setTextureImage(texture.url);\r\n      if (this.image) {\r\n        this.imgRatio = this.image.width / this.image.height;\r\n        if (this.imgRatio < this.targetRatio) {\r\n          this.textureWidth = this.targetWidth;\r\n          this.textureHeight = this.textureWidth / this.imgRatio;\r\n        } else {\r\n          this.textureHeight = this.targetHeight;\r\n          this.textureWidth = this.textureHeight * this.imgRatio;\r\n        }\r\n        this.initializeTextureProps(texture);\r\n        this.setTiled(true);\r\n        this.redraw();\r\n      }\r\n    // }, 200);\r\n  }\r\n\r\n  async initializeTexture() {\r\n    const texture\r\n      = this.texturePlane ? this.texturePlane.getTexture() : this.plainTexture;\r\n    if (texture) {\r\n      await this._loadTextureData(texture, false);\r\n    }\r\n  }\r\n\r\n  initializeTextureProps(texture: Texture) {\r\n    this.texture = texture;\r\n    const maxZoom = this.maxZoom[texture.type];\r\n    this.textureScale = texture.scale || 100;\r\n    this.textureScaleSlider = this.textureScale > 100 ?\r\n      (this.textureScale - 100) * this.zoomSliderMax / (maxZoom - 100)\r\n      : -(this.textureScale - 100) * this.zoomSliderMax / (this.minZoom - 100);\r\n    this.textureRotationDeg = Math.round(THREE.MathUtils.radToDeg(texture.rotation || 0));\r\n    if (Number.isFinite(texture.tileSize)) {\r\n      this.tileSize = texture.tileSize * 100;\r\n    } else {\r\n      texture.tileSize = this.tileSize / 100;\r\n    }\r\n    if (Number.isFinite(texture.tileRotation)) {\r\n      this.tileRotationDeg = Math.round(THREE.MathUtils.radToDeg(texture.tileRotation));\r\n    } else {\r\n      texture.tileRotation = THREE.MathUtils.degToRad(this.tileRotationDeg);\r\n    }\r\n    if (texture.type === TextureType.CustomPattern) {\r\n      this.editorScale = Math.min(this.image.width, this.image.height) / this.targetWidth;\r\n    } else {\r\n      this.editorScale = this.width / this.targetWidth;\r\n    }\r\n    const offset = texture.offset || new THREE.Vector2();\r\n    this.textureOffsetX = offset.x / this.editorScale;\r\n    this.textureOffsetY = offset.y / this.editorScale;\r\n  }\r\n\r\n  initializeTargetProps() {\r\n    if (Number.isFinite(this.width) && Number.isFinite(this.height)) {\r\n      this.targetRatio = this.width / this.height;\r\n      if (this.targetRatio > this.editorRatio) {\r\n        this.targetWidth = this.editorWidth - 2 * this.editorMargin;\r\n        this.targetHeight = this.targetWidth / this.targetRatio;\r\n        this.targetPosX = this.editorMargin;\r\n        this.targetPosY = (this.editorHeight - this.targetHeight) / 2;\r\n      } else {\r\n        this.targetHeight = this.editorHeight - 2 * this.editorMargin;\r\n        this.targetWidth = this.targetHeight * this.targetRatio;\r\n        this.targetPosX = (this.editorWidth - this.targetWidth) / 2;\r\n        this.targetPosY = this.editorMargin;\r\n      }\r\n    }\r\n  }\r\n\r\n  onMouseDown() {\r\n    this.mouseDown = true;\r\n  }\r\n\r\n  onTouchStart(event: TouchEvent) {\r\n    this.mouseDown = true;\r\n    const touch = event.touches[0];\r\n    if (touch) {\r\n      this.lastTouchPosition = new THREE.Vector2(touch.pageX, touch.pageY);\r\n    }\r\n  }\r\n\r\n  onMouseUp() {\r\n    this.mouseDown = false;\r\n  }\r\n\r\n  onTouchEnd() {\r\n    this.mouseDown = false;\r\n    this.lastTouchPosition = null;\r\n  }\r\n\r\n  onDragOver(event: DragEvent): void {\r\n    event.stopPropagation();\r\n    event.preventDefault();\r\n  }\r\n\r\n  async onDrop(event: DragEvent): Promise<void> {\r\n    event.preventDefault();\r\n    let file: File;\r\n    if (event.dataTransfer.items) {\r\n      if (event.dataTransfer.items[0].kind === 'file') {\r\n        file = event.dataTransfer.items[0].getAsFile();\r\n      }\r\n    } else {\r\n      file = event.dataTransfer.files[0];\r\n    }\r\n\r\n    const data: HTMLImageElement = await MaterialUtils.ReadAndResizePhotoAsDataURL(file);\r\n    this.onPhotoDataChange({ data: data.src, fileName: file.name, resized: false });\r\n  }\r\n\r\n  isBasic(texture: Texture): boolean {\r\n    return texture && texture.type === TextureType.Basic;\r\n  }\r\n\r\n  isPBR(texture: Texture): boolean {\r\n    return texture && texture.type === TextureType.PBR;\r\n  }\r\n\r\n  isTile(texture: Texture): boolean {\r\n    return texture && !texture.stretch &&\r\n      (texture.type === TextureType.CustomPattern ||\r\n      texture.type === TextureType.Basic);\r\n  }\r\n\r\n  getTextureOffset(): THREE.Vector2 {\r\n    const offset = new THREE.Vector2(this.textureOffsetX, this.textureOffsetY);\r\n    return offset.multiplyScalar(this.editorScale);\r\n  }\r\n\r\n  async onPhotoDataChange({ data, fileName, resized }: { data: string, fileName: string, resized: boolean }): Promise<void> {\r\n    this.imageHasBeenResized = false;\r\n    const texture = new Texture();\r\n    texture.name = fileName;\r\n    texture.data = data;\r\n    texture.offset = new THREE.Vector2();\r\n    texture.scale = 100;\r\n    texture.rotation = 0;\r\n    texture.tileSize = 1;\r\n    texture.tileRotation = 0;\r\n    texture.type = this.tiled ? TextureType.CustomPattern : TextureType.Image;\r\n    await this._loadTextureData(Texture.CreateModelFromInterface(texture));\r\n    // this.dampSetTexture.emit(texture);\r\n    this.imageHasBeenResized = resized;\r\n    this.setTexture.emit(texture);\r\n  }\r\n\r\n  onMouseMove(event: MouseEvent) {\r\n    if (this.texture && this.mouseDown && this.texture.type !== TextureType.Basic) {\r\n      this.offsetTexture(event.movementX, event.movementY);\r\n    }\r\n  }\r\n\r\n  onTouchMove(event: TouchEvent) {\r\n    event.preventDefault();\r\n    const touch = event.touches[0];\r\n    if (touch && this.lastTouchPosition && this.texture && this.mouseDown && this.texture.type !== TextureType.Basic) {\r\n      this.offsetTexture(\r\n        touch.pageX - this.lastTouchPosition.x,\r\n        touch.pageY - this.lastTouchPosition.y\r\n      );\r\n      this.lastTouchPosition.set(touch.pageX, touch.pageY);\r\n    }\r\n  }\r\n\r\n  offsetTexture(x: number, y: number) {\r\n    this.textureOffsetX += x * (this.textureScale / 100);\r\n    this.textureOffsetY += y * (this.textureScale / 100);\r\n    this.texture.offset = this.getTextureOffset();\r\n    this.texture.offsetScale = this.editorScale;\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.redraw();\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  onRotationChange(value: number) {\r\n    this.textureRotationDeg = this.clampNumber(value, -180, 180);\r\n    this.texture.rotation = THREE.MathUtils.degToRad(this.textureRotationDeg);\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.redraw();\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  onScaleChange(value: number) {\r\n    this.textureScaleSlider =\r\n      Math.round(1000 * this.clampNumber(value, -this.zoomSliderMax, this.zoomSliderMax)) / 1000;\r\n    const oldScale = this.textureScale / 100;\r\n    const maxZoom = this.maxZoom[this.texture.type];\r\n    if (this.textureScaleSlider >= 0) {\r\n      this.textureScale = (maxZoom - 100) / this.zoomSliderMax * this.textureScaleSlider + 100;\r\n    } else {\r\n      this.textureScale = (this.minZoom - 100) / -this.zoomSliderMax * this.textureScaleSlider + 100;\r\n    }\r\n    const newScale = this.textureScale / 100;\r\n    this.textureOffsetX = (this.targetWidth / 2 - (this.targetWidth / 2 - this.textureOffsetX / oldScale) * newScale / oldScale) * newScale;\r\n    this.textureOffsetY = (this.targetHeight / 2 -\r\n      (this.targetHeight / 2 - this.textureOffsetY / oldScale) *\r\n      newScale / oldScale) * newScale;\r\n    this.texture.scale = this.textureScale;\r\n    this.texture.offset = this.getTextureOffset();\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.redraw();\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  onTileSizeChange(value: number) {\r\n    this.tileSize = Math.round(1000 * this.clampNumber(value, this.tileSizeMin, this.tileSizeMax) / 1000);\r\n    this.texture.tileSize = this.tileSize / 100;\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  onTileRotationChange(value: number) {\r\n    this.tileRotationDeg = this.clampNumber(value, -180, 180);\r\n    this.texture.tileRotation = THREE.MathUtils.degToRad(this.tileRotationDeg);\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  async tiledChanged(newTiled: boolean) {\r\n    this.setTiled(newTiled);\r\n    this.texture.type = this.tiled ? TextureType.CustomPattern : TextureType.Image;\r\n    await this._loadTextureData(this.texture);\r\n    // this.dampSetTexture.emit(this.texture);\r\n    this.setTexture.emit(this.texture);\r\n  }\r\n\r\n  drawPhotoImage() {\r\n    const scaleNorm = this.textureScale / 100;\r\n    const rotationRad = THREE.MathUtils.degToRad(this.textureRotationDeg);\r\n    const transX = this.targetPosX + this.textureOffsetX / scaleNorm + this.textureWidth * scaleNorm / 2;\r\n    const transY = this.targetPosY + this.textureOffsetY / scaleNorm + this.textureHeight * scaleNorm / 2;\r\n    this.context.translate(transX, transY);\r\n    this.context.rotate(rotationRad);\r\n    this.context.drawImage(\r\n      this.image,\r\n      -this.textureWidth * scaleNorm / 2,\r\n      -this.textureHeight * scaleNorm / 2,\r\n      this.textureWidth * scaleNorm,\r\n      this.textureHeight * scaleNorm\r\n    );\r\n    this.context.rotate(-rotationRad);\r\n    this.context.translate(-transX, -transY);\r\n  }\r\n\r\n  drawBasicTextureImage() {\r\n    if (this.texture.stretch) {\r\n      const xMargin = (this.editorWidth - this.targetWidth) / 2;\r\n      const yMargin = (this.editorHeight - this.targetHeight) / 2;\r\n      this.context.drawImage(\r\n        this.image,\r\n        xMargin,\r\n        yMargin,\r\n        this.editorWidth - 2 * xMargin,\r\n        this.editorHeight - 2 * yMargin\r\n      );\r\n    } else {\r\n      const xMargin = (this.editorWidth - this.textureWidth) / 2;\r\n      const yMargin = (this.editorHeight - this.textureHeight) / 2;\r\n      this.context.drawImage(\r\n        this.image,\r\n        xMargin,\r\n        yMargin,\r\n        this.editorWidth - 2 * xMargin,\r\n        this.editorHeight - 2 * yMargin\r\n      );\r\n    }\r\n  }\r\n\r\n  drawCustomTextureImage() {\r\n    const scaleNorm = this.textureScale / 100;\r\n    const rotationRad = THREE.MathUtils.degToRad(this.textureRotationDeg);\r\n    let tileRatio;\r\n    if (this.textureWidth < this.textureHeight) {\r\n      tileRatio = (this.editorWidth - 2 * this.editorMargin) / this.textureWidth;\r\n    } else {\r\n      tileRatio = (this.editorHeight - 2 * this.editorMargin) / this.textureHeight;\r\n    }\r\n    const transX = this.editorMargin + this.textureOffsetX / scaleNorm + this.textureWidth * tileRatio * scaleNorm / 2;\r\n    const transY = this.editorMargin + this.textureOffsetY / scaleNorm + this.textureHeight * tileRatio * scaleNorm / 2;\r\n    this.context.translate(transX, transY);\r\n    this.context.rotate(rotationRad);\r\n    this.context.drawImage(\r\n      this.image,\r\n      -this.textureWidth * tileRatio * scaleNorm / 2,\r\n      -this.textureHeight * tileRatio * scaleNorm / 2,\r\n      this.textureWidth * tileRatio * scaleNorm,\r\n      this.textureHeight * tileRatio * scaleNorm\r\n    );\r\n    this.context.rotate(-rotationRad);\r\n    this.context.translate(-transX, -transY);\r\n  }\r\n\r\n  drawTextureImage() {\r\n    if (this.texture) {\r\n      if (this.texture.type === TextureType.Basic || this.texture.type === TextureType.PBR) {\r\n        this.drawBasicTextureImage();\r\n      } else if (this.texture.type === TextureType.CustomPattern) {\r\n        this.drawCustomTextureImage();\r\n      }\r\n    }\r\n  }\r\n\r\n  drawTargetOverlay() {\r\n    const xMargin = (this.editorWidth - this.targetWidth) / 2;\r\n    const yMargin = (this.editorHeight - this.targetHeight) / 2;\r\n\r\n    this.context.fillStyle = 'rgba(0, 0, 0, 0.45)';\r\n    this.context.fillRect(0, 0, this.editorWidth, yMargin);\r\n    this.context.fillRect(0, yMargin, xMargin, this.targetHeight);\r\n    this.context.fillRect(xMargin + this.targetWidth, yMargin, xMargin, this.targetHeight);\r\n    this.context.fillRect(0, this.editorHeight - yMargin, this.editorWidth, yMargin);\r\n\r\n    // create the border\r\n    const borderWidth: number = 1;\r\n    this.context.fillStyle = 'rgba(255, 0, 255, 1)';\r\n    this.context.fillRect(xMargin, yMargin, this.targetWidth, borderWidth);\r\n    this.context.fillRect(xMargin, yMargin + borderWidth, borderWidth, this.targetHeight);\r\n    this.context.fillRect((xMargin + this.targetWidth) - borderWidth, yMargin, borderWidth, this.targetHeight);\r\n    this.context.fillRect(xMargin, this.editorHeight - yMargin, this.targetWidth, borderWidth);\r\n  }\r\n\r\n  drawTileOverlay() {\r\n    this.context.fillStyle = 'rgba(0, 0, 0, 0.45)';\r\n    this.context.fillRect(0, 0, this.editorWidth, this.editorMargin);\r\n    this.context.fillRect(0, this.editorMargin, this.editorMargin, this.editorHeight - 2 * this.editorMargin);\r\n    this.context.fillRect(\r\n      this.editorWidth - this.editorMargin, this.editorMargin,\r\n      this.editorMargin, this.editorHeight - 2 * this.editorMargin\r\n    );\r\n    this.context.fillRect(0, this.editorHeight - this.editorMargin, this.editorWidth, this.editorMargin);\r\n\r\n    // create the border\r\n    const borderWidth: number = 1;\r\n    this.context.fillStyle = 'rgba(255, 0, 255, 1)';\r\n    this.context.fillRect(this.editorMargin, this.editorMargin, this.editorWidth - (this.editorMargin * 2), borderWidth);\r\n    this.context.fillRect(this.editorWidth - this.editorMargin, this.editorMargin, borderWidth, this.editorHeight - (this.editorMargin * 2));\r\n    this.context.fillRect(this.editorMargin, this.editorHeight - this.editorMargin, this.editorWidth - (this.editorMargin * 2) + borderWidth, borderWidth);\r\n    this.context.fillRect(this.editorMargin, this.editorMargin, borderWidth, this.editorHeight - (this.editorMargin * 2));\r\n  }\r\n\r\n  redraw(background: string = '#666666') {\r\n    this.context.fillStyle = background;\r\n    this.context.fillRect(-this.editorWidth, -this.editorHeight, 2 * this.editorWidth, 2 * this.editorHeight);\r\n    if (this.image) {\r\n      if (this.tiled) {\r\n        this.drawTextureImage();\r\n        if (this.texture.type === TextureType.CustomPattern) {\r\n          this.drawTileOverlay();\r\n        }\r\n      } else {\r\n        this.drawPhotoImage();\r\n        this.drawTargetOverlay();\r\n      }\r\n    }\r\n  }\r\n\r\n  // TODO: Reset default texture - not white\r\n  resetTexture() {\r\n    this.texture = null;\r\n    this.setTexture.emit(0xffffff);\r\n  }\r\n\r\n  clampNumber(number: number, min: number, max: number): number {\r\n    return Math.min(Math.max(number, min), max);\r\n  }\r\n\r\n  getCroppedCanvas(): string {\r\n\r\n    this.redraw('#ffffff');\r\n\r\n    let myCanvas = this.canvas.nativeElement;\r\n\r\n    if (this.texture.type === TextureType.CustomPattern) {\r\n      const xMargin = this.editorMargin;\r\n      const yMargin = this.editorMargin;\r\n      myCanvas = this.cropCanvas(myCanvas, xMargin + 1, yMargin + 1, this.editorWidth - (2 * this.editorMargin) - 1, this.editorHeight  - (2 * this.editorMargin) - 1);\r\n    } else if (this.texture.type === TextureType.Image) {\r\n      const xMargin = (this.editorWidth - this.targetWidth) / 2;\r\n      const yMargin = (this.editorHeight - this.targetHeight) / 2;\r\n      myCanvas = this.cropCanvas(myCanvas, xMargin + 1, yMargin + 1, this.targetWidth - 2, this.targetHeight - 2);\r\n    }\r\n\r\n    this.redraw();\r\n\r\n    return myCanvas.toDataURL();\r\n  }\r\n\r\n  cropCanvas(sourceCanvas, left, top, width, height): any {\r\n    const destCanvas = document.createElement('canvas');\r\n    destCanvas.width = width;\r\n    destCanvas.height = height;\r\n    destCanvas.getContext('2d').drawImage(sourceCanvas,\r\n      left, top, width, height,  // source rect with content to crop\r\n      0, 0, width, height);      // newCanvas, same size as source rect\r\n    return destCanvas;\r\n  }\r\n}\r\n","<rp-file-drop\r\n  [showDragDrop]=\"((!changedTexture || texture?.type === textureType.Basic) && options !== Options.None) || dragNDropEnforced\"\r\n  [showRemove]=\"changedTexture\"\r\n  (fileContentChanged)=\"onPhotoDataChange($event)\"\r\n  (removeClick)=\"handleRemoveTextureClick($event)\"\r\n>\r\n</rp-file-drop>\r\n\r\n<div class=\"resize-message-wrapper\" *ngIf=\"imageHasBeenResized\">\r\n  <span class=\"resize-message\" [textContent]=\"'IMAGE_RESIZED' | localize\"></span>\r\n</div>\r\n\r\n<div class=\"picture-editor\" [hidden]=\"!texture || !changedTexture || dragNDropEnforced\">\r\n  <div\r\n    class=\"picture-editor-canvas\"\r\n    [hidden]=\"options === Options.None || (texture?.type === textureType.Basic)\"\r\n    (dragover)=\"onDragOver($event)\"\r\n    (drop)=\"onDrop($event)\"\r\n  >\r\n    <div\r\n      class=\"canvas-wrapper\"\r\n      fxLayout=\"column inline\"\r\n      fxLayoutAlign=\"center center\"\r\n    >\r\n      <canvas [hidden]=\"texture && texture.stretch\" #canvas></canvas>\r\n      <mat-button-toggle-group\r\n        *ngIf=\"options === Options.Both\"\r\n        (change)=\"tiledChanged($event.value === 'texture')\"\r\n        [value]=\"tiled ? 'texture' : 'stretch'\"\r\n      >\r\n        <mat-button-toggle\r\n          value=\"stretch\"\r\n          title=\"{{'PICTURE' | localize}}\"\r\n          [checked]=\"!tiled\">\r\n          <div fxLayout=\"column\" fxLayoutAlign=\"center center\">\r\n            <mat-icon class=\"homedecorator-material-icons\">photo_size_select_large</mat-icon>\r\n            {{'SKIN_FULL_WALL' | localize}}\r\n          </div>\r\n        </mat-button-toggle>\r\n        <mat-button-toggle\r\n          value=\"texture\"\r\n          title=\"{{'TILE' | localize}}\"\r\n          [checked]=\"tiled\"\r\n          >\r\n          <div fxLayout=\"column\" fxLayoutAlign=\"center center\">\r\n            <mat-icon class=\"homedecorator-material-icons\">texture</mat-icon>\r\n            {{'CREATE_TEXTURE' | localize}}\r\n          </div>\r\n        </mat-button-toggle>\r\n      </mat-button-toggle-group>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"sliders\" *ngIf=\"texture?.type === textureType.CustomPattern\r\n    || ((texture?.type === textureType.Basic || texture?.type === textureType.PBR)\r\n    && options === Options.None)\r\n\"\r\n    >\r\n    <rp-slider-input\r\n      title=\"{{'TILE_ROTATION' | localize}}\"\r\n      min=\"-180\"\r\n      max=\"180\"\r\n      step=\"1\"\r\n      [value]=\"tileRotationDeg\"\r\n      (onChange)=\"onTileRotationChange($event)\">\r\n    </rp-slider-input>\r\n    <rp-slider-input\r\n      title=\"{{'TILE_SIZE' | localize}}\"\r\n      [min]=\"tileSizeMin\"\r\n      [max]=\"tileSizeMax\"\r\n      step=\"0.1\"\r\n      [value]=\"tileSize\"\r\n      (onChange)=\"onTileSizeChange($event)\">\r\n    </rp-slider-input>\r\n  </div>\r\n\r\n  <div class=\"sliders\" *ngIf=\"!isBasic(texture) && !isPBR(texture)\">\r\n    <rp-slider-input\r\n      title=\"{{'ROTATION' | localize}}\"\r\n      min=\"-180\"\r\n      max=\"180\"\r\n      step=\"1\"\r\n      [value]=\"textureRotationDeg\"\r\n      (onChange)=\"onRotationChange($event)\">\r\n    </rp-slider-input>\r\n    <rp-slider-input\r\n      title=\"{{'ZOOM' | localize}}\"\r\n      [min]=\"-zoomSliderMax\"\r\n      [max]=\"zoomSliderMax\"\r\n      step=\"0.1\"\r\n      [value]=\"textureScaleSlider\"\r\n      (onChange)=\"onScaleChange($event)\">\r\n    </rp-slider-input>\r\n  </div>\r\n\r\n  <!--\r\n  <footer class=\"picture-editor-footer\">\r\n    <button *ngIf=\"texture?.type !== TextureType.Basic || options === Options.None\"\r\n      mat-stroked-button color=\"warn\"\r\n      (click)=\"resetTexture()\"\r\n    >\r\n      {{ 'Remove' | localize }}\r\n    </button>\r\n  </footer>\r\n  -->\r\n</div>\r\n"]}