@rocketshow/designer 1.32.0 → 1.33.0

package/esm2022/lib/services/preview.service.mjs

@@ -0,0 +1,496 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as THREE from 'three';
+import { EffectCurve } from '../models/effect-curve';
+import { FixtureCapabilityType } from '../models/fixture-capability';
+import { FixtureChannelValue } from '../models/fixture-channel-value';
+import { PresetRegionScene } from '../models/preset-region-scene';
+import { FixtureService } from './fixture.service';
+import { PresetService } from './preset.service';
+import { ProjectService } from './project.service';
+import { SceneService } from './scene.service';
+import { TimelineService } from './timeline.service';
+import { UniverseService } from './universe.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./preset.service";
+import * as i2 from "./fixture.service";
+import * as i3 from "./scene.service";
+import * as i4 from "./timeline.service";
+import * as i5 from "./universe.service";
+import * as i6 from "./project.service";
+export class PreviewService {
+    constructor(presetService, fixtureService, sceneService, timelineService, universeService, projectService) {
+        this.presetService = presetService;
+        this.fixtureService = fixtureService;
+        this.sceneService = sceneService;
+        this.timelineService = timelineService;
+        this.universeService = universeService;
+        this.projectService = projectService;
+        this.doUpdateFixtureSetup = new Subject();
+        this.stageMeshes = [];
+        this.stageMaterial = new THREE.MeshStandardMaterial({
+            color: 0x0d0d0d,
+            // roughness: 0.5,
+            // metalness: 0.5,
+        });
+    }
+    getAlreadyCalculatedFixture(fixtures, fixtureIndex) {
+        // Has this fixture already been calculated (same universe and dmx start address as a fixture before)
+        // --> return it
+        for (let i = 0; i < fixtureIndex; i++) {
+            const calculatedFixture = fixtures[i];
+            if (calculatedFixture.fixture.dmxUniverseUuid === fixtures[fixtureIndex].fixture.dmxUniverseUuid &&
+                calculatedFixture.fixture.dmxFirstChannel === fixtures[fixtureIndex].fixture.dmxFirstChannel) {
+                return calculatedFixture;
+            }
+        }
+        return undefined;
+    }
+    getPresets(timeMillis) {
+        // Get relevant presets in correct order to process with their corresponding scene, if available
+        let presets = [];
+        if (this.timelineService.playState === 'playing') {
+            // Only use active presets in current regions
+            presets = this.timelineService.getPresetsInTime(timeMillis);
+        }
+        else {
+            if (this.projectService.project.previewPreset) {
+                // Only preview the selected preset
+                if (this.presetService.selectedPreset) {
+                    presets.push(new PresetRegionScene(this.presetService.selectedPreset, undefined, undefined));
+                }
+            }
+            else {
+                // Preview the selected scenes
+                for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {
+                    for (const scene of this.sceneService.selectedScenes) {
+                        if (scene.uuid === this.projectService.project.scenes[sceneIndex].uuid) {
+                            for (let presetIndex = this.projectService.project.presets.length - 1; presetIndex >= 0; presetIndex--) {
+                                for (const presetUuid of scene.presetUuids) {
+                                    // Loop over the presets in the preset service to retain the preset order
+                                    if (presetUuid === this.projectService.project.presets[presetIndex].uuid) {
+                                        presets.push(new PresetRegionScene(this.projectService.project.presets[presetIndex], undefined, scene));
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return presets;
+    }
+    mixChannelValue(existingChannelValues, channelValue, intensityPercentage, defaultValue = 0) {
+        let newValue = channelValue.value;
+        let existingValue = defaultValue;
+        if (intensityPercentage < 1) {
+            // We need to mix a possibly existing value (or the default value 0) with the new value (fading)
+            // Get the existent value for this property
+            for (const existingChannelValue of existingChannelValues) {
+                if (existingChannelValue.channelName === channelValue.channelName &&
+                    existingChannelValue.profileUuid === channelValue.profileUuid) {
+                    existingValue = existingChannelValue.value;
+                    break;
+                }
+            }
+            // Mix the existing value with the new value
+            newValue = existingValue * (1 - intensityPercentage) + newValue * intensityPercentage;
+        }
+        // Remove the existent value, if available
+        for (let i = 0; i < existingChannelValues.length; i++) {
+            if (existingChannelValues[i].channelName === channelValue.channelName &&
+                existingChannelValues[i].profileUuid === channelValue.profileUuid) {
+                existingChannelValues.splice(i, 1);
+                break;
+            }
+        }
+        // Add the new value
+        const fixtureChannelValue = new FixtureChannelValue();
+        fixtureChannelValue.channelName = channelValue.channelName;
+        fixtureChannelValue.profileUuid = channelValue.profileUuid;
+        fixtureChannelValue.value = newValue;
+        existingChannelValues.push(fixtureChannelValue);
+    }
+    // Get the fixture index inside the passed preset (used for chasing)
+    getFixtureIndex(preset, fixtureUuid) {
+        let index = 0;
+        const countedDmxChannels = [];
+        // Loop over the global fixtures to retain the order
+        for (const fixture of this.projectService.project.fixtures) {
+            for (const presetFixtureUuid of preset.fixtureUuids) {
+                if (presetFixtureUuid === fixture.uuid) {
+                    if (fixture.uuid === fixtureUuid) {
+                        return index;
+                    }
+                    // don't count fixtures on the same channel as already counted ones
+                    if (!countedDmxChannels.includes(fixture.dmxFirstChannel)) {
+                        countedDmxChannels.push(fixture.dmxFirstChannel);
+                        index++;
+                    }
+                    break;
+                }
+            }
+        }
+        // Not found in the preset
+        return undefined;
+    }
+    getPresetIntensity(preset, timeMillis) {
+        // When fading is in progress (on preset or scene-level), the current preset does not
+        // fully cover underlying values.
+        // -> 0 = no covering at all, 1 = fully cover (no fading)
+        let intensityPercentageScene = 1;
+        let intensityPercentagePreset = 1;
+        let intensityPercentage = 1;
+        if (preset.region && preset.scene) {
+            // Fade out is stronger than fade in (if they overlap)
+            // Take away intensity for scene fading
+            const sceneStartMillis = preset.scene.fadeInPre ? preset.region.startMillis - preset.scene.fadeInMillis : preset.region.startMillis;
+            const sceneEndMillis = preset.scene.fadeOutPost ? preset.region.endMillis + preset.scene.fadeOutMillis : preset.region.endMillis;
+            if (timeMillis > sceneEndMillis - preset.scene.fadeOutMillis && timeMillis < sceneEndMillis) {
+                // Scene fades out
+                intensityPercentageScene = (sceneEndMillis - timeMillis) / preset.scene.fadeOutMillis;
+            }
+            else if (timeMillis < sceneStartMillis + preset.scene.fadeInMillis && timeMillis > sceneStartMillis) {
+                // Scene fades in
+                intensityPercentageScene = (timeMillis - sceneStartMillis) / preset.scene.fadeInMillis;
+            }
+        }
+        if (preset.region && preset.preset) {
+            // Take away intensity for preset fading
+            let presetStartMillis = preset.preset.startMillis === undefined ? preset.region.startMillis : preset.region.startMillis + preset.preset.startMillis;
+            let presetEndMillis = preset.preset.endMillis === undefined ? preset.region.endMillis : preset.region.startMillis + preset.preset.endMillis;
+            // extend the running time, if fading is done outside the boundaries
+            presetStartMillis -= preset.preset.fadeInPre ? preset.preset.fadeInMillis : 0;
+            presetEndMillis += preset.preset.fadeOutPost ? preset.preset.fadeOutMillis : 0;
+            if (timeMillis > presetEndMillis - preset.preset.fadeOutMillis && timeMillis < presetEndMillis) {
+                // Preset fades out
+                intensityPercentagePreset = (presetEndMillis - timeMillis) / preset.preset.fadeOutMillis;
+            }
+            else if (timeMillis < presetStartMillis + preset.preset.fadeInMillis && timeMillis > presetStartMillis) {
+                // Preset fades in
+                intensityPercentagePreset = (timeMillis - presetStartMillis) / preset.preset.fadeInMillis;
+            }
+            intensityPercentage = intensityPercentageScene * intensityPercentagePreset;
+        }
+        return intensityPercentage;
+    }
+    mixCapabilityValues(preset, cachedFixture, values, intensityPercentage) {
+        let hasColor = false;
+        // mix the preset capability values
+        for (const presetCapabilityValue of preset.preset.fixtureCapabilityValues) {
+            for (const cachedChannel of cachedFixture.channels) {
+                if (cachedChannel.channel) {
+                    for (const channelCapability of cachedChannel.capabilities) {
+                        if (this.fixtureService.capabilitiesMatch(presetCapabilityValue.type, channelCapability.capability.type, presetCapabilityValue.color, channelCapability.capability.color, presetCapabilityValue.wheel, channelCapability.wheelName, presetCapabilityValue.profileUuid, cachedFixture.profile.uuid)) {
+                            // the capabilities match -> apply the value, if possible
+                            if ((presetCapabilityValue.type === FixtureCapabilityType.Intensity ||
+                                presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) &&
+                                presetCapabilityValue.valuePercentage >= 0) {
+                                // intensity and colorIntensity (dimmer and color)
+                                const valuePercentage = presetCapabilityValue.valuePercentage;
+                                const defaultValue = 0;
+                                // brightness property
+                                if (cachedChannel.capabilities.length === 1) {
+                                    // the only capability in this channel
+                                    const fixtureChannelValue = new FixtureChannelValue();
+                                    fixtureChannelValue.channelName = cachedChannel.name;
+                                    fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                    fixtureChannelValue.value = cachedChannel.maxValue * valuePercentage;
+                                    this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);
+                                    if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {
+                                        hasColor = true;
+                                    }
+                                }
+                                else {
+                                    // more than one capability in the channel
+                                    if (channelCapability.capability.brightness === 'off' && valuePercentage === 0) {
+                                        const fixtureChannelValue = new FixtureChannelValue();
+                                        fixtureChannelValue.channelName = cachedChannel.name;
+                                        fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                        fixtureChannelValue.value = channelCapability.centerValue;
+                                        this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);
+                                        if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {
+                                            hasColor = true;
+                                        }
+                                    }
+                                    else if ((channelCapability.capability.brightnessStart === 'dark' || channelCapability.capability.brightnessStart === 'off') &&
+                                        channelCapability.capability.brightnessEnd === 'bright') {
+                                        const value = (channelCapability.capability.dmxRange[1] - channelCapability.capability.dmxRange[0]) * valuePercentage +
+                                            channelCapability.capability.dmxRange[0];
+                                        const fixtureChannelValue = new FixtureChannelValue();
+                                        fixtureChannelValue.channelName = cachedChannel.name;
+                                        fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                        fixtureChannelValue.value = value;
+                                        this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);
+                                        if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {
+                                            hasColor = true;
+                                        }
+                                    }
+                                }
+                            }
+                            else if ((presetCapabilityValue.type === FixtureCapabilityType.Pan || presetCapabilityValue.type === FixtureCapabilityType.Tilt) &&
+                                presetCapabilityValue.valuePercentage >= 0) {
+                                const fixtureChannelValue = new FixtureChannelValue();
+                                fixtureChannelValue.channelName = cachedChannel.name;
+                                fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                fixtureChannelValue.value = cachedChannel.maxValue * presetCapabilityValue.valuePercentage;
+                                this.mixChannelValue(values, fixtureChannelValue, 1);
+                            }
+                            else if (presetCapabilityValue.type === FixtureCapabilityType.WheelSlot &&
+                                channelCapability.capability.slotNumber === presetCapabilityValue.slotNumber) {
+                                // wheel slot (color, gobo, etc.)
+                                const fixtureChannelValue = new FixtureChannelValue();
+                                fixtureChannelValue.channelName = cachedChannel.name;
+                                fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                fixtureChannelValue.value = channelCapability.centerValue;
+                                this.mixChannelValue(values, fixtureChannelValue, 1);
+                                // check, whether we just set a color wheel value
+                                if (channelCapability.wheelIsColor) {
+                                    hasColor = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                // approximate the color from a color or a different color wheel, if necessary
+                if (!hasColor && cachedChannel.colorWheel) {
+                    const capability = this.presetService.getApproximatedColorWheelCapability(preset.preset, cachedChannel);
+                    if (capability) {
+                        // we found an approximated color in the available wheel channel
+                        const fixtureChannelValue = new FixtureChannelValue();
+                        fixtureChannelValue.channelName = cachedChannel.name;
+                        fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                        fixtureChannelValue.value = capability.centerValue;
+                        this.mixChannelValue(values, fixtureChannelValue, 1);
+                    }
+                }
+            }
+        }
+    }
+    mixChannelValues(preset, cachedFixture, values, intensityPercentage) {
+        // mix the preset channel values
+        for (const cachedChannel of cachedFixture.channels) {
+            if (cachedChannel.channel) {
+                for (const channelValue of preset.preset.fixtureChannelValues) {
+                    if (cachedFixture.profile.uuid === channelValue.profileUuid && cachedChannel.name === channelValue.channelName) {
+                        this.mixChannelValue(values, channelValue, intensityPercentage);
+                    }
+                }
+            }
+        }
+    }
+    mixEffects(timeMillis, fixtureIndex, preset, cachedFixture, values, intensityPercentage) {
+        for (const effect of preset.preset.effects) {
+            if (effect.visible) {
+                // EffectCurve
+                if (effect instanceof EffectCurve) {
+                    const effectCurve = effect;
+                    // capabilities
+                    for (const capability of effectCurve.capabilities) {
+                        for (const cachedChannel of cachedFixture.channels) {
+                            for (const channelCapability of cachedChannel.capabilities) {
+                                if (this.fixtureService.capabilitiesMatch(capability.type, channelCapability.capability.type, capability.color, channelCapability.capability.color, null, null, null, null)) {
+                                    const fixtureChannelValue = new FixtureChannelValue();
+                                    fixtureChannelValue.channelName = cachedChannel.name;
+                                    fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                    fixtureChannelValue.value = cachedChannel.maxValue * effectCurve.getValueAtMillis(timeMillis, fixtureIndex);
+                                    this.mixChannelValue(values, fixtureChannelValue, intensityPercentage);
+                                }
+                            }
+                        }
+                    }
+                    // channels
+                    for (const channelProfile of effectCurve.channels) {
+                        if (channelProfile.profileUuid === cachedFixture.profile.uuid) {
+                            for (const channel of channelProfile.channels) {
+                                for (const cachedChannel of cachedFixture.channels) {
+                                    if (cachedChannel.name === channel) {
+                                        const fixtureChannelValue = new FixtureChannelValue();
+                                        fixtureChannelValue.channelName = cachedChannel.name;
+                                        fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                                        fixtureChannelValue.value = cachedChannel.maxValue * effectCurve.getValueAtMillis(timeMillis, fixtureIndex);
+                                        this.mixChannelValue(values, fixtureChannelValue, intensityPercentage);
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+                // TODO other effects (PanTilt, etc.)
+            }
+        }
+    }
+    // return all fixture uuids with their corresponding channel values
+    getChannelValues(timeMillis, presets) {
+        // Loop over all relevant presets and calc the property values from the presets (capabilities and effects)
+        const calculatedFixtures = new Map();
+        for (let i = 0; i < this.fixtureService.cachedFixtures.length; i++) {
+            const cachedFixture = this.fixtureService.cachedFixtures[i];
+            // all values of the current fixture channels
+            let values = [];
+            const alreadyCalculatedFixture = this.getAlreadyCalculatedFixture(this.fixtureService.cachedFixtures, i);
+            if (alreadyCalculatedFixture) {
+                // only relevant for the preview --> reuse all calculated values
+                values = Object.assign([], calculatedFixtures.get(alreadyCalculatedFixture));
+            }
+            else {
+                // apply the default values
+                for (const cachedChannel of cachedFixture.channels) {
+                    if (cachedChannel.channel) {
+                        if (cachedChannel.channel.defaultValue) {
+                            const fixtureChannelValue = new FixtureChannelValue();
+                            fixtureChannelValue.channelName = cachedChannel.name;
+                            fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;
+                            fixtureChannelValue.value = cachedChannel.defaultValue;
+                            this.mixChannelValue(values, fixtureChannelValue, 1);
+                        }
+                    }
+                }
+                for (const preset of presets) {
+                    // search for this fixture in the preset and get it's preset-specific index (for chasing effects)
+                    const fixtureIndex = this.getFixtureIndex(preset.preset, cachedFixture.fixture.uuid);
+                    if (fixtureIndex >= 0) {
+                        // this fixture is also in the preset -> mix the required values (overwrite existing values,
+                        // if set multiple times)
+                        const intensityPercentage = this.getPresetIntensity(preset, timeMillis);
+                        this.mixCapabilityValues(preset, cachedFixture, values, intensityPercentage);
+                        this.mixChannelValues(preset, cachedFixture, values, intensityPercentage);
+                        this.mixEffects(timeMillis, fixtureIndex, preset, cachedFixture, values, intensityPercentage);
+                    }
+                }
+            }
+            // Store the calculated values for subsequent fixtures on the same DMX address
+            calculatedFixtures.set(cachedFixture, values);
+        }
+        return calculatedFixtures;
+    }
+    setUniverseValues(fixtures, masterDimmerValue) {
+        // TODO only, if monitoring is enabled
+        return;
+        // Reset all DMX universes
+        for (const universe of this.universeService.universes) {
+            universe.channelValues = [];
+            for (let i = 0; i < 512; i++) {
+                universe.channelValues.push(0);
+            }
+        }
+        // loop over each fixture
+        fixtures.forEach((channelValues, cachedFixture) => {
+            // TODO Get the correct universe for this fixture
+            const universe = this.universeService.getUniverseByUuid(cachedFixture.fixture.dmxUniverseUuid);
+            // loop over each channel for this fixture
+            for (let channelIndex = 0; channelIndex < cachedFixture.mode.channels.length; channelIndex++) {
+                const channelObj = cachedFixture.mode.channels[channelIndex];
+                if (typeof channelObj === 'string') {
+                    const channelName = channelObj;
+                    // match this mode channel with a channel value
+                    for (const channelValue of channelValues) {
+                        const channel = this.fixtureService.getChannelByName(cachedFixture, channelName);
+                        if (channel && channel.channel) {
+                            const fineIndex = channel.channel.fineChannelAliases.indexOf(channelName);
+                            if (channel.name === channelValue.channelName || fineIndex > -1) {
+                                const universeChannel = cachedFixture.fixture.dmxFirstChannel + channelIndex;
+                                const dmxValue = Math.floor(channelValue.value / Math.pow(256, channel.channel.fineChannelAliases.length - (fineIndex + 1))) % 256;
+                                // TODO
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    fixtureIsSelected(uuid, presets) {
+        for (const preset of presets) {
+            for (const fixtureUuid of preset.preset.fixtureUuids) {
+                if (fixtureUuid === uuid) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    updateFixtureSetup() {
+        this.doUpdateFixtureSetup.next();
+    }
+    prepareStageMesh(mesh) {
+        mesh.receiveShadow = false;
+        mesh.castShadow = false;
+    }
+    updateStage() {
+        if (!this.scene) {
+            return;
+        }
+        let geometry;
+        let mesh;
+        // Remove old meshes from the scene
+        for (const existingMesh of this.stageMeshes) {
+            this.scene.remove(existingMesh);
+            existingMesh.geometry.dispose();
+        }
+        this.stageMeshes = [];
+        // Ground
+        geometry = new THREE.PlaneGeometry(5000, 5000);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(0, 0, 0);
+        mesh.rotateX((Math.PI / 180) * -90);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Floor
+        geometry = new THREE.BoxGeometry(this.projectService.project.stageWidthCm, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(0, this.projectService.project.stageFloorHeightCm / 2, 0);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Pillar front left
+        geometry = new THREE.BoxGeometry(this.projectService.project.stagePillarWidthCm, this.projectService.project.stageHeightCm, this.projectService.project.stagePillarWidthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(-this.projectService.project.stageWidthCm / 2 + this.projectService.project.stagePillarWidthCm / 2, this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - this.projectService.project.stagePillarWidthCm / 2);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Pillar front right
+        geometry = new THREE.BoxGeometry(this.projectService.project.stagePillarWidthCm, this.projectService.project.stageHeightCm, this.projectService.project.stagePillarWidthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(this.projectService.project.stageWidthCm / 2 - this.projectService.project.stagePillarWidthCm / 2, this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - this.projectService.project.stagePillarWidthCm / 2);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Pillar back left
+        geometry = new THREE.BoxGeometry(this.projectService.project.stagePillarWidthCm, this.projectService.project.stageHeightCm, this.projectService.project.stagePillarWidthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(-this.projectService.project.stageWidthCm / 2 + this.projectService.project.stagePillarWidthCm / 2, this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + this.projectService.project.stagePillarWidthCm / 2);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Pillar back right
+        geometry = new THREE.BoxGeometry(this.projectService.project.stagePillarWidthCm, this.projectService.project.stageHeightCm, this.projectService.project.stagePillarWidthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(this.projectService.project.stageWidthCm / 2 - this.projectService.project.stagePillarWidthCm / 2, this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + this.projectService.project.stagePillarWidthCm / 2);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+        // Ceiling
+        geometry = new THREE.BoxGeometry(this.projectService.project.stageWidthCm, this.projectService.project.stageCeilingHeightCm, this.projectService.project.stageDepthCm);
+        mesh = new THREE.Mesh(geometry, this.stageMaterial);
+        this.prepareStageMesh(mesh);
+        mesh.position.set(0, this.projectService.project.stageHeightCm +
+            this.projectService.project.stageCeilingHeightCm / 2 +
+            this.projectService.project.stageFloorHeightCm, 0);
+        this.scene.add(mesh);
+        this.stageMeshes.push(mesh);
+    }
+    static { this.ɵfac = function PreviewService_Factory(t) { return new (t || PreviewService)(i0.ɵɵinject(i1.PresetService), i0.ɵɵinject(i2.FixtureService), i0.ɵɵinject(i3.SceneService), i0.ɵɵinject(i4.TimelineService), i0.ɵɵinject(i5.UniverseService), i0.ɵɵinject(i6.ProjectService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PreviewService, factory: PreviewService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreviewService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.PresetService }, { type: i2.FixtureService }, { type: i3.SceneService }, { type: i4.TimelineService }, { type: i5.UniverseService }, { type: i6.ProjectService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/preview.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport * as THREE from 'three';\nimport { CachedFixture } from '../models/cached-fixture';\nimport { EffectCurve } from '../models/effect-curve';\nimport { FixtureCapabilityType } from '../models/fixture-capability';\nimport { FixtureChannelValue } from '../models/fixture-channel-value';\nimport { Preset } from '../models/preset';\nimport { PresetRegionScene } from '../models/preset-region-scene';\nimport { Universe } from '../models/universe';\nimport { FixtureService } from './fixture.service';\nimport { PresetService } from './preset.service';\nimport { ProjectService } from './project.service';\nimport { SceneService } from './scene.service';\nimport { TimelineService } from './timeline.service';\nimport { UniverseService } from './universe.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PreviewService {\n  public doUpdateFixtureSetup: Subject<void> = new Subject();\n\n  public scene: THREE.Scene;\n\n  private stageMeshes: THREE.Mesh[] = [];\n  private stageMaterial = new THREE.MeshStandardMaterial({\n    color: 0x0d0d0d,\n    // roughness: 0.5,\n    // metalness: 0.5,\n  });\n\n  constructor(\n    private presetService: PresetService,\n    private fixtureService: FixtureService,\n    private sceneService: SceneService,\n    private timelineService: TimelineService,\n    private universeService: UniverseService,\n    private projectService: ProjectService\n  ) {}\n\n  private getAlreadyCalculatedFixture(fixtures: CachedFixture[], fixtureIndex: number): CachedFixture {\n    // Has this fixture already been calculated (same universe and dmx start address as a fixture before)\n    // --> return it\n    for (let i = 0; i < fixtureIndex; i++) {\n      const calculatedFixture = fixtures[i];\n\n      if (\n        calculatedFixture.fixture.dmxUniverseUuid === fixtures[fixtureIndex].fixture.dmxUniverseUuid &&\n        calculatedFixture.fixture.dmxFirstChannel === fixtures[fixtureIndex].fixture.dmxFirstChannel\n      ) {\n        return calculatedFixture;\n      }\n    }\n\n    return undefined;\n  }\n\n  public getPresets(timeMillis: number): PresetRegionScene[] {\n    // Get relevant presets in correct order to process with their corresponding scene, if available\n    let presets: PresetRegionScene[] = [];\n\n    if (this.timelineService.playState === 'playing') {\n      // Only use active presets in current regions\n      presets = this.timelineService.getPresetsInTime(timeMillis);\n    } else {\n      if (this.projectService.project.previewPreset) {\n        // Only preview the selected preset\n        if (this.presetService.selectedPreset) {\n          presets.push(new PresetRegionScene(this.presetService.selectedPreset, undefined, undefined));\n        }\n      } else {\n        // Preview the selected scenes\n        for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {\n          for (const scene of this.sceneService.selectedScenes) {\n            if (scene.uuid === this.projectService.project.scenes[sceneIndex].uuid) {\n              for (let presetIndex = this.projectService.project.presets.length - 1; presetIndex >= 0; presetIndex--) {\n                for (const presetUuid of scene.presetUuids) {\n                  // Loop over the presets in the preset service to retain the preset order\n                  if (presetUuid === this.projectService.project.presets[presetIndex].uuid) {\n                    presets.push(new PresetRegionScene(this.projectService.project.presets[presetIndex], undefined, scene));\n                    break;\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return presets;\n  }\n\n  private mixChannelValue(\n    existingChannelValues: FixtureChannelValue[],\n    channelValue: FixtureChannelValue,\n    intensityPercentage: number,\n    defaultValue: number = 0\n  ) {\n    let newValue: number = channelValue.value;\n    let existingValue: number = defaultValue;\n\n    if (intensityPercentage < 1) {\n      // We need to mix a possibly existing value (or the default value 0) with the new value (fading)\n\n      // Get the existent value for this property\n      for (const existingChannelValue of existingChannelValues) {\n        if (\n          existingChannelValue.channelName === channelValue.channelName &&\n          existingChannelValue.profileUuid === channelValue.profileUuid\n        ) {\n          existingValue = existingChannelValue.value;\n          break;\n        }\n      }\n\n      // Mix the existing value with the new value\n      newValue = existingValue * (1 - intensityPercentage) + newValue * intensityPercentage;\n    }\n\n    // Remove the existent value, if available\n    for (let i = 0; i < existingChannelValues.length; i++) {\n      if (\n        existingChannelValues[i].channelName === channelValue.channelName &&\n        existingChannelValues[i].profileUuid === channelValue.profileUuid\n      ) {\n        existingChannelValues.splice(i, 1);\n        break;\n      }\n    }\n\n    // Add the new value\n    const fixtureChannelValue = new FixtureChannelValue();\n    fixtureChannelValue.channelName = channelValue.channelName;\n    fixtureChannelValue.profileUuid = channelValue.profileUuid;\n    fixtureChannelValue.value = newValue;\n    existingChannelValues.push(fixtureChannelValue);\n  }\n\n  // Get the fixture index inside the passed preset (used for chasing)\n  private getFixtureIndex(preset: Preset, fixtureUuid: string): number {\n    let index = 0;\n    const countedDmxChannels: number[] = [];\n\n    // Loop over the global fixtures to retain the order\n    for (const fixture of this.projectService.project.fixtures) {\n      for (const presetFixtureUuid of preset.fixtureUuids) {\n        if (presetFixtureUuid === fixture.uuid) {\n          if (fixture.uuid === fixtureUuid) {\n            return index;\n          }\n\n          // don't count fixtures on the same channel as already counted ones\n          if (!countedDmxChannels.includes(fixture.dmxFirstChannel)) {\n            countedDmxChannels.push(fixture.dmxFirstChannel);\n            index++;\n          }\n          break;\n        }\n      }\n    }\n\n    // Not found in the preset\n    return undefined;\n  }\n\n  private getPresetIntensity(preset: PresetRegionScene, timeMillis: number): number {\n    // When fading is in progress (on preset or scene-level), the current preset does not\n    // fully cover underlying values.\n    // -> 0 = no covering at all, 1 = fully cover (no fading)\n    let intensityPercentageScene = 1;\n    let intensityPercentagePreset = 1;\n    let intensityPercentage = 1;\n\n    if (preset.region && preset.scene) {\n      // Fade out is stronger than fade in (if they overlap)\n\n      // Take away intensity for scene fading\n      const sceneStartMillis = preset.scene.fadeInPre ? preset.region.startMillis - preset.scene.fadeInMillis : preset.region.startMillis;\n      const sceneEndMillis = preset.scene.fadeOutPost ? preset.region.endMillis + preset.scene.fadeOutMillis : preset.region.endMillis;\n\n      if (timeMillis > sceneEndMillis - preset.scene.fadeOutMillis && timeMillis < sceneEndMillis) {\n        // Scene fades out\n        intensityPercentageScene = (sceneEndMillis - timeMillis) / preset.scene.fadeOutMillis;\n      } else if (timeMillis < sceneStartMillis + preset.scene.fadeInMillis && timeMillis > sceneStartMillis) {\n        // Scene fades in\n        intensityPercentageScene = (timeMillis - sceneStartMillis) / preset.scene.fadeInMillis;\n      }\n    }\n\n    if (preset.region && preset.preset) {\n      // Take away intensity for preset fading\n      let presetStartMillis =\n        preset.preset.startMillis === undefined ? preset.region.startMillis : preset.region.startMillis + preset.preset.startMillis;\n\n      let presetEndMillis =\n        preset.preset.endMillis === undefined ? preset.region.endMillis : preset.region.startMillis + preset.preset.endMillis;\n\n      // extend the running time, if fading is done outside the boundaries\n      presetStartMillis -= preset.preset.fadeInPre ? preset.preset.fadeInMillis : 0;\n      presetEndMillis += preset.preset.fadeOutPost ? preset.preset.fadeOutMillis : 0;\n\n      if (timeMillis > presetEndMillis - preset.preset.fadeOutMillis && timeMillis < presetEndMillis) {\n        // Preset fades out\n        intensityPercentagePreset = (presetEndMillis - timeMillis) / preset.preset.fadeOutMillis;\n      } else if (timeMillis < presetStartMillis + preset.preset.fadeInMillis && timeMillis > presetStartMillis) {\n        // Preset fades in\n        intensityPercentagePreset = (timeMillis - presetStartMillis) / preset.preset.fadeInMillis;\n      }\n\n      intensityPercentage = intensityPercentageScene * intensityPercentagePreset;\n    }\n\n    return intensityPercentage;\n  }\n\n  private mixCapabilityValues(\n    preset: PresetRegionScene,\n    cachedFixture: CachedFixture,\n    values: FixtureChannelValue[],\n    intensityPercentage: number\n  ) {\n    let hasColor = false;\n\n    // mix the preset capability values\n    for (const presetCapabilityValue of preset.preset.fixtureCapabilityValues) {\n      for (const cachedChannel of cachedFixture.channels) {\n        if (cachedChannel.channel) {\n          for (const channelCapability of cachedChannel.capabilities) {\n            if (\n              this.fixtureService.capabilitiesMatch(\n                presetCapabilityValue.type,\n                channelCapability.capability.type,\n                presetCapabilityValue.color,\n                channelCapability.capability.color,\n                presetCapabilityValue.wheel,\n                channelCapability.wheelName,\n                presetCapabilityValue.profileUuid,\n                cachedFixture.profile.uuid\n              )\n            ) {\n              // the capabilities match -> apply the value, if possible\n              if (\n                (presetCapabilityValue.type === FixtureCapabilityType.Intensity ||\n                  presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) &&\n                presetCapabilityValue.valuePercentage >= 0\n              ) {\n                // intensity and colorIntensity (dimmer and color)\n                const valuePercentage = presetCapabilityValue.valuePercentage;\n                const defaultValue = 0;\n\n                // brightness property\n                if (cachedChannel.capabilities.length === 1) {\n                  // the only capability in this channel\n                  const fixtureChannelValue = new FixtureChannelValue();\n                  fixtureChannelValue.channelName = cachedChannel.name;\n                  fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                  fixtureChannelValue.value = cachedChannel.maxValue * valuePercentage;\n                  this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);\n\n                  if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {\n                    hasColor = true;\n                  }\n                } else {\n                  // more than one capability in the channel\n                  if (channelCapability.capability.brightness === 'off' && valuePercentage === 0) {\n                    const fixtureChannelValue = new FixtureChannelValue();\n                    fixtureChannelValue.channelName = cachedChannel.name;\n                    fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                    fixtureChannelValue.value = channelCapability.centerValue;\n                    this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);\n\n                    if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {\n                      hasColor = true;\n                    }\n                  } else if (\n                    (channelCapability.capability.brightnessStart === 'dark' || channelCapability.capability.brightnessStart === 'off') &&\n                    channelCapability.capability.brightnessEnd === 'bright'\n                  ) {\n                    const value =\n                      (channelCapability.capability.dmxRange[1] - channelCapability.capability.dmxRange[0]) * valuePercentage +\n                      channelCapability.capability.dmxRange[0];\n\n                    const fixtureChannelValue = new FixtureChannelValue();\n                    fixtureChannelValue.channelName = cachedChannel.name;\n                    fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                    fixtureChannelValue.value = value;\n                    this.mixChannelValue(values, fixtureChannelValue, intensityPercentage, defaultValue);\n\n                    if (presetCapabilityValue.type === FixtureCapabilityType.ColorIntensity) {\n                      hasColor = true;\n                    }\n                  }\n                }\n              } else if (\n                (presetCapabilityValue.type === FixtureCapabilityType.Pan || presetCapabilityValue.type === FixtureCapabilityType.Tilt) &&\n                presetCapabilityValue.valuePercentage >= 0\n              ) {\n                const fixtureChannelValue = new FixtureChannelValue();\n                fixtureChannelValue.channelName = cachedChannel.name;\n                fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                fixtureChannelValue.value = cachedChannel.maxValue * presetCapabilityValue.valuePercentage;\n                this.mixChannelValue(values, fixtureChannelValue, 1);\n              } else if (\n                presetCapabilityValue.type === FixtureCapabilityType.WheelSlot &&\n                channelCapability.capability.slotNumber === presetCapabilityValue.slotNumber\n              ) {\n                // wheel slot (color, gobo, etc.)\n                const fixtureChannelValue = new FixtureChannelValue();\n                fixtureChannelValue.channelName = cachedChannel.name;\n                fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                fixtureChannelValue.value = channelCapability.centerValue;\n                this.mixChannelValue(values, fixtureChannelValue, 1);\n\n                // check, whether we just set a color wheel value\n                if (channelCapability.wheelIsColor) {\n                  hasColor = true;\n                }\n              }\n            }\n          }\n        }\n\n        // approximate the color from a color or a different color wheel, if necessary\n        if (!hasColor && cachedChannel.colorWheel) {\n          const capability = this.presetService.getApproximatedColorWheelCapability(preset.preset, cachedChannel);\n\n          if (capability) {\n            // we found an approximated color in the available wheel channel\n            const fixtureChannelValue = new FixtureChannelValue();\n            fixtureChannelValue.channelName = cachedChannel.name;\n            fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n            fixtureChannelValue.value = capability.centerValue;\n            this.mixChannelValue(values, fixtureChannelValue, 1);\n          }\n        }\n      }\n    }\n  }\n\n  private mixChannelValues(\n    preset: PresetRegionScene,\n    cachedFixture: CachedFixture,\n    values: FixtureChannelValue[],\n    intensityPercentage: number\n  ) {\n    // mix the preset channel values\n    for (const cachedChannel of cachedFixture.channels) {\n      if (cachedChannel.channel) {\n        for (const channelValue of preset.preset.fixtureChannelValues) {\n          if (cachedFixture.profile.uuid === channelValue.profileUuid && cachedChannel.name === channelValue.channelName) {\n            this.mixChannelValue(values, channelValue, intensityPercentage);\n          }\n        }\n      }\n    }\n  }\n\n  private mixEffects(\n    timeMillis: number,\n    fixtureIndex: number,\n    preset: PresetRegionScene,\n    cachedFixture: CachedFixture,\n    values: FixtureChannelValue[],\n    intensityPercentage: number\n  ) {\n    for (const effect of preset.preset.effects) {\n      if (effect.visible) {\n        // EffectCurve\n        if (effect instanceof EffectCurve) {\n          const effectCurve = effect as EffectCurve;\n\n          // capabilities\n          for (const capability of effectCurve.capabilities) {\n            for (const cachedChannel of cachedFixture.channels) {\n              for (const channelCapability of cachedChannel.capabilities) {\n                if (\n                  this.fixtureService.capabilitiesMatch(\n                    capability.type,\n                    channelCapability.capability.type,\n                    capability.color,\n                    channelCapability.capability.color,\n                    null,\n                    null,\n                    null,\n                    null\n                  )\n                ) {\n                  const fixtureChannelValue = new FixtureChannelValue();\n                  fixtureChannelValue.channelName = cachedChannel.name;\n                  fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                  fixtureChannelValue.value = cachedChannel.maxValue * effectCurve.getValueAtMillis(timeMillis, fixtureIndex);\n                  this.mixChannelValue(values, fixtureChannelValue, intensityPercentage);\n                }\n              }\n            }\n          }\n\n          // channels\n          for (const channelProfile of effectCurve.channels) {\n            if (channelProfile.profileUuid === cachedFixture.profile.uuid) {\n              for (const channel of channelProfile.channels) {\n                for (const cachedChannel of cachedFixture.channels) {\n                  if (cachedChannel.name === channel) {\n                    const fixtureChannelValue = new FixtureChannelValue();\n                    fixtureChannelValue.channelName = cachedChannel.name;\n                    fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n                    fixtureChannelValue.value = cachedChannel.maxValue * effectCurve.getValueAtMillis(timeMillis, fixtureIndex);\n                    this.mixChannelValue(values, fixtureChannelValue, intensityPercentage);\n                  }\n                }\n              }\n\n              break;\n            }\n          }\n        }\n\n        // TODO other effects (PanTilt, etc.)\n      }\n    }\n  }\n\n  // return all fixture uuids with their corresponding channel values\n  public getChannelValues(timeMillis: number, presets: PresetRegionScene[]): Map<CachedFixture, FixtureChannelValue[]> {\n    // Loop over all relevant presets and calc the property values from the presets (capabilities and effects)\n    const calculatedFixtures = new Map<CachedFixture, FixtureChannelValue[]>();\n\n    for (let i = 0; i < this.fixtureService.cachedFixtures.length; i++) {\n      const cachedFixture = this.fixtureService.cachedFixtures[i];\n\n      // all values of the current fixture channels\n      let values: FixtureChannelValue[] = [];\n\n      const alreadyCalculatedFixture = this.getAlreadyCalculatedFixture(this.fixtureService.cachedFixtures, i);\n\n      if (alreadyCalculatedFixture) {\n        // only relevant for the preview --> reuse all calculated values\n        values = Object.assign([], calculatedFixtures.get(alreadyCalculatedFixture));\n      } else {\n        // apply the default values\n        for (const cachedChannel of cachedFixture.channels) {\n          if (cachedChannel.channel) {\n            if (cachedChannel.channel.defaultValue) {\n              const fixtureChannelValue = new FixtureChannelValue();\n              fixtureChannelValue.channelName = cachedChannel.name;\n              fixtureChannelValue.profileUuid = cachedFixture.profile.uuid;\n              fixtureChannelValue.value = cachedChannel.defaultValue;\n              this.mixChannelValue(values, fixtureChannelValue, 1);\n            }\n          }\n        }\n\n        for (const preset of presets) {\n          // search for this fixture in the preset and get it's preset-specific index (for chasing effects)\n          const fixtureIndex = this.getFixtureIndex(preset.preset, cachedFixture.fixture.uuid);\n\n          if (fixtureIndex >= 0) {\n            // this fixture is also in the preset -> mix the required values (overwrite existing values,\n            // if set multiple times)\n            const intensityPercentage = this.getPresetIntensity(preset, timeMillis);\n\n            this.mixCapabilityValues(preset, cachedFixture, values, intensityPercentage);\n            this.mixChannelValues(preset, cachedFixture, values, intensityPercentage);\n            this.mixEffects(timeMillis, fixtureIndex, preset, cachedFixture, values, intensityPercentage);\n          }\n        }\n      }\n\n      // Store the calculated values for subsequent fixtures on the same DMX address\n      calculatedFixtures.set(cachedFixture, values);\n    }\n\n    return calculatedFixtures;\n  }\n\n  public setUniverseValues(fixtures: Map<CachedFixture, FixtureChannelValue[]>, masterDimmerValue: number) {\n    // TODO only, if monitoring is enabled\n    return;\n\n    // Reset all DMX universes\n    for (const universe of this.universeService.universes) {\n      universe.channelValues = [];\n      for (let i = 0; i < 512; i++) {\n        universe.channelValues.push(0);\n      }\n    }\n\n    // loop over each fixture\n    fixtures.forEach((channelValues: FixtureChannelValue[], cachedFixture: CachedFixture) => {\n      // TODO Get the correct universe for this fixture\n      const universe: Universe = this.universeService.getUniverseByUuid(cachedFixture.fixture.dmxUniverseUuid);\n\n      // loop over each channel for this fixture\n      for (let channelIndex = 0; channelIndex < cachedFixture.mode.channels.length; channelIndex++) {\n        const channelObj = cachedFixture.mode.channels[channelIndex];\n        if (typeof channelObj === 'string') {\n          const channelName = channelObj;\n          // match this mode channel with a channel value\n          for (const channelValue of channelValues) {\n            const channel = this.fixtureService.getChannelByName(cachedFixture, channelName);\n            if (channel && channel.channel) {\n              const fineIndex = channel.channel.fineChannelAliases.indexOf(channelName);\n              if (channel.name === channelValue.channelName || fineIndex > -1) {\n                const universeChannel = cachedFixture.fixture.dmxFirstChannel + channelIndex;\n                const dmxValue =\n                  Math.floor(channelValue.value / Math.pow(256, channel.channel.fineChannelAliases.length - (fineIndex + 1))) % 256;\n                // TODO\n                break;\n              }\n            }\n          }\n        }\n      }\n    });\n  }\n\n  public fixtureIsSelected(uuid: string, presets: PresetRegionScene[]): boolean {\n    for (const preset of presets) {\n      for (const fixtureUuid of preset.preset.fixtureUuids) {\n        if (fixtureUuid === uuid) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  public updateFixtureSetup() {\n    this.doUpdateFixtureSetup.next();\n  }\n\n  private prepareStageMesh(mesh: THREE.Mesh) {\n    mesh.receiveShadow = false;\n    mesh.castShadow = false;\n  }\n\n  public updateStage() {\n    if (!this.scene) {\n      return;\n    }\n\n    let geometry: any;\n    let mesh: any;\n\n    // Remove old meshes from the scene\n    for (const existingMesh of this.stageMeshes) {\n      this.scene.remove(existingMesh);\n      existingMesh.geometry.dispose();\n    }\n    this.stageMeshes = [];\n\n    // Ground\n    geometry = new THREE.PlaneGeometry(5000, 5000);\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(0, 0, 0);\n    mesh.rotateX((Math.PI / 180) * -90);\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Floor\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stageWidthCm,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(0, this.projectService.project.stageFloorHeightCm / 2, 0);\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Pillar front left\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stagePillarWidthCm,\n      this.projectService.project.stageHeightCm,\n      this.projectService.project.stagePillarWidthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(\n      -this.projectService.project.stageWidthCm / 2 + this.projectService.project.stagePillarWidthCm / 2,\n      this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - this.projectService.project.stagePillarWidthCm / 2\n    );\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Pillar front right\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stagePillarWidthCm,\n      this.projectService.project.stageHeightCm,\n      this.projectService.project.stagePillarWidthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(\n      this.projectService.project.stageWidthCm / 2 - this.projectService.project.stagePillarWidthCm / 2,\n      this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - this.projectService.project.stagePillarWidthCm / 2\n    );\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Pillar back left\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stagePillarWidthCm,\n      this.projectService.project.stageHeightCm,\n      this.projectService.project.stagePillarWidthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(\n      -this.projectService.project.stageWidthCm / 2 + this.projectService.project.stagePillarWidthCm / 2,\n      this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + this.projectService.project.stagePillarWidthCm / 2\n    );\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Pillar back right\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stagePillarWidthCm,\n      this.projectService.project.stageHeightCm,\n      this.projectService.project.stagePillarWidthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(\n      this.projectService.project.stageWidthCm / 2 - this.projectService.project.stagePillarWidthCm / 2,\n      this.projectService.project.stageHeightCm / 2 + this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + this.projectService.project.stagePillarWidthCm / 2\n    );\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n\n    // Ceiling\n    geometry = new THREE.BoxGeometry(\n      this.projectService.project.stageWidthCm,\n      this.projectService.project.stageCeilingHeightCm,\n      this.projectService.project.stageDepthCm\n    );\n    mesh = new THREE.Mesh(geometry, this.stageMaterial);\n    this.prepareStageMesh(mesh);\n    mesh.position.set(\n      0,\n      this.projectService.project.stageHeightCm +\n        this.projectService.project.stageCeilingHeightCm / 2 +\n        this.projectService.project.stageFloorHeightCm,\n      0\n    );\n    this.scene.add(mesh);\n    this.stageMeshes.push(mesh);\n  }\n}\n"]}