@rocketshow/designer 1.32.0 → 1.33.0

package/esm2022/lib/preset/preset.component.mjs

@@ -0,0 +1,131 @@
+import { Component } from '@angular/core';
+import { BsModalService } from 'ngx-bootstrap/modal';
+import { IntroService } from '../services/intro.service';
+import { PresetService } from '../services/preset.service';
+import { ProjectService } from '../services/project.service';
+import { SceneService } from '../services/scene.service';
+import { PresetSettingsComponent } from './preset-settings/preset-settings.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/preset.service";
+import * as i2 from "../services/scene.service";
+import * as i3 from "../services/project.service";
+import * as i4 from "../services/intro.service";
+import * as i5 from "ngx-bootstrap/modal";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/forms";
+import * as i8 from "ngx-sortablejs-plus";
+import * as i9 from "@ngx-translate/core";
+function PresetComponent_div_12_Template(rf, ctx) { if (rf & 1) {
+    const _r1 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 9);
+    i0.ɵɵlistener("click", function PresetComponent_div_12_Template_div_click_0_listener() { const i_r2 = i0.ɵɵrestoreView(_r1).index; const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.selectPreset(i_r2)); });
+    i0.ɵɵelementStart(1, "div", 10)(2, "div", 11);
+    i0.ɵɵelement(3, "i", 12);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "div", 13)(5, "input", 14);
+    i0.ɵɵlistener("ngModelChange", function PresetComponent_div_12_Template_input_ngModelChange_5_listener($event) { const i_r2 = i0.ɵɵrestoreView(_r1).index; const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.activatePreset($event, i_r2)); })("click", function PresetComponent_div_12_Template_input_click_5_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView($event.stopPropagation()); });
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(6, "div");
+    i0.ɵɵtext(7);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(8, "div", 15)(9, "button", 16);
+    i0.ɵɵlistener("click", function PresetComponent_div_12_Template_button_click_9_listener() { const item_r4 = i0.ɵɵrestoreView(_r1).$implicit; const ctx_r2 = i0.ɵɵnextContext(); ctx_r2.openSettings(item_r4); return i0.ɵɵresetView(false); });
+    i0.ɵɵtext(10, "...");
+    i0.ɵɵelementEnd()()()();
+} if (rf & 2) {
+    const item_r4 = ctx.$implicit;
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵclassProp("active-light", !ctx_r2.projectService.project.previewPreset && item_r4 == ctx_r2.presetService.selectedPreset)("active", ctx_r2.projectService.project.previewPreset && item_r4 == ctx_r2.presetService.selectedPreset)("inactive-list-item", !ctx_r2.sceneService.presetIsSelected(item_r4));
+    i0.ɵɵadvance(5);
+    i0.ɵɵproperty("disabled", !ctx_r2.enableCheckbox())("ngModel", ctx_r2.sceneService.presetIsSelected(item_r4));
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", item_r4.name, " ");
+} }
+export class PresetComponent {
+    constructor(presetService, sceneService, projectService, introService, modalService) {
+        this.presetService = presetService;
+        this.sceneService = sceneService;
+        this.projectService = projectService;
+        this.introService = introService;
+        this.modalService = modalService;
+    }
+    ngOnInit() { }
+    selectPreset(index) {
+        this.projectService.project.previewPreset = true;
+        this.presetService.selectPreset(index);
+    }
+    enableCheckbox() {
+        return this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1;
+    }
+    activatePreset(active, index) {
+        if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {
+            const uuid = this.projectService.project.presets[index].uuid;
+            if (active) {
+                // Activate a new uuid
+                this.sceneService.selectedScenes[0].presetUuids.push(uuid);
+            }
+            else {
+                // Remove the uuid
+                for (let i = 0; i < this.sceneService.selectedScenes[0].presetUuids.length; i++) {
+                    if (this.sceneService.selectedScenes[0].presetUuids[i] === uuid) {
+                        this.sceneService.selectedScenes[0].presetUuids.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    addPreset() {
+        this.presetService.addPreset();
+        if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {
+            this.sceneService.selectedScenes[0].presetUuids.push(this.presetService.selectedPreset.uuid);
+        }
+    }
+    removePreset() {
+        if (!this.presetService.selectedPreset) {
+            return;
+        }
+        this.projectService.project.presets.splice(this.projectService.project.presets.indexOf(this.presetService.selectedPreset), 1);
+        this.presetService.selectPreset(0);
+    }
+    openSettings(preset) {
+        const bsModalRef = this.modalService.show(PresetSettingsComponent, {
+            keyboard: true,
+            ignoreBackdropClick: false,
+            class: '',
+            initialState: { preset },
+        });
+    }
+    static { this.ɵfac = function PresetComponent_Factory(t) { return new (t || PresetComponent)(i0.ɵɵdirectiveInject(i1.PresetService), i0.ɵɵdirectiveInject(i2.SceneService), i0.ɵɵdirectiveInject(i3.ProjectService), i0.ɵɵdirectiveInject(i4.IntroService), i0.ɵɵdirectiveInject(i5.BsModalService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PresetComponent, selectors: [["lib-app-preset"]], decls: 13, vars: 7, consts: [[1, "card", "border-secondary", "h-100", "panel", "card-intro-preset", "card-intro-active"], [1, "card-header", "d-flex"], [1, "ml-auto"], ["href", "#", 1, "btn", "btn-secondary", "m-0,", "p-0", 3, "click"], ["aria-hidden", "true", 1, "fa", "fa-minus-circle", "fa-fw"], ["aria-hidden", "true", 1, "fa", "fa-plus-circle", "fa-fw"], [1, "card-body", "h-100", "p-0"], [1, "list-group", 3, "sortablejs"], ["class", "list-group-item", 3, "active-light", "active", "inactive-list-item", "click", 4, "ngFor", "ngForOf"], [1, "list-group-item", 3, "click"], [1, "row", "d-flex", 2, "cursor", "pointer"], [1, "col-auto", "list-sort-handle", "my-auto", 2, "cursor", "move", "cursor", "-webkit-grabbing"], ["aria-hidden", "true", 1, "fa", "fa-bars"], [1, "form-check"], ["type", "checkbox", "id", "active", 1, "form-check-input", 3, "ngModelChange", "click", "disabled", "ngModel"], [1, "my-auto", "ml-auto", "mr-2", "d-flex"], ["type", "button", 1, "btn", "btn-secondary", "btn-sm", "py-0", "px-1", 3, "click"]], template: function PresetComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "div");
+            i0.ɵɵtext(3);
+            i0.ɵɵpipe(4, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "div", 2)(6, "a", 3);
+            i0.ɵɵlistener("click", function PresetComponent_Template_a_click_6_listener() { ctx.removePreset(); return false; });
+            i0.ɵɵelement(7, "i", 4);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(8, "a", 3);
+            i0.ɵɵlistener("click", function PresetComponent_Template_a_click_8_listener() { ctx.addPreset(); return false; });
+            i0.ɵɵelement(9, "i", 5);
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(10, "div", 6)(11, "div", 7);
+            i0.ɵɵtemplate(12, PresetComponent_div_12_Template, 11, 9, "div", 8);
+            i0.ɵɵelementEnd()()();
+        } if (rf & 2) {
+            i0.ɵɵclassProp("card-intro-active", ctx.introService.showStep("presets"));
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(4, 5, "designer.preset.title"), " ");
+            i0.ɵɵadvance(8);
+            i0.ɵɵproperty("sortablejs", ctx.projectService.project.presets);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngForOf", ctx.projectService.project.presets);
+        } }, dependencies: [i6.NgForOf, i7.CheckboxControlValueAccessor, i7.NgControlStatus, i7.NgModel, i8.SortablejsDirective, i9.TranslatePipe] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PresetComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-preset', template: "<div\n  class=\"card border-secondary h-100 panel card-intro-preset card-intro-active\"\n  [class.card-intro-active]=\"introService.showStep('presets')\"\n>\n  <div class=\"card-header d-flex\">\n    <div>\n      {{ 'designer.preset.title' | translate }}\n    </div>\n    <div class=\"ml-auto\">\n      <a href=\"#\" class=\"btn btn-secondary m-0, p-0\" (click)=\"removePreset(); (false)\"\n        ><i class=\"fa fa-minus-circle fa-fw\" aria-hidden=\"true\"></i\n      ></a>\n      <a href=\"#\" class=\"btn btn-secondary m-0, p-0\" (click)=\"addPreset(); (false)\"\n        ><i class=\"fa fa-plus-circle fa-fw\" aria-hidden=\"true\"></i\n      ></a>\n    </div>\n  </div>\n\n  <div class=\"card-body h-100 p-0\">\n    <!-- List of presets -->\n    <div class=\"list-group\" [sortablejs]=\"projectService.project.presets\">\n      <div\n        class=\"list-group-item\"\n        *ngFor=\"let item of projectService.project.presets; let i = index\"\n        (click)=\"selectPreset(i)\"\n        [class.active-light]=\"!projectService.project.previewPreset && item == presetService.selectedPreset\"\n        [class.active]=\"projectService.project.previewPreset && item == presetService.selectedPreset\"\n        [class.inactive-list-item]=\"!sceneService.presetIsSelected(item)\"\n      >\n        <div class=\"row d-flex\" style=\"cursor: pointer\">\n          <div class=\"col-auto list-sort-handle my-auto\" style=\"cursor: move; cursor: -webkit-grabbing\">\n            <i class=\"fa fa-bars\" aria-hidden=\"true\"></i>\n          </div>\n          <div class=\"form-check\">\n            <input\n              type=\"checkbox\"\n              [disabled]=\"!enableCheckbox()\"\n              class=\"form-check-input\"\n              id=\"active\"\n              [ngModel]=\"sceneService.presetIsSelected(item)\"\n              (ngModelChange)=\"activatePreset($event, i)\"\n              (click)=\"$event.stopPropagation()\"\n            />\n          </div>\n          <div>\n            {{ item.name }}\n          </div>\n          <div class=\"my-auto ml-auto mr-2 d-flex\">\n            <button type=\"button\" class=\"btn btn-secondary btn-sm py-0 px-1\" (click)=\"openSettings(item); (false)\">...</button>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n" }]
+    }], () => [{ type: i1.PresetService }, { type: i2.SceneService }, { type: i3.ProjectService }, { type: i4.IntroService }, { type: i5.BsModalService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PresetComponent, { className: "PresetComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset.component.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/preset/preset.component.ts","../../../../../projects/designer/src/lib/preset/preset.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { BsModalService } from 'ngx-bootstrap/modal';\nimport { Preset } from '../models/preset';\nimport { IntroService } from '../services/intro.service';\nimport { PresetService } from '../services/preset.service';\nimport { ProjectService } from '../services/project.service';\nimport { SceneService } from '../services/scene.service';\nimport { PresetSettingsComponent } from './preset-settings/preset-settings.component';\n\n@Component({\n  selector: 'lib-app-preset',\n  templateUrl: './preset.component.html',\n  styleUrls: ['./preset.component.css'],\n})\nexport class PresetComponent implements OnInit {\n  constructor(\n    public presetService: PresetService,\n    public sceneService: SceneService,\n    public projectService: ProjectService,\n    public introService: IntroService,\n    private modalService: BsModalService\n  ) {}\n\n  ngOnInit() {}\n\n  selectPreset(index: number) {\n    this.projectService.project.previewPreset = true;\n    this.presetService.selectPreset(index);\n  }\n\n  enableCheckbox(): boolean {\n    return this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1;\n  }\n\n  activatePreset(active: boolean, index: number) {\n    if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {\n      const uuid = this.projectService.project.presets[index].uuid;\n\n      if (active) {\n        // Activate a new uuid\n        this.sceneService.selectedScenes[0].presetUuids.push(uuid);\n      } else {\n        // Remove the uuid\n        for (let i = 0; i < this.sceneService.selectedScenes[0].presetUuids.length; i++) {\n          if (this.sceneService.selectedScenes[0].presetUuids[i] === uuid) {\n            this.sceneService.selectedScenes[0].presetUuids.splice(i, 1);\n            return;\n          }\n        }\n      }\n    }\n  }\n\n  addPreset() {\n    this.presetService.addPreset();\n\n    if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {\n      this.sceneService.selectedScenes[0].presetUuids.push(this.presetService.selectedPreset.uuid);\n    }\n  }\n\n  removePreset() {\n    if (!this.presetService.selectedPreset) {\n      return;\n    }\n\n    this.projectService.project.presets.splice(this.projectService.project.presets.indexOf(this.presetService.selectedPreset), 1);\n    this.presetService.selectPreset(0);\n  }\n\n  openSettings(preset: Preset) {\n    const bsModalRef = this.modalService.show(PresetSettingsComponent, {\n      keyboard: true,\n      ignoreBackdropClick: false,\n      class: '',\n      initialState: { preset },\n    });\n  }\n}\n","<div\n  class=\"card border-secondary h-100 panel card-intro-preset card-intro-active\"\n  [class.card-intro-active]=\"introService.showStep('presets')\"\n>\n  <div class=\"card-header d-flex\">\n    <div>\n      {{ 'designer.preset.title' | translate }}\n    </div>\n    <div class=\"ml-auto\">\n      <a href=\"#\" class=\"btn btn-secondary m-0, p-0\" (click)=\"removePreset(); (false)\"\n        ><i class=\"fa fa-minus-circle fa-fw\" aria-hidden=\"true\"></i\n      ></a>\n      <a href=\"#\" class=\"btn btn-secondary m-0, p-0\" (click)=\"addPreset(); (false)\"\n        ><i class=\"fa fa-plus-circle fa-fw\" aria-hidden=\"true\"></i\n      ></a>\n    </div>\n  </div>\n\n  <div class=\"card-body h-100 p-0\">\n    <!-- List of presets -->\n    <div class=\"list-group\" [sortablejs]=\"projectService.project.presets\">\n      <div\n        class=\"list-group-item\"\n        *ngFor=\"let item of projectService.project.presets; let i = index\"\n        (click)=\"selectPreset(i)\"\n        [class.active-light]=\"!projectService.project.previewPreset && item == presetService.selectedPreset\"\n        [class.active]=\"projectService.project.previewPreset && item == presetService.selectedPreset\"\n        [class.inactive-list-item]=\"!sceneService.presetIsSelected(item)\"\n      >\n        <div class=\"row d-flex\" style=\"cursor: pointer\">\n          <div class=\"col-auto list-sort-handle my-auto\" style=\"cursor: move; cursor: -webkit-grabbing\">\n            <i class=\"fa fa-bars\" aria-hidden=\"true\"></i>\n          </div>\n          <div class=\"form-check\">\n            <input\n              type=\"checkbox\"\n              [disabled]=\"!enableCheckbox()\"\n              class=\"form-check-input\"\n              id=\"active\"\n              [ngModel]=\"sceneService.presetIsSelected(item)\"\n              (ngModelChange)=\"activatePreset($event, i)\"\n              (click)=\"$event.stopPropagation()\"\n            />\n          </div>\n          <div>\n            {{ item.name }}\n          </div>\n          <div class=\"my-auto ml-auto mr-2 d-flex\">\n            <button type=\"button\" class=\"btn btn-secondary btn-sm py-0 px-1\" (click)=\"openSettings(item); (false)\">...</button>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2022/lib/preview/models/color-changer-3d.mjs

@@ -0,0 +1,167 @@
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as THREE from 'three';
+import { Fixture3d } from './fixture-3d';
+export class ColorChanger3d extends Fixture3d {
+    atmosphereMat() {
+        const vertexShader = [
+            'varying vec3	vVertexWorldPosition;',
+            'varying vec3	vVertexNormal;',
+            'void main(){',
+            '	vVertexNormal = normalize(normalMatrix * normal);',
+            '	vVertexWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;',
+            '	// set gl_Position',
+            '	gl_Position	= projectionMatrix * modelViewMatrix * vec4(position, 1.0);',
+            '}',
+        ].join('\n');
+        const fragmentShader = [
+            'uniform vec3	glowColor;',
+            'uniform float	coeficient;',
+            'uniform float	power;',
+            'uniform float	opacity;',
+            'varying vec3	vVertexNormal;',
+            'varying vec3	vVertexWorldPosition;',
+            'void main(){',
+            '	vec3 worldCameraToVertex= vVertexWorldPosition - cameraPosition;',
+            '	vec3 viewCameraToVertex	= (viewMatrix * vec4(worldCameraToVertex, 0.0)).xyz;',
+            '	viewCameraToVertex	= normalize(viewCameraToVertex);',
+            '	float intensity		= pow(coeficient + dot(vVertexNormal, viewCameraToVertex), power);',
+            '	gl_FragColor		= vec4(glowColor, intensity * opacity);',
+            '}',
+        ].join('\n');
+        // create custom material from the shader code above
+        // that is within specially labeled script tags
+        const material = new THREE.ShaderMaterial({
+            uniforms: {
+                coeficient: {
+                    type: 'f',
+                    value: 0.3,
+                },
+                power: {
+                    type: 'f',
+                    value: 1.3,
+                },
+                opacity: {
+                    type: 'f',
+                    value: 1.0,
+                },
+                glowColor: {
+                    type: 'c',
+                    value: new THREE.Color('white'),
+                },
+            },
+            vertexShader,
+            fragmentShader,
+            // blending: THREE.AdditiveBlending,
+            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.8, 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.spotlightGroup.add(this.spotLightBeam);
+        this.spotLightBeam.rotation.x = Math.PI / 2;
+    }
+    createObjects() {
+        this.material = new THREE.MeshLambertMaterial({
+            color: 0x0d0d0d,
+            emissive: 0x0d0d0d,
+        });
+        this.mesh.material = this.material;
+        // Add the spotlight
+        this.spotLight = new THREE.SpotLight(0xffffff, 1);
+        this.spotLight.angle = 0.244;
+        this.spotLight.penumbra = 0.5;
+        this.spotLight.decay = 2;
+        this.spotLight.distance = 60000;
+        this.spotLight.castShadow = false;
+        this.spotLight.intensity = 10;
+        this.spotLightHelper = new THREE.SpotLightHelper(this.spotLight);
+        // 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, 2, 1000);
+        this.spotlightGroup.add(this.pointLight);
+        this.pointLight.position.set(0, -1.4, 0);
+        // Add the light beam
+        this.createSpotLightBeam();
+        this.objectGroup.add(this.spotlightGroup);
+        this.objectGroup.add(this.mesh);
+        // 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.spotLightMaxIntensity = 5;
+        this.objectGroup = new THREE.Object3D();
+        this.spotlightGroup = new THREE.Object3D();
+        forkJoin([previewMeshService.getMesh('color-changer')])
+            .pipe(map(([colorChanger]) => {
+            this.mesh = colorChanger;
+            this.createObjects();
+        }))
+            .subscribe();
+    }
+    getObject() {
+        return this.objectGroup;
+    }
+    updatePreview(channelValues, masterDimmerValue) {
+        super.updatePreview(channelValues, masterDimmerValue);
+        if (!this.isLoaded) {
+            return;
+        }
+        this.updatePosition(this.objectGroup);
+        // Update the material
+        if (this.lastSelected !== this.isSelected) {
+            if (this.isSelected) {
+                for (const child of this.mesh.children) {
+                    child.material = this.selectedMaterial;
+                }
+            }
+            else {
+                for (const child of this.mesh.children) {
+                    child.material = this.material;
+                }
+            }
+            this.lastSelected = this.isSelected;
+        }
+        // Update the light helpers
+        this.spotLightHelper.update();
+        // 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.glowColor.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);
+        this.spotLightBeam.material.uniforms.opacity.value = Math.min(intensityColor, this.dimmer) * 0.5;
+        this.spotLight.intensity = this.spotLightMaxIntensity * this.dimmer;
+        this.pointLight.intensity = this.pointLightMaxIntensity * this.dimmer;
+    }
+    destroy() {
+        this.scene.remove(this.objectGroup);
+        this.material.dispose();
+        this.atmosphereMaterial.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color-changer-3d.js","sourceRoot":"","sources":["../../../../../../projects/designer/src/lib/preview/models/color-changer-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import { forkJoin } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport * as THREE from 'three';\nimport { Mesh } from 'three';\nimport { CachedFixture } from '../../models/cached-fixture';\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 ColorChanger3d extends Fixture3d {\n  private readonly pointLightMaxIntensity: number = 2;\n  private readonly spotLightMaxIntensity: number = 5;\n\n  private mesh: THREE.Mesh;\n\n  private objectGroup: THREE.Object3D = new THREE.Object3D();\n  private spotlightGroup: 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 lastSelected: boolean;\n\n  private material: THREE.MeshStandardMaterial;\n  private atmosphereMaterial: THREE.ShaderMaterial;\n\n  private atmosphereMat() {\n    const vertexShader = [\n      'varying vec3\tvVertexWorldPosition;',\n      'varying vec3\tvVertexNormal;',\n\n      'void main(){',\n      '\tvVertexNormal = normalize(normalMatrix * normal);',\n\n      '\tvVertexWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;',\n\n      '\t// set gl_Position',\n      '\tgl_Position\t= projectionMatrix * modelViewMatrix * vec4(position, 1.0);',\n      '}',\n    ].join('\\n');\n    const fragmentShader = [\n      'uniform vec3\tglowColor;',\n      'uniform float\tcoeficient;',\n      'uniform float\tpower;',\n      'uniform float\topacity;',\n\n      'varying vec3\tvVertexNormal;',\n      'varying vec3\tvVertexWorldPosition;',\n\n      'void main(){',\n      '\tvec3 worldCameraToVertex= vVertexWorldPosition - cameraPosition;',\n      '\tvec3 viewCameraToVertex\t= (viewMatrix * vec4(worldCameraToVertex, 0.0)).xyz;',\n      '\tviewCameraToVertex\t= normalize(viewCameraToVertex);',\n      '\tfloat intensity\t\t= pow(coeficient + dot(vVertexNormal, viewCameraToVertex), power);',\n      '\tgl_FragColor\t\t= vec4(glowColor, intensity * opacity);',\n      '}',\n    ].join('\\n');\n\n    // create custom material from the shader code above\n    // that is within specially labeled script tags\n    const material = new THREE.ShaderMaterial({\n      uniforms: {\n        coeficient: {\n          type: 'f',\n          value: 0.3,\n        },\n        power: {\n          type: 'f',\n          value: 1.3,\n        },\n        opacity: {\n          type: 'f',\n          value: 1.0,\n        },\n        glowColor: {\n          type: 'c',\n          value: new THREE.Color('white'),\n        },\n      },\n      vertexShader,\n      fragmentShader,\n      // blending: THREE.AdditiveBlending,\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.8, 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\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.mesh.material = this.material;\n\n    // Add the spotlight\n    this.spotLight = new THREE.SpotLight(0xffffff, 1);\n    this.spotLight.angle = 0.244;\n    this.spotLight.penumbra = 0.5;\n    this.spotLight.decay = 2;\n    this.spotLight.distance = 60000;\n    this.spotLight.castShadow = false;\n    this.spotLight.intensity = 10;\n\n    this.spotLightHelper = new THREE.SpotLightHelper(this.spotLight);\n    // 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, 2, 1000);\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.objectGroup.add(this.spotlightGroup);\n    this.objectGroup.add(this.mesh);\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([previewMeshService.getMesh('color-changer')])\n      .pipe(\n        map(([colorChanger]) => {\n          this.mesh = colorChanger;\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    this.updatePosition(this.objectGroup);\n\n    // Update the material\n    if (this.lastSelected !== this.isSelected) {\n      if (this.isSelected) {\n        for (const child of this.mesh.children) {\n          (child as Mesh).material = this.selectedMaterial;\n        }\n      } else {\n        for (const child of this.mesh.children) {\n          (child as Mesh).material = this.material;\n        }\n      }\n\n      this.lastSelected = this.isSelected;\n    }\n\n    // Update the light helpers\n    this.spotLightHelper.update();\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 as any).uniforms.glowColor.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    (this.spotLightBeam.material as any).uniforms.opacity.value = Math.min(intensityColor, this.dimmer) * 0.5;\n\n    this.spotLight.intensity = this.spotLightMaxIntensity * this.dimmer;\n    this.pointLight.intensity = this.pointLightMaxIntensity * this.dimmer;\n  }\n\n  destroy() {\n    this.scene.remove(this.objectGroup);\n    this.material.dispose();\n    this.atmosphereMaterial.dispose();\n  }\n}\n"]}

package/esm2022/lib/preview/models/fixture-3d.mjs

@@ -0,0 +1,150 @@
+import * as THREE from 'three';
+import { Positioning } from '../../models/fixture';
+import { FixtureCapabilityColor, FixtureCapabilityType } from '../../models/fixture-capability';
+export class Fixture3d {
+    constructor(fixtureService, fixture, scene) {
+        this.fixtureService = fixtureService;
+        this.fixtureHasDimmer = false;
+        this.fixtureHasColorWheel = false;
+        this.fixtureHasColor = false;
+        this.dimmer = 0;
+        this.isSelected = false;
+        this.isLoaded = false;
+        this.fixture = fixture;
+        this.scene = scene;
+        // TODO Don't create it for each fixture but pass it from the preview service
+        this.selectedMaterial = new THREE.MeshLambertMaterial({
+            color: 0xff00ff,
+            emissive: 0xff00ff,
+        });
+        // evaluate, various capabilities of this fixture
+        for (const cachedChannel of this.fixture.channels) {
+            if (cachedChannel.channel) {
+                for (const capability of cachedChannel.capabilities) {
+                    switch (capability.capability.type) {
+                        case FixtureCapabilityType.Intensity:
+                            this.fixtureHasDimmer = true;
+                            break;
+                        case FixtureCapabilityType.ColorIntensity:
+                            this.fixtureHasColor = true;
+                            break;
+                    }
+                }
+                if (cachedChannel.colorWheel) {
+                    this.fixtureHasColorWheel = true;
+                }
+            }
+        }
+    }
+    getCapabilityInValue(channel, value) {
+        for (const capability of channel.capabilities) {
+            if (capability.capability.dmxRange.length === 0 ||
+                (value >= capability.capability.dmxRange[0] && value <= capability.capability.dmxRange[1])) {
+                return capability;
+            }
+        }
+        return undefined;
+    }
+    // Apply the properties of the base fixture to the preview
+    updatePreview(channelValues, masterDimmerValue) {
+        // Apply default settings
+        if (this.fixtureHasDimmer) {
+            this.dimmer = 0;
+        }
+        else {
+            this.dimmer = 1;
+        }
+        this.colorRed = 255;
+        this.colorGreen = 255;
+        this.colorBlue = 255;
+        if (!this.fixtureHasColorWheel && this.fixtureHasColor) {
+            this.colorRed = 0;
+            this.colorGreen = 0;
+            this.colorBlue = 0;
+        }
+        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.Intensity: {
+                        let valuePercentage;
+                        if (capability.capability.dmxRange.length > 0) {
+                            valuePercentage =
+                                (channelValue.value - capability.capability.dmxRange[0]) /
+                                    (capability.capability.dmxRange[1] - capability.capability.dmxRange[0]);
+                        }
+                        else {
+                            valuePercentage = channelValue.value / channel.maxValue;
+                        }
+                        this.dimmer = valuePercentage * masterDimmerValue;
+                        break;
+                    }
+                    case FixtureCapabilityType.ColorIntensity: {
+                        const valuePercentage = (255 * channelValue.value) / channel.maxValue;
+                        switch (capability.capability.color) {
+                            case FixtureCapabilityColor.Red:
+                                // Round needed for threejs
+                                this.colorRed = Math.round(valuePercentage);
+                                break;
+                            case FixtureCapabilityColor.Green:
+                                // Round needed for threejs
+                                this.colorGreen = Math.round(valuePercentage);
+                                break;
+                            case FixtureCapabilityColor.Blue:
+                                // Round needed for threejs
+                                this.colorBlue = Math.round(valuePercentage);
+                                break;
+                        }
+                        break;
+                    }
+                    case FixtureCapabilityType.WheelSlot: {
+                        const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);
+                        if (mixedColor) {
+                            this.colorRed = Math.round(mixedColor.red);
+                            this.colorGreen = Math.round(mixedColor.green);
+                            this.colorBlue = Math.round(mixedColor.blue);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    updatePosition(object) {
+        // Update the position
+        switch (this.fixture.fixture.positioning) {
+            case Positioning.topFront: {
+                object.rotation.x = THREE.MathUtils.degToRad(0);
+                object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY - 13, this.fixture.fixture.positionZ);
+                break;
+            }
+            case Positioning.bottomFront: {
+                object.rotation.x = THREE.MathUtils.degToRad(180);
+                object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY + 13, this.fixture.fixture.positionZ);
+                break;
+            }
+            case Positioning.topBack: {
+                object.rotation.x = THREE.MathUtils.degToRad(0);
+                object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY - 13, this.fixture.fixture.positionZ);
+                break;
+            }
+            case Positioning.bottomBack: {
+                object.rotation.x = THREE.MathUtils.degToRad(180);
+                object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY + 13, this.fixture.fixture.positionZ);
+                break;
+            }
+            case Positioning.manual: {
+                object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY, this.fixture.fixture.positionZ);
+                object.rotation.x = THREE.MathUtils.degToRad(this.fixture.fixture.rotationX);
+                object.rotation.y = THREE.MathUtils.degToRad(this.fixture.fixture.rotationY);
+                object.rotation.z = THREE.MathUtils.degToRad(this.fixture.fixture.rotationZ);
+                break;
+            }
+        }
+    }
+    destroy() {
+        this.selectedMaterial.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixture-3d.js","sourceRoot":"","sources":["../../../../../../projects/designer/src/lib/preview/models/fixture-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\nimport { CachedFixture } from '../../models/cached-fixture';\nimport { CachedFixtureCapability } from '../../models/cached-fixture-capability';\nimport { CachedFixtureChannel } from '../../models/cached-fixture-channel';\nimport { Positioning } from '../../models/fixture';\nimport { FixtureCapabilityColor, FixtureCapabilityType } from '../../models/fixture-capability';\nimport { FixtureChannelValue } from '../../models/fixture-channel-value';\nimport { FixtureService } from '../../services/fixture.service';\n\nexport abstract class Fixture3d {\n  fixture: CachedFixture;\n  fixtureHasDimmer = false;\n  fixtureHasColorWheel = false;\n  fixtureHasColor = false;\n\n  scene: any;\n\n  colorRed: number;\n  colorGreen: number;\n  colorBlue: number;\n\n  dimmer = 0;\n\n  isSelected = false;\n  isLoaded = false;\n\n  protected selectedMaterial: THREE.MeshLambertMaterial;\n\n  constructor(public fixtureService: FixtureService, fixture: CachedFixture, scene: any) {\n    this.fixture = fixture;\n    this.scene = scene;\n\n    // TODO Don't create it for each fixture but pass it from the preview service\n    this.selectedMaterial = new THREE.MeshLambertMaterial({\n      color: 0xff00ff,\n      emissive: 0xff00ff,\n    });\n\n    // evaluate, various capabilities of this fixture\n    for (const cachedChannel of this.fixture.channels) {\n      if (cachedChannel.channel) {\n        for (const capability of cachedChannel.capabilities) {\n          switch (capability.capability.type) {\n            case FixtureCapabilityType.Intensity:\n              this.fixtureHasDimmer = true;\n              break;\n            case FixtureCapabilityType.ColorIntensity:\n              this.fixtureHasColor = true;\n              break;\n          }\n        }\n\n        if (cachedChannel.colorWheel) {\n          this.fixtureHasColorWheel = true;\n        }\n      }\n    }\n  }\n\n  protected getCapabilityInValue(channel: CachedFixtureChannel, value: number): CachedFixtureCapability {\n    for (const capability of channel.capabilities) {\n      if (\n        capability.capability.dmxRange.length === 0 ||\n        (value >= capability.capability.dmxRange[0] && value <= capability.capability.dmxRange[1])\n      ) {\n        return capability;\n      }\n    }\n\n    return undefined;\n  }\n\n  // Apply the properties of the base fixture to the preview\n  updatePreview(channelValues: FixtureChannelValue[], masterDimmerValue: number) {\n    // Apply default settings\n    if (this.fixtureHasDimmer) {\n      this.dimmer = 0;\n    } else {\n      this.dimmer = 1;\n    }\n\n    this.colorRed = 255;\n    this.colorGreen = 255;\n    this.colorBlue = 255;\n\n    if (!this.fixtureHasColorWheel && this.fixtureHasColor) {\n      this.colorRed = 0;\n      this.colorGreen = 0;\n      this.colorBlue = 0;\n    }\n\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\n      if (capability) {\n        switch (capability.capability.type) {\n          case FixtureCapabilityType.Intensity: {\n            let valuePercentage: number;\n            if (capability.capability.dmxRange.length > 0) {\n              valuePercentage =\n                (channelValue.value - capability.capability.dmxRange[0]) /\n                (capability.capability.dmxRange[1] - capability.capability.dmxRange[0]);\n            } else {\n              valuePercentage = channelValue.value / channel.maxValue;\n            }\n            this.dimmer = valuePercentage * masterDimmerValue;\n            break;\n          }\n          case FixtureCapabilityType.ColorIntensity: {\n            const valuePercentage = (255 * channelValue.value) / channel.maxValue;\n            switch (capability.capability.color) {\n              case FixtureCapabilityColor.Red:\n                // Round needed for threejs\n                this.colorRed = Math.round(valuePercentage);\n                break;\n              case FixtureCapabilityColor.Green:\n                // Round needed for threejs\n                this.colorGreen = Math.round(valuePercentage);\n                break;\n              case FixtureCapabilityColor.Blue:\n                // Round needed for threejs\n                this.colorBlue = Math.round(valuePercentage);\n                break;\n            }\n            break;\n          }\n          case FixtureCapabilityType.WheelSlot: {\n            const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);\n            if (mixedColor) {\n              this.colorRed = Math.round(mixedColor.red);\n              this.colorGreen = Math.round(mixedColor.green);\n              this.colorBlue = Math.round(mixedColor.blue);\n            }\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  updatePosition(object: THREE.Object3D) {\n    // Update the position\n    switch (this.fixture.fixture.positioning) {\n      case Positioning.topFront: {\n        object.rotation.x = THREE.MathUtils.degToRad(0);\n        object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY - 13, this.fixture.fixture.positionZ);\n        break;\n      }\n      case Positioning.bottomFront: {\n        object.rotation.x = THREE.MathUtils.degToRad(180);\n        object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY + 13, this.fixture.fixture.positionZ);\n        break;\n      }\n      case Positioning.topBack: {\n        object.rotation.x = THREE.MathUtils.degToRad(0);\n        object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY - 13, this.fixture.fixture.positionZ);\n        break;\n      }\n      case Positioning.bottomBack: {\n        object.rotation.x = THREE.MathUtils.degToRad(180);\n        object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY + 13, this.fixture.fixture.positionZ);\n        break;\n      }\n      case Positioning.manual: {\n        object.position.set(this.fixture.fixture.positionX, this.fixture.fixture.positionY, this.fixture.fixture.positionZ);\n        object.rotation.x = THREE.MathUtils.degToRad(this.fixture.fixture.rotationX);\n        object.rotation.y = THREE.MathUtils.degToRad(this.fixture.fixture.rotationY);\n        object.rotation.z = THREE.MathUtils.degToRad(this.fixture.fixture.rotationZ);\n        break;\n      }\n    }\n  }\n\n  destroy() {\n    this.selectedMaterial.dispose();\n  }\n}\n"]}