@rocketshow/designer 1.32.0 → 1.35.0

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

@@ -0,0 +1,449 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { FixtureCapabilityColor, FixtureCapabilityType } from '../models/fixture-capability';
+import { FixtureCapabilityValue } from '../models/fixture-capability-value';
+import { FixtureChannelValue } from '../models/fixture-channel-value';
+import { Preset } from '../models/preset';
+import { AnimationService } from './animation.service';
+import { ConfigService } from './config.service';
+import { EffectService } from './effect.service';
+import { FixtureService } from './fixture.service';
+import { ProjectService } from './project.service';
+import { UuidService } from './uuid.service';
+import { PresetFixture } from '../models/preset-fixture';
+import * as i0 from "@angular/core";
+import * as i1 from "./effect.service";
+import * as i2 from "./uuid.service";
+import * as i3 from "./project.service";
+import * as i4 from "./fixture.service";
+import * as i5 from "./config.service";
+import * as i6 from "@angular/common/http";
+import * as i7 from "./animation.service";
+export class PresetService {
+    constructor(effectService, uuidService, projectService, fixtureService, configService, http, animationService) {
+        this.effectService = effectService;
+        this.uuidService = uuidService;
+        this.projectService = projectService;
+        this.fixtureService = fixtureService;
+        this.configService = configService;
+        this.http = http;
+        this.animationService = animationService;
+        // fires, when the current preview element has changed (scene/preset)
+        this.previewSelectionChanged = new Subject();
+        // fires, when the fixture selection has changed
+        this.fixtureSelectionChanged = new Subject();
+        // fires, when the fixture selection has changed for settings
+        this.fixtureSelectionSettingsChanged = new Subject();
+        // fires, when the selected color has changed. This is required,
+        // because detectChanges is not enough to trigger different components.
+        this.fixtureColorChanged = new Subject();
+        this.liveChangePending = false;
+    }
+    getPresetByUuid(uuid) {
+        for (const preset of this.projectService.project.presets) {
+            if (preset.uuid === uuid) {
+                return preset;
+            }
+        }
+    }
+    getPresetFixture(preset, fixtureUuid, pixelKey) {
+        for (const fixture of preset.fixtures) {
+            if (fixture.fixtureUuid === fixtureUuid && ((!fixture.pixelKey && !pixelKey) || fixture.pixelKey === pixelKey)) {
+                return fixture;
+            }
+        }
+        return null;
+    }
+    fixtureIsSelected(fixture, pixelKey, preset) {
+        // is the passed fixture selected in the passed/currently selected preset?
+        if (!preset) {
+            if (this.selectedPreset) {
+                preset = this.selectedPreset;
+            }
+            else {
+                return false;
+            }
+        }
+        const presetFixture = this.getPresetFixture(preset, fixture.uuid, pixelKey);
+        if (presetFixture) {
+            return true;
+        }
+        return false;
+    }
+    switchFixtureSelection(fixture, pixelKey) {
+        if (!this.selectedPreset) {
+            return;
+        }
+        // select all fixtures at the specified start channel or unselect them,
+        // if already selected
+        if (this.fixtureIsSelected(fixture, pixelKey)) {
+            for (let i = this.selectedPreset.fixtures.length - 1; i >= 0; i--) {
+                const projectFixture = this.fixtureService.getFixtureByUuid(this.selectedPreset.fixtures[i].fixtureUuid);
+                if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel &&
+                    ((!this.selectedPreset.fixtures[i].pixelKey && !pixelKey) || this.selectedPreset.fixtures[i].pixelKey === pixelKey)) {
+                    this.selectedPreset.fixtures.splice(i, 1);
+                }
+            }
+        }
+        else {
+            for (const projectPresetFixture of this.projectService.project.presetFixtures) {
+                if ((!projectPresetFixture.pixelKey && !pixelKey) || projectPresetFixture.pixelKey === pixelKey) {
+                    const projectFixture = this.fixtureService.getFixtureByUuid(projectPresetFixture.fixtureUuid);
+                    if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {
+                        const presetFixture = new PresetFixture();
+                        presetFixture.fixtureUuid = projectPresetFixture.fixtureUuid;
+                        presetFixture.pixelKey = pixelKey;
+                        this.selectedPreset.fixtures.push(presetFixture);
+                    }
+                }
+            }
+        }
+    }
+    selectAllFixtures() {
+        if (!this.selectedPreset) {
+            return;
+        }
+        for (const fixture of this.projectService.project.fixtures) {
+            const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);
+            if (pixelKeys.length > 0) {
+                for (const pixelKey of pixelKeys) {
+                    if (!this.fixtureIsSelected(fixture, pixelKey)) {
+                        const presetFixture = new PresetFixture();
+                        presetFixture.fixtureUuid = fixture.uuid;
+                        presetFixture.pixelKey = pixelKey;
+                        this.selectedPreset.fixtures.push(presetFixture);
+                    }
+                }
+            }
+            else {
+                if (!this.fixtureIsSelected(fixture, null)) {
+                    const presetFixture = new PresetFixture();
+                    presetFixture.fixtureUuid = fixture.uuid;
+                    this.selectedPreset.fixtures.push(presetFixture);
+                }
+            }
+        }
+    }
+    selectNoFixtures() {
+        if (!this.selectedPreset) {
+            return;
+        }
+        this.selectedPreset.fixtures = [];
+    }
+    removeDeletedFixtures() {
+        // after changing the configuration in the fixture pool, we might need to
+        // delete some fixtures
+        for (const preset of this.projectService.project.presets) {
+            for (let i = preset.fixtures.length - 1; i >= 0; i--) {
+                const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtures[i].fixtureUuid);
+                if (!presetFixture) {
+                    preset.fixtures.splice(i, 1);
+                }
+            }
+        }
+    }
+    updateFixtureSelection() {
+        // after changing the configuration in the fixture pool, we might need to
+        // select some more fixtures on the same channel as already selected ones
+        for (const preset of this.projectService.project.presets) {
+            for (let presetFixture of preset.fixtures) {
+                const fixture = this.fixtureService.getFixtureByUuid(presetFixture.fixtureUuid);
+                for (const projectFixture of this.projectService.project.fixtures) {
+                    if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel &&
+                        !this.fixtureIsSelected(projectFixture, presetFixture.pixelKey, preset)) {
+                        const newPresetFixture = new PresetFixture();
+                        newPresetFixture.fixtureUuid = projectFixture.uuid;
+                        newPresetFixture.pixelKey = presetFixture.pixelKey;
+                        preset.fixtures.push(newPresetFixture);
+                    }
+                }
+            }
+        }
+    }
+    deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid) {
+        for (let i = 0; i < preset.fixtureCapabilityValues.length; i++) {
+            if (this.fixtureService.capabilitiesMatch(preset.fixtureCapabilityValues[i].type, capabilityType, preset.fixtureCapabilityValues[i].color, color, preset.fixtureCapabilityValues[i].wheel, wheel, preset.fixtureCapabilityValues[i].profileUuid, profileUuid)) {
+                preset.fixtureCapabilityValues.splice(i, 1);
+                return;
+            }
+        }
+    }
+    setCapabilityValue(preset, capabilityType, valuePercentage, slotNumber, color, wheel, profileUuid) {
+        // Delete existant properties with this type and set the new value
+        this.deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid);
+        const fixtureCapabilityValue = new FixtureCapabilityValue();
+        fixtureCapabilityValue.type = capabilityType;
+        fixtureCapabilityValue.color = color;
+        fixtureCapabilityValue.wheel = wheel;
+        fixtureCapabilityValue.valuePercentage = valuePercentage;
+        fixtureCapabilityValue.slotNumber = slotNumber;
+        fixtureCapabilityValue.profileUuid = profileUuid;
+        preset.fixtureCapabilityValues.push(fixtureCapabilityValue);
+    }
+    getCapabilityValue(preset, capabilityType, color, wheel, profileUuid) {
+        for (const capabilityValue of preset.fixtureCapabilityValues) {
+            if (this.fixtureService.capabilitiesMatch(capabilityValue.type, capabilityType, capabilityValue.color, color, capabilityValue.wheel, wheel, capabilityValue.profileUuid, profileUuid)) {
+                return capabilityValue;
+            }
+        }
+        return undefined;
+    }
+    deleteChannelValue(channelName, profileUuid) {
+        for (let i = 0; i < this.selectedPreset.fixtureChannelValues.length; i++) {
+            if (this.selectedPreset.fixtureChannelValues[i].channelName === channelName &&
+                this.selectedPreset.fixtureChannelValues[i].profileUuid === profileUuid) {
+                this.selectedPreset.fixtureChannelValues.splice(i, 1);
+                return;
+            }
+        }
+    }
+    setChannelValue(channelName, profileUuid, value) {
+        // Delete existant properties with this type and set the new value
+        this.deleteChannelValue(channelName, profileUuid);
+        const fixtureChannelValue = new FixtureChannelValue();
+        fixtureChannelValue.channelName = channelName;
+        fixtureChannelValue.profileUuid = profileUuid;
+        fixtureChannelValue.value = value;
+        this.selectedPreset.fixtureChannelValues.push(fixtureChannelValue);
+    }
+    getChannelValue(channelName, profileUuid) {
+        for (const channelValue of this.selectedPreset.fixtureChannelValues) {
+            if (channelValue.channelName === channelName && channelValue.profileUuid === profileUuid) {
+                return channelValue.value;
+            }
+        }
+    }
+    getApproximatedColorWheelCapability(preset, cachedChannel) {
+        // return an approximated wheel slot channel capability, if a color or a slot on a different
+        // wheel has been selected
+        let colorRed;
+        let colorGreen;
+        let colorBlue;
+        let lowestDiff = Number.MAX_VALUE;
+        let lowestDiffCapability;
+        let capabilityValue;
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);
+        if (capabilityValue) {
+            colorRed = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);
+        if (capabilityValue) {
+            colorGreen = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);
+        if (capabilityValue) {
+            colorBlue = 255 * capabilityValue.valuePercentage;
+        }
+        if (!colorRed && !colorGreen && !colorBlue) {
+            // no color found -> search the first color wheel
+            // TODO
+        }
+        if (colorRed !== undefined && colorGreen !== undefined && colorBlue !== undefined) {
+            for (const capability of cachedChannel.capabilities) {
+                if (capability.capability.slotNumber) {
+                    const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);
+                    if (mixedColor) {
+                        const diff = Math.abs(mixedColor.red - colorRed) + Math.abs(mixedColor.green - colorGreen) + Math.abs(mixedColor.blue - colorBlue);
+                        if (diff < lowestDiff) {
+                            lowestDiff = diff;
+                            lowestDiffCapability = capability;
+                        }
+                    }
+                }
+            }
+        }
+        return lowestDiffCapability;
+    }
+    hasCapabilityType(type) {
+        // there is at least one channel with at least one intensity capability
+        for (const projectFixture of this.selectedPreset.fixtures) {
+            const fixture = this.fixtureService.getCachedFixtureByUuid(projectFixture.fixtureUuid, projectFixture.pixelKey);
+            for (const channel of fixture.channels) {
+                if (channel.channel) {
+                    for (const capability of channel.capabilities) {
+                        if (capability.capability.type === type) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    hasCapabilityDimmer() {
+        return this.hasCapabilityType(FixtureCapabilityType.Intensity);
+    }
+    hasCapabilityColor() {
+        // TODO optionally color temperature and color white (see stairville/mh-100)
+        // one of the profiles has a color intensity
+        if (this.hasCapabilityType(FixtureCapabilityType.ColorIntensity)) {
+            return true;
+        }
+        return false;
+    }
+    hasCapabilityColorOrColorWheel() {
+        // TODO optionally color temperature and color white (see stairville/mh-100)
+        // one of the profiles has a color intensity
+        if (this.hasCapabilityColor()) {
+            return true;
+        }
+        // a color wheel is involved
+        for (const projectFixture of this.selectedPreset.fixtures) {
+            const fixture = this.fixtureService.getCachedFixtureByUuid(projectFixture.fixtureUuid, projectFixture.pixelKey);
+            for (const channel of fixture.channels) {
+                if (channel.colorWheel) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    hasCapabilityPanTilt() {
+        let hasPan = false;
+        let hasTilt = false;
+        // there is at least one pan and one tilt channel
+        if (this.hasCapabilityType(FixtureCapabilityType.Pan)) {
+            hasPan = true;
+        }
+        if (this.hasCapabilityType(FixtureCapabilityType.Tilt)) {
+            hasTilt = true;
+        }
+        if (hasPan && hasTilt) {
+            return true;
+        }
+        return false;
+    }
+    selectPreset(index) {
+        this.effectService.selectedEffect = undefined;
+        this.selectedPreset = this.projectService.project.presets[index];
+        this.projectService.project.selectedPresetUuid = this.projectService.project.presets[index].uuid;
+        this.autoOpenFirstEffect();
+        this.previewSelectionChanged.next();
+        this.previewLive();
+    }
+    autoOpenFirstEffect() {
+        // open the first effect, if the preset only has one
+        if (this.selectedPreset && this.selectedPreset.effects.length === 1) {
+            this.effectService.selectedEffect = this.selectedPreset.effects[0];
+        }
+    }
+    addPreset(name) {
+        const preset = new Preset();
+        preset.uuid = this.uuidService.getUuid();
+        preset.name = name || 'New Preset';
+        // Insert the new preset before the highest currently selected preset
+        let highestSelectedPresetIndex = 0;
+        for (let i = 0; i < this.projectService.project.presets.length; i++) {
+            if (this.selectedPreset === this.projectService.project.presets[i]) {
+                highestSelectedPresetIndex = i;
+                break;
+            }
+        }
+        this.projectService.project.presets.splice(highestSelectedPresetIndex, 0, preset);
+        this.selectPreset(highestSelectedPresetIndex);
+    }
+    // return all fixture profiles used in the current preset selection
+    getSelectedProfiles() {
+        const profiles = [];
+        if (!this.selectedPreset) {
+            return profiles;
+        }
+        for (const presetFixture of this.selectedPreset.fixtures) {
+            const fixture = this.fixtureService.getFixtureByUuid(presetFixture.fixtureUuid);
+            const profile = this.fixtureService.getProfileByUuid(fixture.profileUuid);
+            if (profiles.indexOf(profile) < 0) {
+                profiles.push(profile);
+            }
+        }
+        return profiles;
+    }
+    // given a list of fixture profiles, return all available channels based on the currently selected fixtures in the preset
+    getSelectedProfileChannels(selectedProfiles) {
+        const calculatedProfileModes = new Map();
+        const availableChannels = new Map();
+        // calculate all modes for each profile
+        for (const profile of selectedProfiles) {
+            const modeAndPixelKeys = [];
+            // loop over the project fixtures to keep the order
+            for (let projectFixture of this.projectService.project.presetFixtures) {
+                for (const presetFixture of this.selectedPreset.fixtures) {
+                    if (projectFixture.fixtureUuid === presetFixture.fixtureUuid &&
+                        ((!projectFixture.pixelKey && !presetFixture.pixelKey) || projectFixture.pixelKey === presetFixture.pixelKey)) {
+                        const fixture = this.fixtureService.getCachedFixtureByUuid(presetFixture.fixtureUuid, presetFixture.pixelKey);
+                        if (fixture.profile.uuid === profile.uuid) {
+                            const exists = modeAndPixelKeys.some((item) => (item.mode === fixture.mode && !item.pixelKey && !fixture.pixelKey) || item.pixelKey === fixture.pixelKey);
+                            if (!exists) {
+                                modeAndPixelKeys.push({
+                                    mode: fixture.mode,
+                                    pixelKey: presetFixture.pixelKey,
+                                });
+                            }
+                        }
+                    }
+                }
+                calculatedProfileModes.set(profile, modeAndPixelKeys);
+            }
+        }
+        // calculate all channels from the modes
+        calculatedProfileModes.forEach((modeAndPixelKeys, profile) => {
+            const profileChannels = [];
+            for (const modeAndPixelKey of modeAndPixelKeys) {
+                const channels = this.fixtureService.getCachedChannels(profile, modeAndPixelKey.mode, modeAndPixelKey.pixelKey);
+                for (const channel of channels) {
+                    // only add the channel, if no channel with the same name has already been added
+                    // (e.g. a fine channel)
+                    if (channel.channel && !profileChannels.find((c) => c.name === channel.name)) {
+                        profileChannels.push(channel);
+                    }
+                }
+            }
+            availableChannels.set(profile, profileChannels);
+        });
+        return availableChannels;
+    }
+    previewLive(compositionName = '', positionMillis) {
+        if (!this.configService.livePreview) {
+            return;
+        }
+        // collect all changes and delay them to not flood the backend
+        // (except play events. they need to be delivered always)
+        if (this.livePreviewTimer && !compositionName) {
+            this.liveChangePending = true;
+            return;
+        }
+        let position = positionMillis;
+        if (position === undefined) {
+            position = Math.round(this.animationService.timeMillis);
+        }
+        this.http
+            .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))
+            .subscribe();
+        this.liveChangePending = false;
+        if (!compositionName) {
+            this.livePreviewTimer = setTimeout(() => {
+                this.livePreviewTimer = undefined;
+                if (this.liveChangePending) {
+                    this.http
+                        .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))
+                        .subscribe();
+                }
+            }, 50);
+        }
+    }
+    stopPreviewPlay() {
+        if (!this.configService.livePreview) {
+            return;
+        }
+        this.http.post('stop-preview-play', null).subscribe();
+    }
+    static { this.ɵfac = function PresetService_Factory(t) { return new (t || PresetService)(i0.ɵɵinject(i1.EffectService), i0.ɵɵinject(i2.UuidService), i0.ɵɵinject(i3.ProjectService), i0.ɵɵinject(i4.FixtureService), i0.ɵɵinject(i5.ConfigService), i0.ɵɵinject(i6.HttpClient), i0.ɵɵinject(i7.AnimationService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PresetService, factory: PresetService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PresetService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.EffectService }, { type: i2.UuidService }, { type: i3.ProjectService }, { type: i4.FixtureService }, { type: i5.ConfigService }, { type: i6.HttpClient }, { type: i7.AnimationService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/preset.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { CachedFixtureCapability } from '../models/cached-fixture-capability';\nimport { CachedFixtureChannel } from '../models/cached-fixture-channel';\nimport { Fixture } from '../models/fixture';\nimport { FixtureCapabilityColor, FixtureCapabilityType } from '../models/fixture-capability';\nimport { FixtureCapabilityValue } from '../models/fixture-capability-value';\nimport { FixtureChannelValue } from '../models/fixture-channel-value';\nimport { FixtureMode } from '../models/fixture-mode';\nimport { FixtureProfile } from '../models/fixture-profile';\nimport { Preset } from '../models/preset';\nimport { AnimationService } from './animation.service';\nimport { ConfigService } from './config.service';\nimport { EffectService } from './effect.service';\nimport { FixtureService } from './fixture.service';\nimport { ProjectService } from './project.service';\nimport { UuidService } from './uuid.service';\nimport { PresetFixture } from '../models/preset-fixture';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PresetService {\n  selectedPreset: Preset;\n\n  // fires, when the current preview element has changed (scene/preset)\n  previewSelectionChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the fixture selection has changed\n  fixtureSelectionChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the fixture selection has changed for settings\n  fixtureSelectionSettingsChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the selected color has changed. This is required,\n  // because detectChanges is not enough to trigger different components.\n  fixtureColorChanged: Subject<void> = new Subject<void>();\n\n  livePreviewTimer: any;\n  liveChangePending = false;\n\n  constructor(\n    private effectService: EffectService,\n    private uuidService: UuidService,\n    private projectService: ProjectService,\n    private fixtureService: FixtureService,\n    private configService: ConfigService,\n    private http: HttpClient,\n    private animationService: AnimationService\n  ) {}\n\n  getPresetByUuid(uuid: string): Preset {\n    for (const preset of this.projectService.project.presets) {\n      if (preset.uuid === uuid) {\n        return preset;\n      }\n    }\n  }\n\n  getPresetFixture(preset: Preset, fixtureUuid: string, pixelKey?: string): PresetFixture {\n    for (const fixture of preset.fixtures) {\n      if (fixture.fixtureUuid === fixtureUuid && ((!fixture.pixelKey && !pixelKey) || fixture.pixelKey === pixelKey)) {\n        return fixture;\n      }\n    }\n\n    return null;\n  }\n\n  fixtureIsSelected(fixture: Fixture, pixelKey: string, preset?: Preset): boolean {\n    // is the passed fixture selected in the passed/currently selected preset?\n    if (!preset) {\n      if (this.selectedPreset) {\n        preset = this.selectedPreset;\n      } else {\n        return false;\n      }\n    }\n\n    const presetFixture = this.getPresetFixture(preset, fixture.uuid, pixelKey);\n\n    if (presetFixture) {\n      return true;\n    }\n\n    return false;\n  }\n\n  switchFixtureSelection(fixture: Fixture, pixelKey: string) {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    // select all fixtures at the specified start channel or unselect them,\n    // if already selected\n    if (this.fixtureIsSelected(fixture, pixelKey)) {\n      for (let i = this.selectedPreset.fixtures.length - 1; i >= 0; i--) {\n        const projectFixture = this.fixtureService.getFixtureByUuid(this.selectedPreset.fixtures[i].fixtureUuid);\n        if (\n          projectFixture.dmxFirstChannel === fixture.dmxFirstChannel &&\n          ((!this.selectedPreset.fixtures[i].pixelKey && !pixelKey) || this.selectedPreset.fixtures[i].pixelKey === pixelKey)\n        ) {\n          this.selectedPreset.fixtures.splice(i, 1);\n        }\n      }\n    } else {\n      for (const projectPresetFixture of this.projectService.project.presetFixtures) {\n        if ((!projectPresetFixture.pixelKey && !pixelKey) || projectPresetFixture.pixelKey === pixelKey) {\n          const projectFixture = this.fixtureService.getFixtureByUuid(projectPresetFixture.fixtureUuid);\n          if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {\n            const presetFixture = new PresetFixture();\n            presetFixture.fixtureUuid = projectPresetFixture.fixtureUuid;\n            presetFixture.pixelKey = pixelKey;\n            this.selectedPreset.fixtures.push(presetFixture);\n          }\n        }\n      }\n    }\n  }\n\n  selectAllFixtures() {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    for (const fixture of this.projectService.project.fixtures) {\n      const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);\n      if (pixelKeys.length > 0) {\n        for (const pixelKey of pixelKeys) {\n          if (!this.fixtureIsSelected(fixture, pixelKey)) {\n            const presetFixture = new PresetFixture();\n            presetFixture.fixtureUuid = fixture.uuid;\n            presetFixture.pixelKey = pixelKey;\n            this.selectedPreset.fixtures.push(presetFixture);\n          }\n        }\n      } else {\n        if (!this.fixtureIsSelected(fixture, null)) {\n          const presetFixture = new PresetFixture();\n          presetFixture.fixtureUuid = fixture.uuid;\n          this.selectedPreset.fixtures.push(presetFixture);\n        }\n      }\n    }\n  }\n\n  selectNoFixtures() {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    this.selectedPreset.fixtures = [];\n  }\n\n  public removeDeletedFixtures() {\n    // after changing the configuration in the fixture pool, we might need to\n    // delete some fixtures\n    for (const preset of this.projectService.project.presets) {\n      for (let i = preset.fixtures.length - 1; i >= 0; i--) {\n        const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtures[i].fixtureUuid);\n        if (!presetFixture) {\n          preset.fixtures.splice(i, 1);\n        }\n      }\n    }\n  }\n\n  public updateFixtureSelection() {\n    // after changing the configuration in the fixture pool, we might need to\n    // select some more fixtures on the same channel as already selected ones\n    for (const preset of this.projectService.project.presets) {\n      for (let presetFixture of preset.fixtures) {\n        const fixture = this.fixtureService.getFixtureByUuid(presetFixture.fixtureUuid);\n        for (const projectFixture of this.projectService.project.fixtures) {\n          if (\n            projectFixture.dmxFirstChannel === fixture.dmxFirstChannel &&\n            !this.fixtureIsSelected(projectFixture, presetFixture.pixelKey, preset)\n          ) {\n            const newPresetFixture = new PresetFixture();\n            newPresetFixture.fixtureUuid = projectFixture.uuid;\n            newPresetFixture.pixelKey = presetFixture.pixelKey;\n            preset.fixtures.push(newPresetFixture);\n          }\n        }\n      }\n    }\n  }\n\n  deleteCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ) {\n    for (let i = 0; i < preset.fixtureCapabilityValues.length; i++) {\n      if (\n        this.fixtureService.capabilitiesMatch(\n          preset.fixtureCapabilityValues[i].type,\n          capabilityType,\n          preset.fixtureCapabilityValues[i].color,\n          color,\n          preset.fixtureCapabilityValues[i].wheel,\n          wheel,\n          preset.fixtureCapabilityValues[i].profileUuid,\n          profileUuid\n        )\n      ) {\n        preset.fixtureCapabilityValues.splice(i, 1);\n        return;\n      }\n    }\n  }\n\n  setCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    valuePercentage: number,\n    slotNumber?: number,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ) {\n    // Delete existant properties with this type and set the new value\n    this.deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid);\n\n    const fixtureCapabilityValue = new FixtureCapabilityValue();\n    fixtureCapabilityValue.type = capabilityType;\n    fixtureCapabilityValue.color = color;\n    fixtureCapabilityValue.wheel = wheel;\n    fixtureCapabilityValue.valuePercentage = valuePercentage;\n    fixtureCapabilityValue.slotNumber = slotNumber;\n    fixtureCapabilityValue.profileUuid = profileUuid;\n\n    preset.fixtureCapabilityValues.push(fixtureCapabilityValue);\n  }\n\n  getCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ): FixtureCapabilityValue {\n    for (const capabilityValue of preset.fixtureCapabilityValues) {\n      if (\n        this.fixtureService.capabilitiesMatch(\n          capabilityValue.type,\n          capabilityType,\n          capabilityValue.color,\n          color,\n          capabilityValue.wheel,\n          wheel,\n          capabilityValue.profileUuid,\n          profileUuid\n        )\n      ) {\n        return capabilityValue;\n      }\n    }\n    return undefined;\n  }\n\n  deleteChannelValue(channelName: string, profileUuid: string) {\n    for (let i = 0; i < this.selectedPreset.fixtureChannelValues.length; i++) {\n      if (\n        this.selectedPreset.fixtureChannelValues[i].channelName === channelName &&\n        this.selectedPreset.fixtureChannelValues[i].profileUuid === profileUuid\n      ) {\n        this.selectedPreset.fixtureChannelValues.splice(i, 1);\n        return;\n      }\n    }\n  }\n\n  setChannelValue(channelName: string, profileUuid: string, value: number) {\n    // Delete existant properties with this type and set the new value\n    this.deleteChannelValue(channelName, profileUuid);\n\n    const fixtureChannelValue = new FixtureChannelValue();\n    fixtureChannelValue.channelName = channelName;\n    fixtureChannelValue.profileUuid = profileUuid;\n    fixtureChannelValue.value = value;\n\n    this.selectedPreset.fixtureChannelValues.push(fixtureChannelValue);\n  }\n\n  getChannelValue(channelName: string, profileUuid: string): number {\n    for (const channelValue of this.selectedPreset.fixtureChannelValues) {\n      if (channelValue.channelName === channelName && channelValue.profileUuid === profileUuid) {\n        return channelValue.value;\n      }\n    }\n  }\n\n  getApproximatedColorWheelCapability(preset: Preset, cachedChannel: CachedFixtureChannel): CachedFixtureCapability {\n    // return an approximated wheel slot channel capability, if a color or a slot on a different\n    // wheel has been selected\n    let colorRed: number;\n    let colorGreen: number;\n    let colorBlue: number;\n    let lowestDiff = Number.MAX_VALUE;\n    let lowestDiffCapability: CachedFixtureCapability;\n    let capabilityValue: FixtureCapabilityValue;\n\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);\n    if (capabilityValue) {\n      colorRed = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);\n    if (capabilityValue) {\n      colorGreen = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);\n    if (capabilityValue) {\n      colorBlue = 255 * capabilityValue.valuePercentage;\n    }\n\n    if (!colorRed && !colorGreen && !colorBlue) {\n      // no color found -> search the first color wheel\n      // TODO\n    }\n\n    if (colorRed !== undefined && colorGreen !== undefined && colorBlue !== undefined) {\n      for (const capability of cachedChannel.capabilities) {\n        if (capability.capability.slotNumber) {\n          const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);\n          if (mixedColor) {\n            const diff =\n              Math.abs(mixedColor.red - colorRed) + Math.abs(mixedColor.green - colorGreen) + Math.abs(mixedColor.blue - colorBlue);\n\n            if (diff < lowestDiff) {\n              lowestDiff = diff;\n              lowestDiffCapability = capability;\n            }\n          }\n        }\n      }\n    }\n\n    return lowestDiffCapability;\n  }\n\n  private hasCapabilityType(type: FixtureCapabilityType): boolean {\n    // there is at least one channel with at least one intensity capability\n    for (const projectFixture of this.selectedPreset.fixtures) {\n      const fixture = this.fixtureService.getCachedFixtureByUuid(projectFixture.fixtureUuid, projectFixture.pixelKey);\n      for (const channel of fixture.channels) {\n        if (channel.channel) {\n          for (const capability of channel.capabilities) {\n            if (capability.capability.type === type) {\n              return true;\n            }\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  hasCapabilityDimmer(): boolean {\n    return this.hasCapabilityType(FixtureCapabilityType.Intensity);\n  }\n\n  hasCapabilityColor(): boolean {\n    // TODO optionally color temperature and color white (see stairville/mh-100)\n\n    // one of the profiles has a color intensity\n    if (this.hasCapabilityType(FixtureCapabilityType.ColorIntensity)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  hasCapabilityColorOrColorWheel(): boolean {\n    // TODO optionally color temperature and color white (see stairville/mh-100)\n\n    // one of the profiles has a color intensity\n    if (this.hasCapabilityColor()) {\n      return true;\n    }\n\n    // a color wheel is involved\n    for (const projectFixture of this.selectedPreset.fixtures) {\n      const fixture = this.fixtureService.getCachedFixtureByUuid(projectFixture.fixtureUuid, projectFixture.pixelKey);\n      for (const channel of fixture.channels) {\n        if (channel.colorWheel) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  hasCapabilityPanTilt(): boolean {\n    let hasPan = false;\n    let hasTilt = false;\n\n    // there is at least one pan and one tilt channel\n    if (this.hasCapabilityType(FixtureCapabilityType.Pan)) {\n      hasPan = true;\n    }\n\n    if (this.hasCapabilityType(FixtureCapabilityType.Tilt)) {\n      hasTilt = true;\n    }\n\n    if (hasPan && hasTilt) {\n      return true;\n    }\n\n    return false;\n  }\n\n  selectPreset(index: number) {\n    this.effectService.selectedEffect = undefined;\n    this.selectedPreset = this.projectService.project.presets[index];\n    this.projectService.project.selectedPresetUuid = this.projectService.project.presets[index].uuid;\n    this.autoOpenFirstEffect();\n    this.previewSelectionChanged.next();\n    this.previewLive();\n  }\n\n  autoOpenFirstEffect() {\n    // open the first effect, if the preset only has one\n    if (this.selectedPreset && this.selectedPreset.effects.length === 1) {\n      this.effectService.selectedEffect = this.selectedPreset.effects[0];\n    }\n  }\n\n  addPreset(name?: string): void {\n    const preset: Preset = new Preset();\n    preset.uuid = this.uuidService.getUuid();\n    preset.name = name || 'New Preset';\n\n    // Insert the new preset before the highest currently selected preset\n    let highestSelectedPresetIndex = 0;\n\n    for (let i = 0; i < this.projectService.project.presets.length; i++) {\n      if (this.selectedPreset === this.projectService.project.presets[i]) {\n        highestSelectedPresetIndex = i;\n        break;\n      }\n    }\n\n    this.projectService.project.presets.splice(highestSelectedPresetIndex, 0, preset);\n    this.selectPreset(highestSelectedPresetIndex);\n  }\n\n  // return all fixture profiles used in the current preset selection\n  getSelectedProfiles() {\n    const profiles: FixtureProfile[] = [];\n\n    if (!this.selectedPreset) {\n      return profiles;\n    }\n\n    for (const presetFixture of this.selectedPreset.fixtures) {\n      const fixture = this.fixtureService.getFixtureByUuid(presetFixture.fixtureUuid);\n      const profile = this.fixtureService.getProfileByUuid(fixture.profileUuid);\n\n      if (profiles.indexOf(profile) < 0) {\n        profiles.push(profile);\n      }\n    }\n\n    return profiles;\n  }\n\n  // given a list of fixture profiles, return all available channels based on the currently selected fixtures in the preset\n  getSelectedProfileChannels(selectedProfiles: FixtureProfile[]) {\n    const calculatedProfileModes = new Map<FixtureProfile, any[]>();\n    const availableChannels: Map<FixtureProfile, CachedFixtureChannel[]> = new Map<FixtureProfile, CachedFixtureChannel[]>();\n\n    // calculate all modes for each profile\n    for (const profile of selectedProfiles) {\n      const modeAndPixelKeys: any[] = [];\n\n      // loop over the project fixtures to keep the order\n      for (let projectFixture of this.projectService.project.presetFixtures) {\n        for (const presetFixture of this.selectedPreset.fixtures) {\n          if (\n            projectFixture.fixtureUuid === presetFixture.fixtureUuid &&\n            ((!projectFixture.pixelKey && !presetFixture.pixelKey) || projectFixture.pixelKey === presetFixture.pixelKey)\n          ) {\n            const fixture = this.fixtureService.getCachedFixtureByUuid(presetFixture.fixtureUuid, presetFixture.pixelKey);\n            if (fixture.profile.uuid === profile.uuid) {\n              const exists = modeAndPixelKeys.some(\n                (item) => (item.mode === fixture.mode && !item.pixelKey && !fixture.pixelKey) || item.pixelKey === fixture.pixelKey\n              );\n              if (!exists) {\n                modeAndPixelKeys.push({\n                  mode: fixture.mode,\n                  pixelKey: presetFixture.pixelKey,\n                });\n              }\n            }\n          }\n        }\n\n        calculatedProfileModes.set(profile, modeAndPixelKeys);\n      }\n    }\n\n    // calculate all channels from the modes\n    calculatedProfileModes.forEach((modeAndPixelKeys: any[], profile: FixtureProfile) => {\n      const profileChannels: CachedFixtureChannel[] = [];\n      for (const modeAndPixelKey of modeAndPixelKeys) {\n        const channels = this.fixtureService.getCachedChannels(profile, modeAndPixelKey.mode, modeAndPixelKey.pixelKey);\n        for (const channel of channels) {\n          // only add the channel, if no channel with the same name has already been added\n          // (e.g. a fine channel)\n          if (channel.channel && !profileChannels.find((c) => c.name === channel.name)) {\n            profileChannels.push(channel);\n          }\n        }\n      }\n      availableChannels.set(profile, profileChannels);\n    });\n\n    return availableChannels;\n  }\n\n  previewLive(compositionName: string = '', positionMillis?: number) {\n    if (!this.configService.livePreview) {\n      return;\n    }\n\n    // collect all changes and delay them to not flood the backend\n    // (except play events. they need to be delivered always)\n    if (this.livePreviewTimer && !compositionName) {\n      this.liveChangePending = true;\n      return;\n    }\n\n    let position = positionMillis;\n\n    if (position === undefined) {\n      position = Math.round(this.animationService.timeMillis);\n    }\n\n    this.http\n      .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))\n      .subscribe();\n\n    this.liveChangePending = false;\n\n    if (!compositionName) {\n      this.livePreviewTimer = setTimeout(() => {\n        this.livePreviewTimer = undefined;\n        if (this.liveChangePending) {\n          this.http\n            .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))\n            .subscribe();\n        }\n      }, 50);\n    }\n  }\n\n  stopPreviewPlay() {\n    if (!this.configService.livePreview) {\n      return;\n    }\n\n    this.http.post('stop-preview-play', null).subscribe();\n  }\n}\n"]}

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

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core';
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import * as i0 from "@angular/core";
+export class PreviewMeshService {
+    constructor() {
+        this.loader = new GLTFLoader();
+        this.cachedMeshes = new Map();
+        // the observable, if the requested mesh is already being loaded currently
+        this.cachedObservables = new Map();
+    }
+    loadScene(name) {
+        return new Observable((observer) => {
+            this.loader.load('./assets/designer/models/' + name + '.gltf', 
+            // Called when the resource is loaded
+            (gltf) => {
+                const model = gltf.scene.children[0];
+                model.position.set(0, 0, 0);
+                observer.next(gltf.scene);
+                observer.complete();
+            }, 
+            // Called while loading is progressing
+            (xhr) => { }, 
+            // Called when loading has errors
+            (error) => {
+                observer.error(error);
+            });
+        });
+    }
+    loadMesh(name) {
+        const observable = this.loadScene(name).pipe(map((scene) => {
+            const model = scene.children[0];
+            model.position.set(0, 0, 0);
+            this.cachedMeshes.set(name, model);
+            this.cachedObservables.delete(name);
+            return model.clone();
+        }));
+        this.cachedObservables.set(name, observable);
+        return observable;
+    }
+    getMesh(name) {
+        if (this.cachedMeshes.get(name)) {
+            return of(this.cachedMeshes.get(name).clone());
+        }
+        return this.cachedObservables.get(name) || this.loadMesh(name);
+    }
+    static { this.ɵfac = function PreviewMeshService_Factory(t) { return new (t || PreviewMeshService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PreviewMeshService, factory: PreviewMeshService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreviewMeshService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,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