@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/render/service/render.service.js

@@ -0,0 +1,650 @@
+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 { Injectable } from '@angular/core';
+import { Command, Service } from '@migenius/realityserver-client';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Box3, DirectionalLight, Material, Mesh, MeshPhongMaterial, SpotLight, Vector3 } from 'three';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter';
+import { RenderModes } from '../enum/render-modes';
+import { ConnectionStatus } from '../enum/connection-status';
+import { RenderQueueItem } from '../model/render-queue-item';
+import { Toast } from '../../../core/model/toast';
+import { ToastType } from '../../../core/model/toast-type';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { RenderData } from '../model/render-data';
+import { RenderSettings } from '../model/render-settings';
+import { FileUtils } from '../../../core/utils/file.utils';
+import { RenderStatus } from '../enum/render-status';
+import { CustomFloorItem } from '../../core3d/items/custom-floor-item';
+import { ItemGroup } from '../../core3d/items/item-group';
+import { GoogleTagManagerEvent } from '../../../core/enum/google-tag-manager-event.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-settings.service";
+import * as i2 from "../../threedselector/threedselector/service/build-furniture.service";
+import * as i3 from "../../../core/service/export.service";
+import * as i4 from "../../core3d/service/camera.service";
+import * as i5 from "../../core3d/service/scene.service";
+import * as i6 from "../../../core/service/homedecorator-connector.service";
+import * as i7 from "../../../core/service/homedecorator-connector-adapter.service";
+import * as i8 from "../../threedselector/threedselector/service/threedselector.service";
+import * as i9 from "../../../core/service/toast.service";
+import * as i10 from "../../../core/service/message-bus.service";
+import * as i11 from "../../../service/google-tag-manager.service";
+import * as i12 from "../../room-planner/components/floorplanner/service/room.service";
+import * as i13 from "../../core3d/service/floor.service";
+import * as i14 from "../../threedselector/threedselector/service/load-furniture.service";
+export class RenderService {
+    constructor(_settingsService, _buildFurnitureService, _exportService, _cameraService, _sceneService, _ione, _ioneConnectorAdapter, _threedSelectorService, _toastService, _messageBusService, _googleTagManager, _roomService, _floorService, _loadFurnitureService) {
+        this._settingsService = _settingsService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this._exportService = _exportService;
+        this._cameraService = _cameraService;
+        this._sceneService = _sceneService;
+        this._ione = _ione;
+        this._ioneConnectorAdapter = _ioneConnectorAdapter;
+        this._threedSelectorService = _threedSelectorService;
+        this._toastService = _toastService;
+        this._messageBusService = _messageBusService;
+        this._googleTagManager = _googleTagManager;
+        this._roomService = _roomService;
+        this._floorService = _floorService;
+        this._loadFurnitureService = _loadFurnitureService;
+        this.renderModes = RenderModes;
+        this.streaming = {};
+        this.renderedRoomImages = [];
+        this.connectionStatus = ConnectionStatus.IsUndefined;
+        this.renders = [];
+        this.cameraPositions = [];
+        this.imageSizes = [
+            { id: 1, name: 'Small', width: 400, height: 300 },
+            { id: 2, name: 'Shop', width: 800, height: 800 },
+            { id: 3, name: 'Full HD', width: 1920, height: 1080 },
+            { id: 4, name: '4K', width: 4096, height: 2160 }
+        ];
+        this.lightnings = [
+            { id: 1, name: 'Light', settings: [] },
+            { id: 2, name: 'Medium', settings: [] },
+            { id: 3, name: 'Heay', settings: [] }
+        ];
+        this.renderEnvironments = [
+            { id: 1, name: 'None', hdrFile: '', intensity: 1.0 },
+            { id: 2, name: 'Modern city', hdrFile: 'canary_wharf_2k.hdr', intensity: 2.5 },
+            { id: 3, name: 'City park', hdrFile: 'dresden_moat_2k.hdr', intensity: 2.5 },
+            { id: 4, name: 'Night in the city', hdrFile: 'hansaplatz_2k.hdr', intensity: 1.0 },
+            { id: 5, name: 'Night in the countryside', hdrFile: 'kloppenheim_02_2k.hdr', intensity: 1.0 },
+            { id: 6, name: 'Forest', hdrFile: 'nagoya_wall_path_2k.hdr', intensity: 1.0 },
+            { id: 7, name: 'Snow', hdrFile: 'snowy_forest_path_01_2k.hdr', intensity: 1.0 },
+            { id: 8, name: 'Pasture', hdrFile: 'spruit_sunrise_2k.hdr', intensity: 1.0 },
+            { id: 9, name: 'Field', hdrFile: 'sunflowers_2k.hdr', intensity: 1.0 },
+            { id: 10, name: 'Old city and canals', hdrFile: 'tears_of_steel_bridge_2k.hdr', intensity: 1.0 },
+            { id: 11, name: 'Estate', hdrFile: 'tiergarten_2k.hdr', intensity: 1.0 },
+            { id: 12, name: 'Beach', hdrFile: 'umhlanga_sunrise_2k.hdr', intensity: 2.5 },
+            { id: 13, name: 'Residential area with park', hdrFile: 'urban_street_01_2k.hdr', intensity: 1.0 },
+            { id: 14, name: 'Residential area', hdrFile: 'urban_street_03_2k.hdr', intensity: 1.0 },
+        ];
+        this.renderScenes = [
+            { id: 1, name: 'scene_grass_cycles_MRP', sceneAssetId: 'scene_grass_cycles_MRP' },
+            { id: 2, name: 'scene_lake_cycles_MRP', sceneAssetId: 'scene_lake_cycles_MRP' },
+            { id: 3, name: 'scene_sky_cycles_MRP', sceneAssetId: 'scene_sky_cycles_MRP' },
+            { id: 4, name: 'scene_garden_cycles_MRP', sceneAssetId: 'scene_garden_cycles_MRP' },
+            { id: 5, name: 'scene_nature_cycles_MRP', sceneAssetId: 'scene_nature_cycles_MRP' }
+        ];
+        this._ceilingLightMargin = 0.5;
+        this.selectedImageSize = 3;
+        this.selectedEnvironment = 1;
+        this.selectedRenderScene = this.renderScenes[0].sceneAssetId;
+        this.blenderRenderService = this._settingsService.settings.blenderRenderService;
+        this.positions = 1;
+        this.save = false;
+        this.renderRoomImageChanged = new BehaviorSubject('');
+        this.renderingStarted = new Subject();
+        this.renderImageChanged = new BehaviorSubject('');
+        this.renderQueue = [];
+        this.currentQueueRenderItem = new RenderQueueItem();
+        this.currentProductHash = '';
+        this._subs = [];
+        this.service = new Service();
+        this.sceneData = {};
+        this._subs.push(this._settingsService.settingsLoaded.subscribe((loaded) => {
+            if (loaded) {
+                // if (!this._settingsService.settings.options.useNewRender) {
+                this.serverData = this._settingsService.settings.renderParameters;
+                if (this.serverData) {
+                    this.serverData.setup = false;
+                    this.checkConnection();
+                    this._renderServiceHeartBeat();
+                }
+                // }
+            }
+        }), this._buildFurnitureService.buildFinished.subscribe((result) => this._checkVisibleUpdates(result.furniture ? result.furniture : null)));
+    }
+    static MakeWindowMaterialTransparent(material) {
+        // console.log(material);
+        material.transparent = true;
+        material.opacity = Math.min(material.opacity, 0.4);
+        return material;
+    }
+    ngOnDestroy() {
+        this.service.close();
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    checkConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.service.validate() === false) {
+                try {
+                    const url = `${(this.serverData.secure ? 'wss' : 'ws')}://${this.serverData.host}:${this.serverData.port}/service/`;
+                    yield this.service.connect(url).then(() => {
+                        this.serverData.setup = true;
+                    }).catch((rej) => {
+                    });
+                    this.service.on('error', (object) => __awaiter(this, void 0, void 0, function* () {
+                        this.serverData.setup = false;
+                        if (this.connectionStatus !== ConnectionStatus.TryingToConnect) {
+                            this.connectionStatus = ConnectionStatus.IsDisConnected;
+                        }
+                        yield this._onRenderError();
+                    }));
+                    this.service.on('close', (object) => __awaiter(this, void 0, void 0, function* () {
+                        this.serverData.setup = false;
+                        if (this.connectionStatus !== ConnectionStatus.TryingToConnect) {
+                            this.connectionStatus = ConnectionStatus.IsDisConnected;
+                        }
+                        yield this._onRenderClose();
+                    }));
+                }
+                catch (err) {
+                    this.serverData.setup = false;
+                }
+            }
+        });
+    }
+    _renderServiceHeartBeat() {
+        setInterval(() => {
+            if (this.connectionStatus === ConnectionStatus.IsDisConnected) {
+                if (this._settingsService.settings.options.showRenderConnectionInfo) {
+                    const toast = new Toast();
+                    toast.message = 'CONNECTION_WITH_RENDER_SERVICE_LOST';
+                    toast.type = ToastType.Error;
+                    this._toastService.showToast(toast);
+                }
+                this.connectionStatus = ConnectionStatus.TryingToConnect;
+                this.checkConnection();
+            }
+            else if (this.connectionStatus === ConnectionStatus.TryingToConnect) {
+                if (this.serverData.setup === false) {
+                    this._messageBusService.emit(MessageType.RenderServiceTryToConnect);
+                    this.checkConnection();
+                }
+                else {
+                    if (this._settingsService.settings.options.showRenderConnectionInfo) {
+                        const toast = new Toast();
+                        toast.message = 'RE_CONNECTED_WITH_RENDER_SERVICE';
+                        toast.type = ToastType.Success;
+                        this._toastService.showToast(toast);
+                    }
+                    this.connectionStatus = ConnectionStatus.IsConnected;
+                }
+            }
+            else if (this.connectionStatus === ConnectionStatus.IsConnected) {
+                this._messageBusService.emit(MessageType.RenderServiceConnected);
+            }
+        }, 2000);
+    }
+    getRenderParameters(type) {
+        const params = new RenderData();
+        if (type !== RenderModes.RenderIone) {
+            const currentImageSize = this.getImageSizeOnId(this.selectedImageSize);
+            params.imageWidth = Number(currentImageSize.width);
+            params.imageHeight = Number(currentImageSize.height);
+        }
+        params.configuredItem = this._getConfiguredFurnitureItem();
+        params.cameraFOV = this._cameraService.camera.fov;
+        params.type = type;
+        if (type === this.renderModes.RenderShop) {
+            params.cameraFOV = 30;
+            if (this._settingsService.settings.renderParameters.settings !== undefined) {
+                params.settings = this._settingsService.settings.renderParameters.settings;
+            }
+        }
+        else if (type === this.renderModes.RenderRoom) {
+            const renderEnvironment = this.getRenderEnvironmentOnId(this.selectedEnvironment);
+            params.settings = new RenderSettings();
+            params.settings.environmentHdr = renderEnvironment.hdrFile;
+            params.settings.environmentIntensity = renderEnvironment.intensity;
+            const floorPlanHasRooms = this._roomService.rooms[0];
+            const ceilingOrFloor = floorPlanHasRooms ? this._roomService.rooms[0].ceilingPlane : this._floorService.getFloorPlane();
+            const bb = new Box3().setFromObject(ceilingOrFloor);
+            const bbSize = new Vector3();
+            bb.getSize(bbSize);
+            params.settings.extraLights = [
+                {
+                    x1: bb.min.x + this._ceilingLightMargin,
+                    z1: bb.min.z + this._ceilingLightMargin,
+                    x2: bb.max.x - this._ceilingLightMargin,
+                    z2: bb.max.z - this._ceilingLightMargin,
+                    height: floorPlanHasRooms ? ceilingOrFloor.position.y : 2.6,
+                }
+            ];
+        }
+        return params;
+    }
+    // The GLTFExporter needs lights to be configured like this,
+    // otherwise they will all point in the same direction.
+    _fixLight(element) {
+        element.target.parent = element;
+        element.lookAt(element.target.position);
+        element.target.position.x = 0;
+        element.target.position.y = 0;
+        element.target.position.z = -1;
+    }
+    _elementMustBeRemoved(element) {
+        if (element.type === 'PerspectiveCamera') {
+            return true;
+        }
+        if (!element.name) {
+            return false;
+        }
+        const lcName = element.name.toLowerCase();
+        // elements with a name starting with c_ are connectors,
+        // which should not be visible.
+        if (lcName.startsWith('c_')) {
+            return true;
+        }
+        if (element.name.startsWith('snapping-preview-mesh')) {
+            return true;
+        }
+        return false;
+    }
+    _exportToGlb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetPath = this._settingsService.settings.assetPath;
+            // The ground plane looks odd in renders.
+            // The hud-ring and hud-circle are the walkthrough mode marker,
+            // which is not supposed to be rendered.
+            const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle'];
+            let scene;
+            try {
+                scene = this._sceneService.scene.clone();
+                elementsToRemove.forEach(elementName => {
+                    const selectedObject = scene.getObjectByName(elementName);
+                    scene.remove(selectedObject);
+                });
+                // Using the parents, because scene.remove does not seem to work correctly.
+                const parents = [];
+                scene.traverse(element => {
+                    if (element instanceof DirectionalLight || element instanceof SpotLight) {
+                        this._fixLight(element);
+                    }
+                    if (element.visible === false) {
+                        // console.log("Element " + element.name + " was invisible, making it visible.");
+                        element.visible = true;
+                    }
+                    if (element instanceof Mesh && element.name && element.name.startsWith('customMeshWindow')) {
+                        let hasCustomTexture = false;
+                        if (element.material instanceof Material) {
+                            if (element.material instanceof MeshPhongMaterial && element.material.map) {
+                                hasCustomTexture = true;
+                            }
+                            element.material = RenderService.MakeWindowMaterialTransparent(element.material);
+                        }
+                        else if (Array.isArray(element.material)) {
+                            element.material.forEach(function (material, index) {
+                                if (material instanceof MeshPhongMaterial && material.map) {
+                                    hasCustomTexture = true;
+                                }
+                                element.material[index] = RenderService.MakeWindowMaterialTransparent(material);
+                            });
+                        }
+                        if (!hasCustomTexture) {
+                            element.name = 'glass';
+                        }
+                    }
+                    if (this._elementMustBeRemoved(element)) {
+                        parents.push(element.parent);
+                    }
+                });
+                parents.forEach(parent => {
+                    for (let i = parent.children.length - 1; i >= 0; i--) {
+                        if (this._elementMustBeRemoved(parent.children[i])) {
+                            parent.remove(parent.children[i]);
+                        }
+                    }
+                });
+                scene.add(this._cameraService.camera.clone());
+                const options = {
+                    trs: false,
+                    onlyVisible: false,
+                    truncateDrawRange: true,
+                    binary: true,
+                    forceIndices: false,
+                    forcePowerOfTwoTextures: false,
+                    // maxTextureSize: 500,
+                    embedImages: true,
+                };
+                const exporter = new GLTFExporter();
+                let filename = '';
+                return new Promise((resolve, reject) => {
+                    exporter.parse(scene, (exportedScene) => __awaiter(this, void 0, void 0, function* () {
+                        const blob = new Blob([exportedScene], { type: 'application/octet-stream' });
+                        const result = yield FileUtils.SaveGLBFile(blob, assetPath);
+                        if (result !== false) {
+                            filename = result.path;
+                        }
+                        resolve(filename);
+                    }), () => {
+                    }, options);
+                });
+            }
+            catch (e) {
+                throw (e);
+            }
+        });
+    }
+    startRendering() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.renderQueue.length > 0) {
+                yield this.checkConnection();
+                if (this.renderQueue[0].renderProgress === 0 || this.renderQueue[0].renderProgress === undefined) {
+                    this.renderQueue[0].renderStatus = RenderStatus.IsRunning;
+                    this.currentQueueRenderItem = this.renderQueue[0];
+                    this.renderQueue.shift();
+                    this.currentQueueRenderItem.params.glbPath = yield this._exportToGlb()
+                        .catch((e) => {
+                        return Promise.reject(e);
+                    });
+                    yield this._startRenderLoop();
+                }
+            }
+        });
+    }
+    _colijnRenderScene(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const requestParams = [{
+                        id: 1,
+                        jsonrpc: '2.0',
+                        method: 'colijn_render_scene_from_glb',
+                        params: params
+                    }];
+                const xhr = new XMLHttpRequest();
+                xhr.open('POST', this._getRenderServiceUrl());
+                xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        resolve(JSON.parse(xhr.responseText));
+                    }
+                    else {
+                        reject(xhr.statusText);
+                    }
+                };
+                xhr.onerror = () => reject(xhr.statusText);
+                xhr.send(JSON.stringify(requestParams));
+            });
+        });
+    }
+    _startRenderLoop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // temporary solution because large request over websockets are not working because of an error in the software of migenius
+            let [info] = yield this._colijnRenderScene(this.currentQueueRenderItem.params);
+            info = info.result;
+            /*
+            const [ info ] = await this.service.queue_commands()
+              .queue(new Command('colijn_render_scene', this.currentQueueRenderItem.params), true)
+              .execute();
+            */
+            this.currentQueueRenderItem.host = this._settingsService.settings.url;
+            this.currentQueueRenderItem.key = info.scene_name;
+            this.currentQueueRenderItem.type = this.currentQueueRenderItem.params.type;
+            this.currentQueueRenderItem.startDateTime = new Date();
+            this.currentQueueRenderItem.imageSize = this.currentQueueRenderItem.params.imageWidth + ' x ' + this.currentQueueRenderItem.params.imageHeight;
+            this._setRenderProgress(RenderStatus.IsRunning, 0, 0);
+            this.sceneData = info;
+            if (!this.sceneData || this.sceneData.error) {
+                return;
+            }
+            if (this.sceneData.image_info && this.sceneData.image_info.needs_render === true) {
+                this.currentQueueRenderItem.rendered = true;
+                yield this._startRenderStream();
+            }
+            else {
+                this._afterRendering();
+            }
+        });
+    }
+    _quitRenderLoop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sceneData.loop_name !== undefined && this.service.validate() !== false) {
+                const [] = yield this.service.queue_commands()
+                    .queue(new Command('render_loop_quit', {
+                    render_loop_name: this.sceneData.loop_name
+                }))
+                    .execute();
+                this.service.remove_stream(this.sceneData.loop_name);
+            }
+        });
+    }
+    _startRenderStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.streaming.stream = this.service.create_stream();
+                yield this.streaming.stream.start({ render_loop_name: this.sceneData.loop_name, image_format: 'jpg', quality: '100' });
+                this.streaming.stream.on('image', (object) => __awaiter(this, void 0, void 0, function* () {
+                    this._htmlImageDisplay(object, null);
+                    const [progress] = yield this.service.queue_commands()
+                        .queue(new Command('render_loop_get_render_progress', {
+                        render_loop_name: this.sceneData.loop_name
+                    }), true)
+                        .execute();
+                    if (progress.progression !== undefined) {
+                        this._setRenderProgress(RenderStatus.IsRunning, Math.ceil((progress.progression * 100)), progress.iteration);
+                    }
+                    if (object.result === 1) {
+                        yield this.service.queue_commands()
+                            .queue(new Command('render_loop_save_to_disk', {
+                            render_loop_name: this.sceneData.loop_name,
+                            format: 'jpg',
+                            quality: 90,
+                            path: this.sceneData.image_info.url
+                        }), true)
+                            .execute();
+                        if (this.streaming.stream !== undefined) {
+                            this.streaming.stream.stop();
+                        }
+                        yield this._quitRenderLoop();
+                        this._afterRendering();
+                        return;
+                    }
+                    else if (object.result < 0) {
+                        yield this._onRenderError();
+                        return;
+                    }
+                }));
+            }
+            catch (err) {
+                yield this._onRenderError();
+                return;
+            }
+        });
+    }
+    _setRenderProgress(status, progress, iterations) {
+        if (!this.serverData) {
+            return;
+        }
+        this.currentQueueRenderItem.endDateTime = new Date();
+        this.currentQueueRenderItem.renderStatus = status;
+        this.currentQueueRenderItem.renderProgress = progress;
+        if (iterations > 0) {
+            this.currentQueueRenderItem.renderIterations = iterations;
+        }
+        if (this.serverData.renderMode === RenderModes.RenderIone) {
+            const render = this.getRenderOnId(this.currentQueueRenderItem.params.render.id);
+            render.status = status;
+            render.progress = progress;
+        }
+    }
+    _onRenderError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._setRenderProgress(RenderStatus.IsStopped, 0, 0);
+            yield this._quitRenderLoop();
+        });
+    }
+    _onRenderClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._setRenderProgress(RenderStatus.IsStopped, 0, 0);
+        });
+    }
+    _afterRendering() {
+        if (!this.serverData) {
+            return;
+        }
+        this._setRenderProgress(RenderStatus.IsSuccess, 100, 0);
+        const imageUrl = this._settingsService.settings.assetPath.replace('content43/', '') + this.sceneData.image_info.url;
+        if (this.serverData.renderMode === RenderModes.RenderRoom) {
+            this.renderedRoomImages.unshift(imageUrl);
+        }
+        this.renderImageChanged.next(imageUrl);
+        if (this.serverData.renderMode === RenderModes.RenderIone) {
+            const render = this.getRenderOnId(this.currentQueueRenderItem.params.render.id);
+            render.url = imageUrl;
+        }
+        const configuredItem = this.currentQueueRenderItem.params.configuredItem;
+        const isSingleItem = this.serverData.renderMode !== RenderModes.RenderRoom;
+        this._googleTagManager.sendEvent(GoogleTagManagerEvent.Render, {
+            'articleNr': isSingleItem ? configuredItem.sku : 'renderRoom',
+            'product': isSingleItem ? configuredItem.name : 'renderRoom',
+            'dimensions': this.currentQueueRenderItem.imageSize
+        });
+        this.startRendering();
+    }
+    _getRenderServiceUrl() {
+        return `${(this.serverData.secure ? 'https' : 'http')}://${this.serverData.host}:${this.serverData.port}`;
+    }
+    forceRenderImage() {
+        const floorGroup = this._getFirstCustomFloorItemFromScene();
+        if (floorGroup !== null) {
+            this._checkVisibleUpdates(floorGroup, true);
+        }
+    }
+    _checkVisibleUpdates(furniture, forceRender = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.serverData) {
+                return;
+            }
+            if (!furniture) {
+                return;
+            }
+            if (this.serverData.renderMode === this.renderModes.RenderIone) {
+                const object = this._exportService.getExportObjectFromCustomFloorGroup(furniture);
+                this.currentProductHash = object.defaultRenderPath;
+            }
+            else if (this.serverData.renderMode === this.renderModes.RenderShop) {
+                const object = this._exportService.getExportObjectFromCustomFloorGroup(furniture);
+                if (!(JSON.stringify(this.prevItem) !== JSON.stringify(object) || forceRender)) {
+                    return;
+                }
+                this.renderingStarted.next();
+                this.prevItem = object;
+                const queueItem = new RenderQueueItem();
+                queueItem.params = this.getRenderParameters(this.renderModes.RenderShop);
+                queueItem.params.cameraMatrix = this._cameraService.camera.matrixWorldInverse.elements;
+                queueItem.params.forceRender = forceRender;
+                this.renderQueue = [];
+                this.renderQueue.push(queueItem);
+                yield this.startRendering();
+            }
+        });
+    }
+    _htmlImageDisplay(image, urlCreator) {
+        try {
+            urlCreator = urlCreator || (window ? (window.URL || window.webkitURL) : undefined);
+        }
+        catch (e) {
+        }
+        const blob = new Blob([image.image], { type: image.mime_type });
+        const url = urlCreator.createObjectURL(blob);
+        this.renderRoomImageChanged.next(url);
+    }
+    getRenderOnId(id) {
+        let returnRender = null;
+        this.renders.forEach((x) => {
+            if (x.id === id) {
+                returnRender = x;
+            }
+        });
+        return returnRender;
+    }
+    getImageSizeOnId(id) {
+        let returnSize = null;
+        this.imageSizes.forEach((x) => {
+            if (x.id === id) {
+                returnSize = x;
+            }
+        });
+        return returnSize;
+    }
+    getRenderEnvironmentOnId(id) {
+        let returnEnvironment = null;
+        this.renderEnvironments.forEach((renderEnvironment) => {
+            if (renderEnvironment.id === id) {
+                returnEnvironment = renderEnvironment;
+                return;
+            }
+        });
+        return returnEnvironment;
+    }
+    getLightningOnId(id) {
+        let returnLightning = null;
+        this.lightnings.forEach((x) => {
+            if (x.id === id) {
+                returnLightning = x;
+            }
+        });
+        return returnLightning;
+    }
+    /******************************************** Export functions ********************************************/
+    _getFirstCustomFloorItemFromScene() {
+        const children = this._sceneService.scene.children;
+        if (children.length <= 0) {
+            return null;
+        }
+        for (let a = 0; a < children.length; a++) {
+            if (children[a] instanceof CustomFloorItem) {
+                return children[a];
+            }
+            if (children[a] instanceof ItemGroup) {
+                const itemGroup = children[a];
+                if (itemGroup.items.length > 0) {
+                    itemGroup.items.forEach((item) => {
+                        if (item instanceof CustomFloorItem) {
+                            return item;
+                        }
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    _getConfiguredFurnitureItem() {
+        const floorgroup = this._getFirstCustomFloorItemFromScene();
+        if (floorgroup === null) {
+            return null;
+        }
+        return this._exportService.getExportObjectFromCustomFloorGroup(floorgroup);
+    }
+}
+RenderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RenderService, deps: [{ token: i1.HomedecoratorSettingsService }, { token: i2.BuildFurnitureService }, { token: i3.ExportService }, { token: i4.CameraService }, { token: i5.SceneService }, { token: i6.HomedecoratorConnectorService }, { token: i7.HomedecoratorConnectorAdapterService }, { token: i8.ThreedselectorService }, { token: i9.ToastService }, { token: i10.MessageBusService }, { token: i11.GoogleTagManagerService }, { token: i12.RoomService }, { token: i13.FloorService }, { token: i14.LoadFurnitureService }], target: i0.ɵɵFactoryTarget.Injectable });
+RenderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RenderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RenderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }, { type: i2.BuildFurnitureService }, { type: i3.ExportService }, { type: i4.CameraService }, { type: i5.SceneService }, { type: i6.HomedecoratorConnectorService }, { type: i7.HomedecoratorConnectorAdapterService }, { type: i8.ThreedselectorService }, { type: i9.ToastService }, { type: i10.MessageBusService }, { type: i11.GoogleTagManagerService }, { type: i12.RoomService }, { type: i13.FloorService }, { type: i14.LoadFurnitureService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/render/service/render.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Command, Service} from '@migenius/realityserver-client';\r\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\r\nimport {Box3, DirectionalLight, Material, Mesh, MeshPhongMaterial, Object3D, SpotLight, Vector3} from 'three';\r\nimport {GLTFExporter} from 'three/examples/jsm/exporters/GLTFExporter';\r\nimport {Scene} from 'three/src/scenes/Scene';\r\nimport {RenderModes} from '../enum/render-modes';\r\nimport {ConnectionStatus} from '../enum/connection-status';\r\nimport {Render} from '../model/render';\r\nimport {CameraPosition} from '../model/camera-position';\r\nimport {ImageSize} from '../model/image-size';\r\nimport {Lightning} from '../model/lightning';\r\nimport {RenderEnvironment} from '../model/render-environment';\r\nimport {RenderQueueItem} from '../model/render-queue-item';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {BuildFurnitureService} from '../../threedselector/threedselector/service/build-furniture.service';\r\nimport {ExportService} from '../../../core/service/export.service';\r\nimport {CameraService} from '../../core3d/service/camera.service';\r\nimport {SceneService} from '../../core3d/service/scene.service';\r\nimport {HomedecoratorConnectorService} from '../../../core/service/homedecorator-connector.service';\r\nimport {HomedecoratorConnectorAdapterService} from '../../../core/service/homedecorator-connector-adapter.service';\r\nimport {ThreedselectorService} from '../../threedselector/threedselector/service/threedselector.service';\r\nimport {ToastService} from '../../../core/service/toast.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {GoogleTagManagerService} from '../../../service/google-tag-manager.service';\r\nimport {RoomService} from '../../room-planner/components/floorplanner/service/room.service';\r\nimport {FloorService} from '../../core3d/service/floor.service';\r\nimport {LoadFurnitureService} from '../../threedselector/threedselector/service/load-furniture.service';\r\nimport {CustomFloorGroupResult} from '../../core3d/model/custom-floor-group-result';\r\nimport {Toast} from '../../../core/model/toast';\r\nimport {ToastType} from '../../../core/model/toast-type';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {RenderData} from '../model/render-data';\r\nimport {RenderSettings} from '../model/render-settings';\r\nimport {FileUtils} from '../../../core/utils/file.utils';\r\nimport {RenderStatus} from '../enum/render-status';\r\nimport {CustomFloorItem} from '../../core3d/items/custom-floor-item';\r\nimport {Item} from '../../core3d/items/item';\r\nimport {ItemGroup} from '../../core3d/items/item-group';\r\nimport {ExportObject} from '../../../core/model/export-object';\r\nimport {GoogleTagManagerEvent} from '../../../core/enum/google-tag-manager-event.enum';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RenderService implements OnDestroy {\r\n\r\n  public readonly renderModes = RenderModes;\r\n\r\n  public service: Service;\r\n\r\n  public serverData: any;\r\n  public sceneData: any;\r\n  public prevItem: any;\r\n\r\n  public streaming: any = {};\r\n\r\n  public renderedRoomImages: string[] = [];\r\n\r\n  public connectionStatus: ConnectionStatus = ConnectionStatus.IsUndefined;\r\n\r\n  public renders: Render[] = [];\r\n  public cameraPositions: CameraPosition[] = [];\r\n  public imageSizes: ImageSize[] = [\r\n    {id: 1, name: 'Small', width: 400, height: 300},\r\n    {id: 2, name: 'Shop', width: 800, height: 800},\r\n    {id: 3, name: 'Full HD', width: 1920, height: 1080},\r\n    {id: 4, name: '4K', width: 4096, height: 2160}\r\n  ];\r\n\r\n  public lightnings: Lightning[] = [\r\n    {id: 1, name: 'Light', settings: []},\r\n    {id: 2, name: 'Medium', settings: []},\r\n    {id: 3, name: 'Heay', settings: []}\r\n  ];\r\n\r\n  public renderEnvironments: RenderEnvironment[] = [\r\n    {id: 1, name: 'None', hdrFile: '', intensity: 1.0},\r\n    {id: 2, name: 'Modern city', hdrFile: 'canary_wharf_2k.hdr', intensity: 2.5},\r\n    {id: 3, name: 'City park', hdrFile: 'dresden_moat_2k.hdr', intensity: 2.5},\r\n    {id: 4, name: 'Night in the city', hdrFile: 'hansaplatz_2k.hdr', intensity: 1.0},\r\n    {id: 5, name: 'Night in the countryside', hdrFile: 'kloppenheim_02_2k.hdr', intensity: 1.0},\r\n    {id: 6, name: 'Forest', hdrFile: 'nagoya_wall_path_2k.hdr', intensity: 1.0},\r\n    {id: 7, name: 'Snow', hdrFile: 'snowy_forest_path_01_2k.hdr', intensity: 1.0},\r\n    {id: 8, name: 'Pasture', hdrFile: 'spruit_sunrise_2k.hdr', intensity: 1.0},\r\n    {id: 9, name: 'Field', hdrFile: 'sunflowers_2k.hdr', intensity: 1.0},\r\n    {id: 10, name: 'Old city and canals', hdrFile: 'tears_of_steel_bridge_2k.hdr', intensity: 1.0},\r\n    {id: 11, name: 'Estate', hdrFile: 'tiergarten_2k.hdr', intensity: 1.0},\r\n    {id: 12, name: 'Beach', hdrFile: 'umhlanga_sunrise_2k.hdr', intensity: 2.5},\r\n    {id: 13, name: 'Residential area with park', hdrFile: 'urban_street_01_2k.hdr', intensity: 1.0},\r\n    {id: 14, name: 'Residential area', hdrFile: 'urban_street_03_2k.hdr', intensity: 1.0},\r\n  ];\r\n\r\n  public renderScenes: any = [\r\n    {id: 1, name: 'scene_grass_cycles_MRP', sceneAssetId: 'scene_grass_cycles_MRP'},\r\n    {id: 2, name: 'scene_lake_cycles_MRP', sceneAssetId: 'scene_lake_cycles_MRP'},\r\n    {id: 3, name: 'scene_sky_cycles_MRP', sceneAssetId: 'scene_sky_cycles_MRP'},\r\n    {id: 4, name: 'scene_garden_cycles_MRP', sceneAssetId: 'scene_garden_cycles_MRP'},\r\n    {id: 5, name: 'scene_nature_cycles_MRP', sceneAssetId: 'scene_nature_cycles_MRP'}\r\n  ];\r\n\r\n\r\n  private _ceilingLightMargin: number = 0.5;\r\n\r\n  public selectedImageSize: number = 3;\r\n  public selectedEnvironment: number = 1;\r\n  public selectedRenderScene: string = this.renderScenes[0].sceneAssetId;\r\n\r\n  public blenderRenderService: boolean = this._settingsService.settings.blenderRenderService;\r\n\r\n  public positions: number = 1;\r\n  public save: boolean = false;\r\n\r\n  public renderRoomImageChanged: BehaviorSubject<string> = new BehaviorSubject('');\r\n  public renderingStarted: Subject<void> = new Subject();\r\n  public renderImageChanged: BehaviorSubject<string> = new BehaviorSubject('');\r\n\r\n  public renderQueue: any[] = [];\r\n  public currentQueueRenderItem: RenderQueueItem = new RenderQueueItem();\r\n  public currentProductHash: string = '';\r\n  public standAloneCameraMatrix: number[];\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  public static MakeWindowMaterialTransparent(material: Material): Material {\r\n    // console.log(material);\r\n    material.transparent = true;\r\n    material.opacity = Math.min(material.opacity, 0.4);\r\n    return material;\r\n  }\r\n\r\n  constructor(\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _buildFurnitureService: BuildFurnitureService,\r\n    private _exportService: ExportService,\r\n    private _cameraService: CameraService,\r\n    private _sceneService: SceneService,\r\n    private _ione: HomedecoratorConnectorService,\r\n    private _ioneConnectorAdapter: HomedecoratorConnectorAdapterService,\r\n    private _threedSelectorService: ThreedselectorService,\r\n    private _toastService: ToastService,\r\n    private _messageBusService: MessageBusService,\r\n    private _googleTagManager: GoogleTagManagerService,\r\n    private _roomService: RoomService,\r\n    private _floorService: FloorService,\r\n    private _loadFurnitureService: LoadFurnitureService\r\n  ) {\r\n    this.service = new Service();\r\n    this.sceneData = {};\r\n\r\n    this._subs.push(\r\n      this._settingsService.settingsLoaded.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          // if (!this._settingsService.settings.options.useNewRender) {\r\n          this.serverData = this._settingsService.settings.renderParameters;\r\n          if (this.serverData) {\r\n            this.serverData.setup = false;\r\n            this.checkConnection();\r\n            this._renderServiceHeartBeat();\r\n          }\r\n          // }\r\n        }\r\n      }),\r\n      this._buildFurnitureService.buildFinished.subscribe(\r\n        (result: CustomFloorGroupResult) => this._checkVisibleUpdates(result.furniture ? result.furniture : null)\r\n      )\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.service.close();\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public async checkConnection(): Promise<void> {\r\n\r\n    if (this.service.validate() === false) {\r\n\r\n      try {\r\n\r\n        const url = `${(this.serverData.secure ? 'wss' : 'ws')}://${this.serverData.host}:${this.serverData.port}/service/`;\r\n        await this.service.connect(url).then(() => {\r\n          this.serverData.setup = true;\r\n        }).catch((rej) => {\r\n        });\r\n\r\n        this.service.on('error', async (object) => {\r\n          this.serverData.setup = false;\r\n          if (this.connectionStatus !== ConnectionStatus.TryingToConnect) {\r\n            this.connectionStatus = ConnectionStatus.IsDisConnected;\r\n          }\r\n          await this._onRenderError();\r\n        });\r\n        this.service.on('close', async (object) => {\r\n          this.serverData.setup = false;\r\n          if (this.connectionStatus !== ConnectionStatus.TryingToConnect) {\r\n            this.connectionStatus = ConnectionStatus.IsDisConnected;\r\n          }\r\n          await this._onRenderClose();\r\n        });\r\n\r\n      } catch (err) {\r\n\r\n        this.serverData.setup = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _renderServiceHeartBeat(): void {\r\n\r\n    setInterval(() => {\r\n      if (this.connectionStatus === ConnectionStatus.IsDisConnected) {\r\n        if (this._settingsService.settings.options.showRenderConnectionInfo) {\r\n          const toast = new Toast();\r\n          toast.message = 'CONNECTION_WITH_RENDER_SERVICE_LOST';\r\n          toast.type = ToastType.Error;\r\n          this._toastService.showToast(toast);\r\n        }\r\n        this.connectionStatus = ConnectionStatus.TryingToConnect;\r\n        this.checkConnection();\r\n      } else if (this.connectionStatus === ConnectionStatus.TryingToConnect) {\r\n        if (this.serverData.setup === false) {\r\n          this._messageBusService.emit(MessageType.RenderServiceTryToConnect);\r\n          this.checkConnection();\r\n        } else {\r\n          if (this._settingsService.settings.options.showRenderConnectionInfo) {\r\n            const toast = new Toast();\r\n            toast.message = 'RE_CONNECTED_WITH_RENDER_SERVICE';\r\n            toast.type = ToastType.Success;\r\n            this._toastService.showToast(toast);\r\n          }\r\n          this.connectionStatus = ConnectionStatus.IsConnected;\r\n        }\r\n      } else if (this.connectionStatus === ConnectionStatus.IsConnected) {\r\n        this._messageBusService.emit(MessageType.RenderServiceConnected);\r\n      }\r\n    }, 2000);\r\n  }\r\n\r\n  public getRenderParameters(type: RenderModes): RenderData {\r\n\r\n    const params: RenderData = new RenderData();\r\n\r\n    if (type !== RenderModes.RenderIone) {\r\n      const currentImageSize = this.getImageSizeOnId(this.selectedImageSize);\r\n      params.imageWidth = Number(currentImageSize.width);\r\n      params.imageHeight = Number(currentImageSize.height);\r\n    }\r\n\r\n    params.configuredItem = this._getConfiguredFurnitureItem();\r\n    params.cameraFOV = this._cameraService.camera.fov;\r\n    params.type = type;\r\n\r\n    if (type === this.renderModes.RenderShop) {\r\n      params.cameraFOV = 30;\r\n\r\n      if (this._settingsService.settings.renderParameters.settings !== undefined) {\r\n        params.settings = this._settingsService.settings.renderParameters.settings;\r\n      }\r\n    } else if (type === this.renderModes.RenderRoom) {\r\n      const renderEnvironment = this.getRenderEnvironmentOnId(this.selectedEnvironment);\r\n      params.settings = new RenderSettings();\r\n      params.settings.environmentHdr = renderEnvironment.hdrFile;\r\n      params.settings.environmentIntensity = renderEnvironment.intensity;\r\n\r\n      const floorPlanHasRooms = this._roomService.rooms[0];\r\n      const ceilingOrFloor = floorPlanHasRooms ? this._roomService.rooms[0].ceilingPlane : this._floorService.getFloorPlane();\r\n      const bb = new Box3().setFromObject(ceilingOrFloor);\r\n      const bbSize: Vector3 = new Vector3();\r\n      bb.getSize(bbSize);\r\n      params.settings.extraLights = [\r\n        {\r\n          x1: bb.min.x + this._ceilingLightMargin,\r\n          z1: bb.min.z + this._ceilingLightMargin,\r\n          x2: bb.max.x - this._ceilingLightMargin,\r\n          z2: bb.max.z - this._ceilingLightMargin,\r\n          height: floorPlanHasRooms ? ceilingOrFloor.position.y : 2.6,\r\n        }\r\n      ];\r\n    }\r\n\r\n    return params;\r\n  }\r\n\r\n  // The GLTFExporter needs lights to be configured like this,\r\n  // otherwise they will all point in the same direction.\r\n  private _fixLight(element: DirectionalLight | SpotLight): void {\r\n    element.target.parent = element;\r\n    element.lookAt(element.target.position);\r\n    element.target.position.x = 0;\r\n    element.target.position.y = 0;\r\n    element.target.position.z = -1;\r\n  }\r\n\r\n  private _elementMustBeRemoved(element: Object3D): boolean {\r\n    if (element.type === 'PerspectiveCamera') {\r\n      return true;\r\n    }\r\n    if (!element.name) {\r\n      return false;\r\n    }\r\n\r\n    const lcName = element.name.toLowerCase();\r\n    // elements with a name starting with c_ are connectors,\r\n    // which should not be visible.\r\n    if (lcName.startsWith('c_')) {\r\n      return true;\r\n    }\r\n\r\n    if (element.name.startsWith('snapping-preview-mesh')) {\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  private async _exportToGlb(): Promise<string> {\r\n    const assetPath: string = this._settingsService.settings.assetPath;\r\n    // The ground plane looks odd in renders.\r\n    // The hud-ring and hud-circle are the walkthrough mode marker,\r\n    // which is not supposed to be rendered.\r\n    const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle'];\r\n\r\n    let scene: Scene;\r\n    try {\r\n      scene = this._sceneService.scene.clone();\r\n\r\n      elementsToRemove.forEach(elementName => {\r\n        const selectedObject: Object3D = scene.getObjectByName(elementName);\r\n        scene.remove(selectedObject);\r\n      });\r\n      // Using the parents, because scene.remove does not seem to work correctly.\r\n      const parents = [];\r\n      scene.traverse(element => {\r\n        if (element instanceof DirectionalLight || element instanceof SpotLight) {\r\n          this._fixLight(element);\r\n        }\r\n\r\n        if (element.visible === false) {\r\n          // console.log(\"Element \" + element.name + \" was invisible, making it visible.\");\r\n          element.visible = true;\r\n        }\r\n\r\n        if (element instanceof Mesh && element.name && element.name.startsWith('customMeshWindow')) {\r\n          let hasCustomTexture: boolean = false;\r\n\r\n          if (element.material instanceof Material) {\r\n\r\n            if (element.material instanceof MeshPhongMaterial && element.material.map) {\r\n              hasCustomTexture = true;\r\n            }\r\n            element.material = RenderService.MakeWindowMaterialTransparent(element.material);\r\n\r\n          } else if (Array.isArray(element.material)) {\r\n\r\n            element.material.forEach(function (material: Material, index) {\r\n              if (material instanceof MeshPhongMaterial && material.map) {\r\n                hasCustomTexture = true;\r\n              }\r\n              element.material[index] = RenderService.MakeWindowMaterialTransparent(material);\r\n            });\r\n          }\r\n\r\n          if (!hasCustomTexture) {\r\n            element.name = 'glass';\r\n          }\r\n        }\r\n\r\n        if (this._elementMustBeRemoved(element)) {\r\n          parents.push(element.parent);\r\n        }\r\n      });\r\n      parents.forEach(parent => {\r\n        for (let i = parent.children.length - 1; i >= 0; i--) {\r\n          if (this._elementMustBeRemoved(parent.children[i])) {\r\n            parent.remove(parent.children[i]);\r\n          }\r\n        }\r\n      });\r\n      scene.add(this._cameraService.camera.clone());\r\n\r\n      const options = {\r\n        trs: false,\r\n        onlyVisible: false,\r\n        truncateDrawRange: true,\r\n        binary: true,\r\n        forceIndices: false,\r\n        forcePowerOfTwoTextures: false,\r\n        // maxTextureSize: 500,\r\n        embedImages: true,\r\n      };\r\n\r\n      const exporter: GLTFExporter = new GLTFExporter();\r\n      let filename: string = '';\r\n\r\n      return new Promise((resolve: Function, reject: Function) => {\r\n        exporter.parse(scene, async (exportedScene: ArrayBuffer) => {\r\n          const blob: Blob = new Blob([exportedScene], {type: 'application/octet-stream'});\r\n          const result: any = await FileUtils.SaveGLBFile(blob, assetPath);\r\n          if (result !== false) {\r\n            filename = result.path;\r\n          }\r\n          resolve(filename);\r\n        }, () => {\r\n        }, options);\r\n      });\r\n    } catch (e) {\r\n      throw (e);\r\n    }\r\n  }\r\n\r\n  public async startRendering(): Promise<void> {\r\n\r\n    if (this.renderQueue.length > 0) {\r\n\r\n      await this.checkConnection();\r\n\r\n      if (this.renderQueue[0].renderProgress === 0 || this.renderQueue[0].renderProgress === undefined) {\r\n        this.renderQueue[0].renderStatus = RenderStatus.IsRunning;\r\n        this.currentQueueRenderItem = this.renderQueue[0];\r\n        this.renderQueue.shift();\r\n\r\n        this.currentQueueRenderItem.params.glbPath = await this._exportToGlb()\r\n          .catch((e) => {\r\n            return Promise.reject(e);\r\n          });\r\n        await this._startRenderLoop();\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _colijnRenderScene(params: any): Promise<any> {\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const requestParams = [{\r\n        id: 1,\r\n        jsonrpc: '2.0',\r\n        method: 'colijn_render_scene_from_glb',\r\n        params: params\r\n      }];\r\n      const xhr = new XMLHttpRequest();\r\n      xhr.open('POST', this._getRenderServiceUrl());\r\n      xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\r\n      xhr.onload = () => {\r\n        if (xhr.status >= 200 && xhr.status < 300) {\r\n          resolve(JSON.parse(xhr.responseText));\r\n        } else {\r\n          reject(xhr.statusText);\r\n        }\r\n      };\r\n      xhr.onerror = () => reject(xhr.statusText);\r\n      xhr.send(JSON.stringify(requestParams));\r\n    });\r\n  }\r\n\r\n  private async _startRenderLoop(): Promise<void> {\r\n\r\n    // temporary solution because large request over websockets are not working because of an error in the software of migenius\r\n    let [info] = await this._colijnRenderScene(this.currentQueueRenderItem.params);\r\n    info = info.result;\r\n\r\n    /*\r\n    const [ info ] = await this.service.queue_commands()\r\n      .queue(new Command('colijn_render_scene', this.currentQueueRenderItem.params), true)\r\n      .execute();\r\n    */\r\n\r\n    this.currentQueueRenderItem.host = this._settingsService.settings.url;\r\n    this.currentQueueRenderItem.key = info.scene_name;\r\n    this.currentQueueRenderItem.type = this.currentQueueRenderItem.params.type;\r\n    this.currentQueueRenderItem.startDateTime = new Date();\r\n    this.currentQueueRenderItem.imageSize = this.currentQueueRenderItem.params.imageWidth + ' x ' + this.currentQueueRenderItem.params.imageHeight;\r\n\r\n    this._setRenderProgress(RenderStatus.IsRunning, 0, 0);\r\n\r\n    this.sceneData = info;\r\n    if (!this.sceneData || this.sceneData.error) {\r\n      return;\r\n    }\r\n    if (this.sceneData.image_info && this.sceneData.image_info.needs_render === true) {\r\n      this.currentQueueRenderItem.rendered = true;\r\n      await this._startRenderStream();\r\n    } else {\r\n      this._afterRendering();\r\n    }\r\n  }\r\n\r\n  private async _quitRenderLoop() {\r\n\r\n    if (this.sceneData.loop_name !== undefined && this.service.validate() !== false) {\r\n      const [] = await this.service.queue_commands()\r\n        .queue(new Command('render_loop_quit', {\r\n          render_loop_name: this.sceneData.loop_name\r\n        }))\r\n        .execute();\r\n      this.service.remove_stream(this.sceneData.loop_name);\r\n    }\r\n  }\r\n\r\n  private async _startRenderStream() {\r\n\r\n    try {\r\n\r\n      this.streaming.stream = this.service.create_stream();\r\n      await this.streaming.stream.start({render_loop_name: this.sceneData.loop_name, image_format: 'jpg', quality: '100'});\r\n\r\n      this.streaming.stream.on('image', async (object) => {\r\n        this._htmlImageDisplay(object, null);\r\n        const [progress] = await this.service.queue_commands()\r\n          .queue(new Command('render_loop_get_render_progress', {\r\n            render_loop_name: this.sceneData.loop_name\r\n          }), true)\r\n          .execute();\r\n\r\n        if (progress.progression !== undefined) {\r\n          this._setRenderProgress(RenderStatus.IsRunning, Math.ceil((progress.progression * 100)), progress.iteration);\r\n        }\r\n\r\n        if (object.result === 1) {\r\n\r\n          await this.service.queue_commands()\r\n            .queue(new Command('render_loop_save_to_disk', {\r\n              render_loop_name: this.sceneData.loop_name,\r\n              format: 'jpg',\r\n              quality: 90,\r\n              path: this.sceneData.image_info.url\r\n            }), true)\r\n            .execute();\r\n\r\n          if (this.streaming.stream !== undefined) {\r\n            this.streaming.stream.stop();\r\n          }\r\n          await this._quitRenderLoop();\r\n          this._afterRendering();\r\n          return;\r\n\r\n        } else if (object.result < 0) {\r\n\r\n          await this._onRenderError();\r\n          return;\r\n        }\r\n      });\r\n\r\n    } catch (err) {\r\n\r\n      await this._onRenderError();\r\n      return;\r\n    }\r\n  }\r\n\r\n  private _setRenderProgress(status: RenderStatus, progress: number, iterations: number): void {\r\n    if (!this.serverData) {\r\n      return;\r\n    }\r\n    this.currentQueueRenderItem.endDateTime = new Date();\r\n    this.currentQueueRenderItem.renderStatus = status;\r\n    this.currentQueueRenderItem.renderProgress = progress;\r\n    if (iterations > 0) {\r\n      this.currentQueueRenderItem.renderIterations = iterations;\r\n    }\r\n\r\n    if (this.serverData.renderMode === RenderModes.RenderIone) {\r\n      const render: Render = this.getRenderOnId(this.currentQueueRenderItem.params.render.id);\r\n      render.status = status;\r\n      render.progress = progress;\r\n    }\r\n  }\r\n\r\n  private async _onRenderError(): Promise<void> {\r\n\r\n    this._setRenderProgress(RenderStatus.IsStopped, 0, 0);\r\n    await this._quitRenderLoop();\r\n  }\r\n\r\n  private async _onRenderClose(): Promise<void> {\r\n\r\n    this._setRenderProgress(RenderStatus.IsStopped, 0, 0);\r\n  }\r\n\r\n  private _afterRendering(): void {\r\n    if (!this.serverData) {\r\n      return;\r\n    }\r\n\r\n    this._setRenderProgress(RenderStatus.IsSuccess, 100, 0);\r\n\r\n    const imageUrl = this._settingsService.settings.assetPath.replace('content43/', '') + this.sceneData.image_info.url;\r\n    if (this.serverData.renderMode === RenderModes.RenderRoom) {\r\n      this.renderedRoomImages.unshift(imageUrl);\r\n    }\r\n\r\n    this.renderImageChanged.next(imageUrl);\r\n\r\n    if (this.serverData.renderMode === RenderModes.RenderIone) {\r\n      const render: Render = this.getRenderOnId(this.currentQueueRenderItem.params.render.id);\r\n      render.url = imageUrl;\r\n    }\r\n\r\n    const configuredItem = this.currentQueueRenderItem.params.configuredItem;\r\n    const isSingleItem = this.serverData.renderMode !== RenderModes.RenderRoom;\r\n    this._googleTagManager.sendEvent(GoogleTagManagerEvent.Render, {\r\n      'articleNr': isSingleItem ? configuredItem.sku : 'renderRoom',\r\n      'product': isSingleItem ? configuredItem.name : 'renderRoom',\r\n      'dimensions': this.currentQueueRenderItem.imageSize\r\n    });\r\n\r\n    this.startRendering();\r\n  }\r\n\r\n  private _getRenderServiceUrl(): string {\r\n\r\n    return `${(this.serverData.secure ? 'https' : 'http')}://${this.serverData.host}:${this.serverData.port}`;\r\n  }\r\n\r\n  public forceRenderImage(): void {\r\n    const floorGroup = this._getFirstCustomFloorItemFromScene();\r\n    if (floorGroup !== null) {\r\n      this._checkVisibleUpdates(floorGroup, true);\r\n    }\r\n  }\r\n\r\n  private async _checkVisibleUpdates(furniture: Item, forceRender: boolean = false): Promise<void> {\r\n    if (!this.serverData) {\r\n      return;\r\n    }\r\n\r\n    if (!furniture) {\r\n      return;\r\n    }\r\n\r\n    if (this.serverData.renderMode === this.renderModes.RenderIone) {\r\n      const object = this._exportService.getExportObjectFromCustomFloorGroup(furniture);\r\n      this.currentProductHash = object.defaultRenderPath;\r\n    } else if (this.serverData.renderMode === this.renderModes.RenderShop) {\r\n      const object = this._exportService.getExportObjectFromCustomFloorGroup(furniture);\r\n\r\n      if (!(JSON.stringify(this.prevItem) !== JSON.stringify(object) || forceRender)) {\r\n        return;\r\n      }\r\n\r\n      this.renderingStarted.next();\r\n      this.prevItem = object;\r\n      const queueItem = new RenderQueueItem();\r\n      queueItem.params = this.getRenderParameters(this.renderModes.RenderShop);\r\n      queueItem.params.cameraMatrix = this._cameraService.camera.matrixWorldInverse.elements;\r\n      queueItem.params.forceRender = forceRender;\r\n      this.renderQueue = [];\r\n      this.renderQueue.push(queueItem);\r\n      await this.startRendering();\r\n    }\r\n  }\r\n\r\n  private _htmlImageDisplay(image, urlCreator) {\r\n\r\n    try {\r\n      urlCreator = urlCreator || (window ? (window.URL || (window as any).webkitURL) : undefined);\r\n    } catch (e) {\r\n\r\n    }\r\n\r\n    const blob = new Blob([image.image], {type: image.mime_type});\r\n    const url = urlCreator.createObjectURL(blob);\r\n\r\n    this.renderRoomImageChanged.next(url);\r\n  }\r\n\r\n  public getRenderOnId(id: number): any {\r\n    let returnRender = null;\r\n    this.renders.forEach((x: Render) => {\r\n      if (x.id === id) {\r\n        returnRender = x;\r\n      }\r\n    });\r\n    return returnRender;\r\n  }\r\n\r\n  public getImageSizeOnId(id: number): any {\r\n    let returnSize = null;\r\n    this.imageSizes.forEach((x: ImageSize) => {\r\n      if (x.id === id) {\r\n        returnSize = x;\r\n      }\r\n    });\r\n    return returnSize;\r\n  }\r\n\r\n  public getRenderEnvironmentOnId(id: number): RenderEnvironment {\r\n    let returnEnvironment = null;\r\n    this.renderEnvironments.forEach((renderEnvironment: RenderEnvironment) => {\r\n      if (renderEnvironment.id === id) {\r\n        returnEnvironment = renderEnvironment;\r\n        return;\r\n      }\r\n    });\r\n    return returnEnvironment;\r\n  }\r\n\r\n  public getLightningOnId(id: number): any {\r\n    let returnLightning = null;\r\n    this.lightnings.forEach((x: Lightning) => {\r\n      if (x.id === id) {\r\n        returnLightning = x;\r\n      }\r\n    });\r\n    return returnLightning;\r\n  }\r\n\r\n\r\n  /******************************************** Export functions ********************************************/\r\n\r\n  private _getFirstCustomFloorItemFromScene(): CustomFloorItem | null {\r\n\r\n    const children = this._sceneService.scene.children;\r\n\r\n    if (children.length <= 0) {\r\n      return null;\r\n    }\r\n\r\n    for (let a = 0; a < children.length; a++) {\r\n      if (children[a] instanceof CustomFloorItem) {\r\n        return <CustomFloorItem>children[a];\r\n      }\r\n      if (children[a] instanceof ItemGroup) {\r\n        const itemGroup = <ItemGroup>children[a];\r\n        if (itemGroup.items.length > 0) {\r\n          itemGroup.items.forEach((item: any) => {\r\n            if (item instanceof CustomFloorItem) {\r\n              return item;\r\n            }\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private _getConfiguredFurnitureItem(): ExportObject | null {\r\n\r\n    const floorgroup = this._getFirstCustomFloorItemFromScene();\r\n\r\n    if (floorgroup === null) {\r\n      return null;\r\n    }\r\n\r\n    return this._exportService.getExportObjectFromCustomFloorGroup(floorgroup);\r\n  }\r\n}\r\n"]}