@rocketshow/designer 1.32.0 → 1.33.0

package/esm2022/lib/preview/models/moving-head-3d.mjs

@@ -0,0 +1,243 @@
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as THREE from 'three';
+import { FixtureCapabilityType } from '../../models/fixture-capability';
+import { Fixture3d } from './fixture-3d';
+export class MovingHead3d extends Fixture3d {
+    atmosphereMat() {
+        const vertexShader = `
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+
+      void main(){
+        vNormal = normalize(normalMatrix * normal);
+
+        vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+        vWorldPosition = worldPosition.xyz;
+
+        gl_Position	= projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }`;
+        const fragmentShader = `
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+
+      uniform vec3 lightColor;
+      uniform float	opacity;
+      uniform vec3 spotPosition;
+      uniform float attenuation;
+      uniform float	anglePower;
+
+      void main(){
+        float intensity;
+
+        intensity	= distance(vWorldPosition, spotPosition) / attenuation;
+        intensity	= 1.0 - clamp(intensity, 0.0, 1.0);
+
+        vec3 normal	= vec3(vNormal.x, vNormal.y, abs(vNormal.z));
+        float angleIntensity	= pow(dot(normal, vec3(0.0, 0.0, 1.0)), anglePower);
+        intensity	= intensity * angleIntensity * opacity;
+
+        gl_FragColor	= vec4(lightColor, intensity);
+      }`;
+        const material = new THREE.ShaderMaterial({
+            uniforms: {
+                attenuation: {
+                    type: 'f',
+                    value: 800.0,
+                },
+                anglePower: {
+                    type: 'f',
+                    value: 2,
+                },
+                spotPosition: {
+                    type: 'v3',
+                    value: new THREE.Vector3(0, 0, 0),
+                },
+                lightColor: {
+                    type: 'c',
+                    value: new THREE.Color('white'),
+                },
+                opacity: {
+                    type: 'f',
+                    value: 1.0,
+                },
+            },
+            vertexShader,
+            fragmentShader,
+            transparent: true,
+            depthWrite: false,
+        });
+        return material;
+    }
+    createSpotLightBeam() {
+        if (this.spotLightBeam) {
+            this.spotlightGroup.remove(this.spotLightBeam);
+        }
+        // TODO update the correct angle from the profile
+        const beamAngleDegrees = 14;
+        const geometry = new THREE.CylinderGeometry(0.1, beamAngleDegrees * 1.2, 100, 64, 20, false);
+        geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(0, -geometry.parameters.height / 2, 0));
+        geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(-Math.PI / 2));
+        this.atmosphereMaterial = this.atmosphereMat();
+        this.spotLightBeam = new THREE.Mesh(geometry, this.atmosphereMaterial);
+        this.spotLightBeam.position.set(0, -0.02, 0);
+        this.spotLightBeam.receiveShadow = false;
+        this.spotLightBeam.castShadow = false;
+        this.spotlightGroup.add(this.spotLightBeam);
+        this.spotLightBeam.rotation.x = Math.PI / 2;
+    }
+    createObjects() {
+        this.material = new THREE.MeshLambertMaterial({
+            color: 0x0d0d0d,
+            emissive: 0x0d0d0d,
+        });
+        this.socket.material = this.material;
+        this.arm.material = this.material;
+        this.head.material = this.material;
+        // Add the head
+        this.head.scale.multiplyScalar(0.9);
+        this.head.position.set(-0.1, 0, 0);
+        const headPivotGroup = new THREE.Object3D();
+        headPivotGroup.add(this.head);
+        this.headGroup.add(headPivotGroup);
+        // Add the spotlight
+        this.spotLight = new THREE.SpotLight(0xffffff, 50000);
+        this.spotLight.angle = 2;
+        this.spotLight.penumbra = 1;
+        this.spotLight.decay = 0.01;
+        this.spotLight.distance = 0;
+        this.spotLight.intensity = 1;
+        this.spotLightHelper = new THREE.SpotLightHelper(this.spotLight);
+        this.scene.add(this.spotLightHelper);
+        const spotLightTarget = new THREE.Object3D();
+        this.spotLight.target = spotLightTarget;
+        this.spotlightGroup.add(this.spotLight);
+        this.spotlightGroup.add(spotLightTarget);
+        this.spotLight.position.set(0, -1.4, 0);
+        spotLightTarget.position.set(0, -10, 0);
+        // Add the point light for the surrounding light
+        this.pointLight = new THREE.PointLight(0xffffff, 500, 0, 0.1);
+        this.spotlightGroup.add(this.pointLight);
+        this.pointLight.position.set(0, -1.4, 0);
+        // Add the light beam
+        this.createSpotLightBeam();
+        this.headGroup.add(this.spotlightGroup);
+        // Add the arm
+        this.armGroup.add(this.headGroup);
+        this.headGroup.position.set(0, -0.6, 0);
+        this.armGroup.add(this.arm);
+        // Add the socket
+        this.objectGroup.add(this.armGroup);
+        this.objectGroup.add(this.socket);
+        this.socket.position.set(0, 1.2, 0);
+        // A moving head has about 32 cm in width
+        this.objectGroup.scale.multiplyScalar(9);
+        this.scene.add(this.objectGroup);
+        this.isLoaded = true;
+    }
+    constructor(fixtureService, previewMeshService, fixture, scene) {
+        super(fixtureService, fixture, scene);
+        this.pointLightMaxIntensity = 2;
+        this.spotLightLightMaxIntensity = 10;
+        this.headGroup = new THREE.Object3D();
+        this.spotlightGroup = new THREE.Object3D();
+        this.armGroup = new THREE.Object3D();
+        this.objectGroup = new THREE.Object3D();
+        forkJoin([
+            previewMeshService.getMesh('moving_head_socket'),
+            previewMeshService.getMesh('moving_head_arm'),
+            previewMeshService.getMesh('moving_head_head'),
+        ])
+            .pipe(map(([socket, arm, head]) => {
+            this.socket = socket;
+            this.arm = arm;
+            this.head = head;
+            this.createObjects();
+        }))
+            .subscribe();
+    }
+    getObject() {
+        return this.objectGroup;
+    }
+    updatePreview(channelValues, masterDimmerValue) {
+        super.updatePreview(channelValues, masterDimmerValue);
+        if (!this.isLoaded) {
+            return;
+        }
+        // Apply default settings
+        let panStart = 0;
+        let panEnd = 255;
+        let tiltStart = 0;
+        let tiltEnd = 255;
+        this.pan = 0;
+        this.tilt = 0;
+        // Apply the known property values
+        for (const channelValue of channelValues) {
+            const channel = this.fixtureService.getChannelByName(this.fixture, channelValue.channelName);
+            const capability = this.getCapabilityInValue(channel, channelValue.value);
+            if (capability) {
+                switch (capability.capability.type) {
+                    case FixtureCapabilityType.Pan: {
+                        panStart = this.fixtureService.getRotationAngleDeg(capability.capability.angleStart) || 0;
+                        panEnd = this.fixtureService.getRotationAngleDeg(capability.capability.angleEnd) || 540;
+                        this.pan = channelValue.value / channel.maxValue;
+                        break;
+                    }
+                    case FixtureCapabilityType.Tilt: {
+                        tiltStart = this.fixtureService.getRotationAngleDeg(capability.capability.angleStart) || 0;
+                        tiltEnd = this.fixtureService.getRotationAngleDeg(capability.capability.angleEnd) || 2700;
+                        this.tilt = channelValue.value / channel.maxValue;
+                        break;
+                    }
+                }
+            }
+        }
+        this.updatePosition(this.objectGroup);
+        // calculate the y/x rotation in radiants based on pan/tilt (0-1) respecting the max pan/tilt
+        this.armGroup.rotation.y = THREE.MathUtils.degToRad(panEnd * this.pan + panStart) - THREE.MathUtils.degToRad(panEnd / 2);
+        this.headGroup.rotation.x = THREE.MathUtils.degToRad(tiltEnd * this.tilt + tiltStart) - THREE.MathUtils.degToRad(tiltEnd / 2);
+        // Update the angle (only on change, because it's expensive)
+        // TODO update the correct angle from the profile
+        const beamAngleDregrees = 14;
+        if (this.lastBeamAngleDegrees !== beamAngleDregrees) {
+            this.spotLight.angle = THREE.MathUtils.degToRad(beamAngleDregrees);
+            this.createSpotLightBeam();
+            this.lastBeamAngleDegrees = beamAngleDregrees;
+        }
+        // Update the material
+        if (this.lastSelected !== this.isSelected) {
+            if (this.isSelected) {
+                this.socket.material = this.selectedMaterial;
+                this.arm.material = this.selectedMaterial;
+                this.head.material = this.selectedMaterial;
+            }
+            else {
+                this.socket.material = this.material;
+                this.arm.material = this.material;
+                this.head.material = this.material;
+            }
+            this.lastSelected = this.isSelected;
+        }
+        // Apply the colors
+        const color = new THREE.Color('rgb(' + this.colorRed + ', ' + this.colorGreen + ', ' + this.colorBlue + ')');
+        this.pointLight.color = color;
+        this.spotLight.color = color;
+        this.spotLightBeam.material.uniforms.lightColor.value = color;
+        // Apply the dimmer value
+        // Take the color into account for the beam (don't show a black beam)
+        const intensityColor = Math.max(this.colorRed, this.colorGreen, this.colorBlue);
+        // console.log(Math.min(intensityColor, this.dimmer));
+        this.spotLightBeam.material.uniforms.opacity.value = Math.min(intensityColor, this.dimmer);
+        this.spotLight.intensity = this.spotLightLightMaxIntensity * this.dimmer;
+        this.pointLight.intensity = this.pointLightMaxIntensity * this.dimmer;
+        this.spotLightBeam.material.uniforms.spotPosition.value = this.objectGroup.position;
+        // this.spotLightHelper.update();
+    }
+    destroy() {
+        this.scene.remove(this.objectGroup);
+        this.material.dispose();
+        this.atmosphereMaterial.dispose();
+        this.spotLightHelper.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"moving-head-3d.js","sourceRoot":"","sources":["../../../../../../projects/designer/src/lib/preview/models/moving-head-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import { forkJoin } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport * as THREE from 'three';\nimport { CachedFixture } from '../../models/cached-fixture';\nimport { FixtureCapabilityType } from '../../models/fixture-capability';\nimport { FixtureChannelValue } from '../../models/fixture-channel-value';\nimport { FixtureService } from '../../services/fixture.service';\nimport { PreviewMeshService } from '../../services/preview-mesh.service';\nimport { Fixture3d } from './fixture-3d';\n\nexport class MovingHead3d extends Fixture3d {\n  private readonly pointLightMaxIntensity: number = 2;\n  private readonly spotLightLightMaxIntensity: number = 10;\n\n  private pan: number;\n  private tilt: number;\n\n  private socket: THREE.Mesh;\n  private arm: THREE.Mesh;\n  private head: THREE.Mesh;\n\n  private headGroup: THREE.Object3D = new THREE.Object3D();\n  private spotlightGroup: THREE.Object3D = new THREE.Object3D();\n  private armGroup: THREE.Object3D = new THREE.Object3D();\n  private objectGroup: THREE.Object3D = new THREE.Object3D();\n  private spotLight: THREE.SpotLight;\n  private spotLightHelper: THREE.SpotLightHelper;\n  private spotLightBeam: THREE.Mesh;\n\n  private pointLight: THREE.PointLight;\n\n  private lastBeamAngleDegrees: number;\n  private lastSelected: boolean;\n\n  private material: THREE.MeshStandardMaterial;\n  private atmosphereMaterial: THREE.ShaderMaterial;\n\n  private atmosphereMat() {\n    const vertexShader = `\n      varying vec3 vNormal;\n      varying vec3 vWorldPosition;\n\n      void main(){\n        vNormal = normalize(normalMatrix * normal);\n\n        vec4 worldPosition = modelMatrix * vec4(position, 1.0);\n        vWorldPosition = worldPosition.xyz;\n\n        gl_Position\t= projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n      }`;\n    const fragmentShader = `\n      varying vec3 vNormal;\n      varying vec3 vWorldPosition;\n\n      uniform vec3 lightColor;\n      uniform float\topacity;\n      uniform vec3 spotPosition;\n      uniform float attenuation;\n      uniform float\tanglePower;\n\n      void main(){\n        float intensity;\n\n        intensity\t= distance(vWorldPosition, spotPosition) / attenuation;\n        intensity\t= 1.0 - clamp(intensity, 0.0, 1.0);\n\n        vec3 normal\t= vec3(vNormal.x, vNormal.y, abs(vNormal.z));\n        float angleIntensity\t= pow(dot(normal, vec3(0.0, 0.0, 1.0)), anglePower);\n        intensity\t= intensity * angleIntensity * opacity;\n\n        gl_FragColor\t= vec4(lightColor, intensity);\n      }`;\n\n    const material = new THREE.ShaderMaterial({\n      uniforms: {\n        attenuation: {\n          type: 'f',\n          value: 800.0,\n        },\n        anglePower: {\n          type: 'f',\n          value: 2,\n        },\n        spotPosition: {\n          type: 'v3',\n          value: new THREE.Vector3(0, 0, 0),\n        },\n        lightColor: {\n          type: 'c',\n          value: new THREE.Color('white'),\n        },\n        opacity: {\n          type: 'f',\n          value: 1.0,\n        },\n      },\n      vertexShader,\n      fragmentShader,\n      transparent: true,\n      depthWrite: false,\n    });\n\n    return material;\n  }\n\n  private createSpotLightBeam() {\n    if (this.spotLightBeam) {\n      this.spotlightGroup.remove(this.spotLightBeam);\n    }\n\n    // TODO update the correct angle from the profile\n    const beamAngleDegrees = 14;\n    const geometry = new THREE.CylinderGeometry(0.1, beamAngleDegrees * 1.2, 100, 64, 20, false);\n    geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(0, -geometry.parameters.height / 2, 0));\n    geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(-Math.PI / 2));\n\n    this.atmosphereMaterial = this.atmosphereMat();\n    this.spotLightBeam = new THREE.Mesh(geometry, this.atmosphereMaterial);\n    this.spotLightBeam.position.set(0, -0.02, 0);\n    this.spotLightBeam.receiveShadow = false;\n    this.spotLightBeam.castShadow = false;\n\n    this.spotlightGroup.add(this.spotLightBeam);\n    this.spotLightBeam.rotation.x = Math.PI / 2;\n  }\n\n  private createObjects() {\n    (this.material as any) = new THREE.MeshLambertMaterial({\n      color: 0x0d0d0d,\n      emissive: 0x0d0d0d,\n    });\n\n    this.socket.material = this.material;\n    this.arm.material = this.material;\n    this.head.material = this.material;\n\n    // Add the head\n    this.head.scale.multiplyScalar(0.9);\n    this.head.position.set(-0.1, 0, 0);\n    const headPivotGroup = new THREE.Object3D();\n    headPivotGroup.add(this.head);\n    this.headGroup.add(headPivotGroup);\n\n    // Add the spotlight\n    this.spotLight = new THREE.SpotLight(0xffffff, 50000);\n    this.spotLight.angle = 2;\n    this.spotLight.penumbra = 1;\n    this.spotLight.decay = 0.01;\n    this.spotLight.distance = 0;\n    this.spotLight.intensity = 1;\n\n    this.spotLightHelper = new THREE.SpotLightHelper(this.spotLight);\n    this.scene.add(this.spotLightHelper);\n\n    const spotLightTarget = new THREE.Object3D();\n    this.spotLight.target = spotLightTarget;\n\n    this.spotlightGroup.add(this.spotLight);\n    this.spotlightGroup.add(spotLightTarget);\n    this.spotLight.position.set(0, -1.4, 0);\n    spotLightTarget.position.set(0, -10, 0);\n\n    // Add the point light for the surrounding light\n    this.pointLight = new THREE.PointLight(0xffffff, 500, 0, 0.1);\n    this.spotlightGroup.add(this.pointLight);\n    this.pointLight.position.set(0, -1.4, 0);\n\n    // Add the light beam\n    this.createSpotLightBeam();\n\n    this.headGroup.add(this.spotlightGroup);\n\n    // Add the arm\n    this.armGroup.add(this.headGroup);\n    this.headGroup.position.set(0, -0.6, 0);\n    this.armGroup.add(this.arm);\n\n    // Add the socket\n    this.objectGroup.add(this.armGroup);\n    this.objectGroup.add(this.socket);\n    this.socket.position.set(0, 1.2, 0);\n\n    // A moving head has about 32 cm in width\n    this.objectGroup.scale.multiplyScalar(9);\n\n    this.scene.add(this.objectGroup);\n\n    this.isLoaded = true;\n  }\n\n  constructor(fixtureService: FixtureService, previewMeshService: PreviewMeshService, fixture: CachedFixture, scene: any) {\n    super(fixtureService, fixture, scene);\n\n    forkJoin([\n      previewMeshService.getMesh('moving_head_socket'),\n      previewMeshService.getMesh('moving_head_arm'),\n      previewMeshService.getMesh('moving_head_head'),\n    ])\n      .pipe(\n        map(([socket, arm, head]) => {\n          this.socket = socket;\n          this.arm = arm;\n          this.head = head;\n\n          this.createObjects();\n        })\n      )\n      .subscribe();\n  }\n\n  public getObject(): THREE.Object3D {\n    return this.objectGroup;\n  }\n\n  public updatePreview(channelValues: FixtureChannelValue[], masterDimmerValue: number): void {\n    super.updatePreview(channelValues, masterDimmerValue);\n\n    if (!this.isLoaded) {\n      return;\n    }\n\n    // Apply default settings\n    let panStart = 0;\n    let panEnd = 255;\n\n    let tiltStart = 0;\n    let tiltEnd = 255;\n\n    this.pan = 0;\n    this.tilt = 0;\n\n    // Apply the known property values\n    for (const channelValue of channelValues) {\n      const channel = this.fixtureService.getChannelByName(this.fixture, channelValue.channelName);\n      const capability = this.getCapabilityInValue(channel, channelValue.value);\n      if (capability) {\n        switch (capability.capability.type) {\n          case FixtureCapabilityType.Pan: {\n            panStart = this.fixtureService.getRotationAngleDeg(capability.capability.angleStart) || 0;\n            panEnd = this.fixtureService.getRotationAngleDeg(capability.capability.angleEnd) || 540;\n            this.pan = channelValue.value / channel.maxValue;\n            break;\n          }\n          case FixtureCapabilityType.Tilt: {\n            tiltStart = this.fixtureService.getRotationAngleDeg(capability.capability.angleStart) || 0;\n            tiltEnd = this.fixtureService.getRotationAngleDeg(capability.capability.angleEnd) || 2700;\n            this.tilt = channelValue.value / channel.maxValue;\n            break;\n          }\n        }\n      }\n    }\n\n    this.updatePosition(this.objectGroup);\n\n    // calculate the y/x rotation in radiants based on pan/tilt (0-1) respecting the max pan/tilt\n    this.armGroup.rotation.y = THREE.MathUtils.degToRad(panEnd * this.pan + panStart) - THREE.MathUtils.degToRad(panEnd / 2);\n    this.headGroup.rotation.x = THREE.MathUtils.degToRad(tiltEnd * this.tilt + tiltStart) - THREE.MathUtils.degToRad(tiltEnd / 2);\n\n    // Update the angle (only on change, because it's expensive)\n    // TODO update the correct angle from the profile\n    const beamAngleDregrees = 14;\n    if (this.lastBeamAngleDegrees !== beamAngleDregrees) {\n      this.spotLight.angle = THREE.MathUtils.degToRad(beamAngleDregrees);\n      this.createSpotLightBeam();\n      this.lastBeamAngleDegrees = beamAngleDregrees;\n    }\n\n    // Update the material\n    if (this.lastSelected !== this.isSelected) {\n      if (this.isSelected) {\n        this.socket.material = this.selectedMaterial;\n        this.arm.material = this.selectedMaterial;\n        this.head.material = this.selectedMaterial;\n      } else {\n        this.socket.material = this.material;\n        this.arm.material = this.material;\n        this.head.material = this.material;\n      }\n\n      this.lastSelected = this.isSelected;\n    }\n\n    // Apply the colors\n    const color = new THREE.Color('rgb(' + this.colorRed + ', ' + this.colorGreen + ', ' + this.colorBlue + ')');\n\n    this.pointLight.color = color;\n\n    this.spotLight.color = color;\n    this.spotLightBeam.material.uniforms.lightColor.value = color;\n\n    // Apply the dimmer value\n    // Take the color into account for the beam (don't show a black beam)\n    const intensityColor = Math.max(this.colorRed, this.colorGreen, this.colorBlue);\n    // console.log(Math.min(intensityColor, this.dimmer));\n    this.spotLightBeam.material.uniforms.opacity.value = Math.min(intensityColor, this.dimmer);\n\n    this.spotLight.intensity = this.spotLightLightMaxIntensity * this.dimmer;\n    this.pointLight.intensity = this.pointLightMaxIntensity * this.dimmer;\n\n    this.spotLightBeam.material.uniforms.spotPosition.value = this.objectGroup.position;\n\n    // this.spotLightHelper.update();\n  }\n\n  destroy() {\n    this.scene.remove(this.objectGroup);\n    this.material.dispose();\n    this.atmosphereMaterial.dispose();\n    this.spotLightHelper.dispose();\n  }\n}\n"]}

package/esm2022/lib/preview/preview.component.mjs

@@ -0,0 +1,212 @@
+import { Component, ElementRef, HostListener, ViewChild } from '@angular/core';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { FixtureCategory } from '../models/fixture-profile';
+import { FixtureService } from '../services/fixture.service';
+import { PreviewMeshService } from '../services/preview-mesh.service';
+import { PreviewService } from '../services/preview.service';
+import { ProjectService } from '../services/project.service';
+import { TimelineService } from '../services/timeline.service';
+import { Positioning } from './../models/fixture';
+import { AnimationService } from './../services/animation.service';
+import { ColorChanger3d } from './models/color-changer-3d';
+import { MovingHead3d } from './models/moving-head-3d';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/fixture.service";
+import * as i2 from "../services/preview-mesh.service";
+import * as i3 from "./../services/animation.service";
+import * as i4 from "../services/preview.service";
+import * as i5 from "../services/timeline.service";
+import * as i6 from "../services/project.service";
+const _c0 = ["canvas"];
+export class PreviewComponent {
+    constructor(fixtureService, previewMeshService, animationService, previewService, timelineService, projectService) {
+        this.fixtureService = fixtureService;
+        this.previewMeshService = previewMeshService;
+        this.animationService = animationService;
+        this.previewService = previewService;
+        this.timelineService = timelineService;
+        this.projectService = projectService;
+        this.fixtures3d = [];
+        this.previewService.doUpdateFixtureSetup.subscribe(() => {
+            // synchronize the 3d-fixtures to the project fixtures
+            this.syncFixtures();
+        });
+    }
+    syncFixtures() {
+        // remove all fixtures
+        for (const fixture3d of this.fixtures3d) {
+            fixture3d.destroy();
+        }
+        this.fixtures3d = [];
+        // add all fixtures from the project
+        for (const fixture of this.fixtureService.cachedFixtures) {
+            switch (fixture.profile.categories[0]) {
+                case FixtureCategory['Moving Head']:
+                    this.fixtures3d.push(new MovingHead3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+                case FixtureCategory['Color Changer']:
+                    this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+                case FixtureCategory['Blinder']:
+                    this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+            }
+        }
+    }
+    get canvas() {
+        return this.canvasRef.nativeElement;
+    }
+    render() {
+        this.renderer.render(this.scene, this.camera);
+    }
+    updateStagePosition(positioning, xMin, xMax, yMin, yMax, zMin, zMax) {
+        let positionCount = 0; // Number of fixtures in the same position
+        let positionIndex = 1;
+        this.projectService.project.fixtures.forEach((element, index) => {
+            if (element.positioning === positioning) {
+                positionCount++;
+            }
+        });
+        this.projectService.project.fixtures.forEach((element, index) => {
+            if (element.positioning === positioning) {
+                element.positionX = xMin + ((xMax - xMin) / (positionCount + 1)) * positionIndex;
+                element.positionY = yMin + ((yMax - yMin) / (positionCount + 1)) * positionIndex;
+                element.positionZ = zMin + ((zMax - zMin) / (positionCount + 1)) * positionIndex;
+                positionIndex++;
+            }
+        });
+    }
+    animate(timeMillis) {
+        if (this.timelineService.playState === 'playing') {
+            // Overwrite the current time with the playing time, if we're in playback mode
+            timeMillis = this.timelineService.waveSurfer.getCurrentTime() * 1000;
+        }
+        this.animationService.timeMillis = timeMillis;
+        // Update the controls
+        if (this.controls) {
+            this.controls.update();
+        }
+        // Update the positions
+        this.updateStagePosition(Positioning.topFront, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - 70, this.projectService.project.stageDepthCm / 2 - 70);
+        this.updateStagePosition(Positioning.bottomFront, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - 70, this.projectService.project.stageDepthCm / 2 - 70);
+        this.updateStagePosition(Positioning.topBack, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + 70, -this.projectService.project.stageDepthCm / 2 + 70);
+        this.updateStagePosition(Positioning.bottomBack, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + 70, -this.projectService.project.stageDepthCm / 2 + 70);
+        // Update all fixtures and apply the preview properties, if available
+        // TODO Update the fixtures only e.g. 40 times per second according to the "real" refresh rate of the DMX interface?
+        const presets = this.previewService.getPresets(timeMillis);
+        const calculatedFixtures = this.previewService.getChannelValues(timeMillis, presets);
+        for (const fixture3d of this.fixtures3d) {
+            // Update the fixture properties
+            fixture3d.updatePreview(calculatedFixtures.get(fixture3d.fixture) || [], this.projectService.project.masterDimmerValue);
+            // Select the fixture, if required
+            if (this.fixtureService.settingsSelection) {
+                fixture3d.isSelected = this.fixtureService.settingsFixtureIsSelected(fixture3d.fixture.fixture);
+            }
+            else {
+                fixture3d.isSelected = this.previewService.fixtureIsSelected(fixture3d.fixture.fixture.uuid, presets);
+            }
+        }
+        // TODO enable for monitoring the DMX universes
+        this.previewService.setUniverseValues(calculatedFixtures, this.projectService.project.masterDimmerValue);
+        // Render the scene
+        this.render();
+        requestAnimationFrame(this.animate.bind(this));
+    }
+    getAspectRatio() {
+        const height = this.canvas.clientHeight;
+        if (height === 0) {
+            return 0;
+        }
+        return this.canvas.clientWidth / this.canvas.clientHeight;
+    }
+    onResize() {
+        this.camera.aspect = this.getAspectRatio();
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
+    }
+    setupRenderer() {
+        this.renderer = new THREE.WebGLRenderer({ antialias: true });
+        this.canvas.appendChild(this.renderer.domElement);
+        this.renderer.setPixelRatio(devicePixelRatio);
+        this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
+        // this.renderer.shadowMap.enabled = true;
+        // this.renderer.gammaInput = true;
+        // this.renderer.gammaOutput = true;
+    }
+    setupCamera() {
+        this.camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 1, 10000);
+        this.camera.position.set(-600, 80, 700);
+    }
+    setupControls() {
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.enableKeys = false;
+        this.controls.rotateSpeed = 0.05;
+        this.controls.zoomSpeed = 1.2;
+        this.controls.enableDamping = true;
+        this.controls.dampingFactor = 0.25;
+        this.controls.screenSpacePanning = false;
+        this.controls.minDistance = 700;
+        // this.controls.zoom = 1000;
+        this.controls.maxDistance = 2000;
+        this.controls.maxPolarAngle = Math.PI / 2;
+        this.controls.target = new THREE.Vector3(0, 200, 0);
+        // this.controls.rotation = 100;
+    }
+    setupScene() {
+        // Create a new scene
+        this.scene = new THREE.Scene();
+        // this.scene.background = new THREE.Color(0x080808);
+        // this.scene.fog	= new THREE.FogExp2( 0x000000, 0.1 );
+        this.previewService.scene = this.scene;
+        // Add a little bit of ambient light
+        const ambient = new THREE.AmbientLight(0xffffff, 1.5);
+        this.scene.add(ambient);
+        // Create the stage dimensions
+        this.previewService.updateStage();
+        const lights = [];
+        lights[0] = new THREE.PointLight(0xffffff, 1, 0, 0.1);
+        lights[1] = new THREE.PointLight(0xffffff, 1, 0, 0.1);
+        lights[2] = new THREE.PointLight(0xffffff, 1, 0, 0.1);
+        lights[0].position.set(0, 2000, 0);
+        lights[1].position.set(1000, 2000, 1000);
+        lights[2].position.set(-1000, -2000, -1000);
+        lights[0].castShadow = true;
+        lights[1].castShadow = true;
+        lights[2].castShadow = true;
+        this.scene.add(lights[0]);
+        this.scene.add(lights[1]);
+        this.scene.add(lights[2]);
+    }
+    ngAfterViewInit() {
+        this.setupRenderer();
+        this.setupCamera();
+        this.setupControls();
+        this.setupScene();
+        this.onResize();
+        this.animate(null);
+    }
+    static { this.ɵfac = function PreviewComponent_Factory(t) { return new (t || PreviewComponent)(i0.ɵɵdirectiveInject(i1.FixtureService), i0.ɵɵdirectiveInject(i2.PreviewMeshService), i0.ɵɵdirectiveInject(i3.AnimationService), i0.ɵɵdirectiveInject(i4.PreviewService), i0.ɵɵdirectiveInject(i5.TimelineService), i0.ɵɵdirectiveInject(i6.ProjectService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PreviewComponent, selectors: [["lib-app-preview"]], viewQuery: function PreviewComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.canvasRef = _t.first);
+        } }, hostBindings: function PreviewComponent_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("resize", function PreviewComponent_resize_HostBindingHandler() { return ctx.onResize(); }, false, i0.ɵɵresolveWindow);
+        } }, decls: 2, vars: 0, consts: [["canvas", ""], [1, "h-100", 2, "overflow", "hidden"]], template: function PreviewComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "div", 1, 0);
+        } } }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreviewComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-preview', template: "<div class=\"h-100\" #canvas style=\"overflow: hidden\"></div>\n" }]
+    }], () => [{ type: i1.FixtureService }, { type: i2.PreviewMeshService }, { type: i3.AnimationService }, { type: i4.PreviewService }, { type: i5.TimelineService }, { type: i6.ProjectService }], { canvasRef: [{
+            type: ViewChild,
+            args: ['canvas']
+        }], onResize: [{
+            type: HostListener,
+            args: ['window:resize']
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PreviewComponent, { className: "PreviewComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.component.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/preview/preview.component.ts","../../../../../projects/designer/src/lib/preview/preview.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, HostListener, ViewChild } from '@angular/core';\nimport * as THREE from 'three';\nimport { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';\nimport { FixtureCategory } from '../models/fixture-profile';\nimport { FixtureService } from '../services/fixture.service';\nimport { PreviewMeshService } from '../services/preview-mesh.service';\nimport { PreviewService } from '../services/preview.service';\nimport { ProjectService } from '../services/project.service';\nimport { TimelineService } from '../services/timeline.service';\nimport { Positioning } from './../models/fixture';\nimport { AnimationService } from './../services/animation.service';\nimport { ColorChanger3d } from './models/color-changer-3d';\nimport { Fixture3d } from './models/fixture-3d';\nimport { MovingHead3d } from './models/moving-head-3d';\n\n@Component({\n  selector: 'lib-app-preview',\n  templateUrl: './preview.component.html',\n  styleUrls: ['./preview.component.css'],\n})\nexport class PreviewComponent implements AfterViewInit {\n  private renderer: THREE.WebGLRenderer;\n  private scene: THREE.Scene;\n  private camera: THREE.PerspectiveCamera;\n  public controls: OrbitControls;\n\n  private fixtures3d: Fixture3d[] = [];\n\n  @ViewChild('canvas')\n  private canvasRef: ElementRef;\n\n  constructor(\n    private fixtureService: FixtureService,\n    private previewMeshService: PreviewMeshService,\n    private animationService: AnimationService,\n    private previewService: PreviewService,\n    private timelineService: TimelineService,\n    private projectService: ProjectService\n  ) {\n    this.previewService.doUpdateFixtureSetup.subscribe(() => {\n      // synchronize the 3d-fixtures to the project fixtures\n      this.syncFixtures();\n    });\n  }\n\n  private syncFixtures() {\n    // remove all fixtures\n    for (const fixture3d of this.fixtures3d) {\n      fixture3d.destroy();\n    }\n    this.fixtures3d = [];\n\n    // add all fixtures from the project\n    for (const fixture of this.fixtureService.cachedFixtures) {\n      switch (fixture.profile.categories[0]) {\n        case FixtureCategory['Moving Head']:\n          this.fixtures3d.push(new MovingHead3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n        case FixtureCategory['Color Changer']:\n          this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n        case FixtureCategory['Blinder']:\n          this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n      }\n    }\n  }\n\n  private get canvas(): HTMLCanvasElement {\n    return this.canvasRef.nativeElement;\n  }\n\n  private render() {\n    this.renderer.render(this.scene, this.camera);\n  }\n\n  private updateStagePosition(\n    positioning: Positioning,\n    xMin: number,\n    xMax: number,\n    yMin: number,\n    yMax: number,\n    zMin: number,\n    zMax: number\n  ) {\n    let positionCount = 0; // Number of fixtures in the same position\n    let positionIndex = 1;\n\n    this.projectService.project.fixtures.forEach((element, index) => {\n      if (element.positioning === positioning) {\n        positionCount++;\n      }\n    });\n\n    this.projectService.project.fixtures.forEach((element, index) => {\n      if (element.positioning === positioning) {\n        element.positionX = xMin + ((xMax - xMin) / (positionCount + 1)) * positionIndex;\n        element.positionY = yMin + ((yMax - yMin) / (positionCount + 1)) * positionIndex;\n        element.positionZ = zMin + ((zMax - zMin) / (positionCount + 1)) * positionIndex;\n\n        positionIndex++;\n      }\n    });\n  }\n\n  private animate(timeMillis: number) {\n    if (this.timelineService.playState === 'playing') {\n      // Overwrite the current time with the playing time, if we're in playback mode\n      timeMillis = this.timelineService.waveSurfer.getCurrentTime() * 1000;\n    }\n\n    this.animationService.timeMillis = timeMillis;\n\n    // Update the controls\n    if (this.controls) {\n      this.controls.update();\n    }\n\n    // Update the positions\n    this.updateStagePosition(\n      Positioning.topFront,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - 70,\n      this.projectService.project.stageDepthCm / 2 - 70\n    );\n    this.updateStagePosition(\n      Positioning.bottomFront,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - 70,\n      this.projectService.project.stageDepthCm / 2 - 70\n    );\n    this.updateStagePosition(\n      Positioning.topBack,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + 70,\n      -this.projectService.project.stageDepthCm / 2 + 70\n    );\n    this.updateStagePosition(\n      Positioning.bottomBack,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + 70,\n      -this.projectService.project.stageDepthCm / 2 + 70\n    );\n\n    // Update all fixtures and apply the preview properties, if available\n    // TODO Update the fixtures only e.g. 40 times per second according to the \"real\" refresh rate of the DMX interface?\n    const presets = this.previewService.getPresets(timeMillis);\n\n    const calculatedFixtures = this.previewService.getChannelValues(timeMillis, presets);\n\n    for (const fixture3d of this.fixtures3d) {\n      // Update the fixture properties\n      fixture3d.updatePreview(calculatedFixtures.get(fixture3d.fixture) || [], this.projectService.project.masterDimmerValue);\n\n      // Select the fixture, if required\n      if (this.fixtureService.settingsSelection) {\n        fixture3d.isSelected = this.fixtureService.settingsFixtureIsSelected(fixture3d.fixture.fixture);\n      } else {\n        fixture3d.isSelected = this.previewService.fixtureIsSelected(fixture3d.fixture.fixture.uuid, presets);\n      }\n    }\n\n    // TODO enable for monitoring the DMX universes\n    this.previewService.setUniverseValues(calculatedFixtures, this.projectService.project.masterDimmerValue);\n\n    // Render the scene\n    this.render();\n\n    requestAnimationFrame(this.animate.bind(this));\n  }\n\n  private getAspectRatio(): number {\n    const height = this.canvas.clientHeight;\n\n    if (height === 0) {\n      return 0;\n    }\n\n    return this.canvas.clientWidth / this.canvas.clientHeight;\n  }\n\n  @HostListener('window:resize')\n  public onResize() {\n    this.camera.aspect = this.getAspectRatio();\n    this.camera.updateProjectionMatrix();\n    this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);\n  }\n\n  private setupRenderer() {\n    this.renderer = new THREE.WebGLRenderer({ antialias: true });\n    this.canvas.appendChild(this.renderer.domElement);\n    this.renderer.setPixelRatio(devicePixelRatio);\n    this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);\n    // this.renderer.shadowMap.enabled = true;\n    // this.renderer.gammaInput = true;\n    // this.renderer.gammaOutput = true;\n  }\n\n  private setupCamera() {\n    this.camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 1, 10000);\n    this.camera.position.set(-600, 80, 700);\n  }\n\n  private setupControls() {\n    this.controls = new OrbitControls(this.camera, this.renderer.domElement);\n    this.controls.enableKeys = false;\n    this.controls.rotateSpeed = 0.05;\n    this.controls.zoomSpeed = 1.2;\n    this.controls.enableDamping = true;\n    this.controls.dampingFactor = 0.25;\n    this.controls.screenSpacePanning = false;\n    this.controls.minDistance = 700;\n    // this.controls.zoom = 1000;\n    this.controls.maxDistance = 2000;\n    this.controls.maxPolarAngle = Math.PI / 2;\n    this.controls.target = new THREE.Vector3(0, 200, 0);\n    // this.controls.rotation = 100;\n  }\n\n  private setupScene() {\n    // Create a new scene\n    this.scene = new THREE.Scene();\n    // this.scene.background = new THREE.Color(0x080808);\n    // this.scene.fog\t= new THREE.FogExp2( 0x000000, 0.1 );\n\n    this.previewService.scene = this.scene;\n\n    // Add a little bit of ambient light\n    const ambient = new THREE.AmbientLight(0xffffff, 1.5);\n    this.scene.add(ambient);\n\n    // Create the stage dimensions\n    this.previewService.updateStage();\n\n    const lights = [];\n    lights[0] = new THREE.PointLight(0xffffff, 1, 0, 0.1);\n    lights[1] = new THREE.PointLight(0xffffff, 1, 0, 0.1);\n    lights[2] = new THREE.PointLight(0xffffff, 1, 0, 0.1);\n\n    lights[0].position.set(0, 2000, 0);\n    lights[1].position.set(1000, 2000, 1000);\n    lights[2].position.set(-1000, -2000, -1000);\n\n    lights[0].castShadow = true;\n    lights[1].castShadow = true;\n    lights[2].castShadow = true;\n\n    this.scene.add(lights[0]);\n    this.scene.add(lights[1]);\n    this.scene.add(lights[2]);\n  }\n\n  ngAfterViewInit(): void {\n    this.setupRenderer();\n    this.setupCamera();\n    this.setupControls();\n    this.setupScene();\n\n    this.onResize();\n    this.animate(null);\n  }\n}\n","<div class=\"h-100\" #canvas style=\"overflow: hidden\"></div>\n"]}