@combeenation/3d-viewer 12.4.3 → 12.4.4

package/dist/lib-cjs/api/classes/viewerLight.js

@@ -1,345 +1,345 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerLight = void 0;
-const babylonHelper_1 = require("./../util/babylonHelper");
-const dottedPath_1 = require("./dottedPath");
-const parameter_1 = require("./parameter");
-const variantParameterizable_1 = require("./variantParameterizable");
-const shadowGenerator_1 = require("@babylonjs/core/Lights/Shadows/shadowGenerator");
-require("@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent");
-const hemisphericLight_1 = require("@babylonjs/core/Lights/hemisphericLight");
-const pointLight_1 = require("@babylonjs/core/Lights/pointLight");
-const shadowLight_1 = require("@babylonjs/core/Lights/shadowLight");
-const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
-const transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
-require("@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual");
-const lodash_es_1 = require("lodash-es");
-/**
- * A {@link ViewerLight} of a {@link Variant}. Acts as a container for Babylon.js lights. Lives only in the context of a
- * {@link Variant}.
- */
-class ViewerLight extends variantParameterizable_1.VariantParameterizable {
-    /**
-     * Constructor.
-     */
-    constructor(variant, name) {
-        super(variant, name);
-        this.variant = variant;
-        this.name = name;
-        this.addParameterObservers();
-    }
-    /**
-     * Creates a {@link ViewerLight} with given name.
-     */
-    static create(variant, name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const viewerLight = new ViewerLight(variant, name);
-            viewerLight._light = yield viewerLight.createBabylonLightFromDefinition(viewerLight.definition);
-            return viewerLight;
-        });
-    }
-    /**
-     * The wrapped Light.
-     */
-    get light() {
-        if (!this._light) {
-            throw new Error(`Light for ViewerLight "${this.name}" has not been properly initialized.`);
-        }
-        return this._light;
-    }
-    /**
-     * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
-     * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
-     */
-    get dottedPath() {
-        return dottedPath_1.DottedPath.create(this.variant.dottedPath).addPart(this.name);
-    }
-    /**
-     * The id representing a {@link DottedPath}.
-     */
-    get id() {
-        const dottedPath = dottedPath_1.DottedPath.create(this.dottedPath);
-        dottedPath.shiftPart(); // remove root
-        return dottedPath.path;
-    }
-    /**
-     * The {@link LightDefinition} of the {@link ViewerLight}.
-     */
-    get definition() {
-        const definition = this.variant.structureJson.lights[this.name];
-        if ((0, lodash_es_1.isString)(definition)) {
-            return {
-                type: 'baked',
-                path: definition,
-            };
-        }
-        return definition;
-    }
-    /**
-     * The type of the {@link ViewerLight}'s light.
-     */
-    get type() {
-        return this.light.constructor.name.replace(/light/i, '').toLowerCase();
-    }
-    /**
-     * @see {@link VariantParameterizable.commitParameters}
-     * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
-     */
-    commitParameters(parameters) {
-        const _super = Object.create(null, {
-            commitParameters: { get: () => super.commitParameters }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            return _super.commitParameters.call(this, parameters);
-        });
-    }
-    /**
-     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
-     */
-    addParameterObservers() {
-        this._parameterObservers.set(parameter_1.Parameter.VISIBLE, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                let visible;
-                try {
-                    visible = parameter_1.Parameter.parseBoolean(newValue);
-                }
-                catch (e) {
-                    return;
-                }
-                if (visible === true) {
-                    (0, babylonHelper_1.enableNodeWithParents)(light.light);
-                }
-                else if (visible === false) {
-                    (0, babylonHelper_1.disableNodeWithParents)(light.light);
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.INTENSITY, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                (0, lodash_es_1.set)(light.light, 'intensity', parameter_1.Parameter.parseNumber(newValue));
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.SCALING, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                // we have to deal just with root nodes here due to relative impacts in a node tree
-                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
-                if (rootNode instanceof transformNode_1.TransformNode) {
-                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
-                        scaling: parameter_1.Parameter.parseScaling(newValue),
-                        position: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.POSITION] || '(0, 0, 0)'),
-                        rotation: parameter_1.Parameter.parseRotation(light.inheritedParameters[parameter_1.Parameter.ROTATION] || '(0, 0, 0)'),
-                    });
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.POSITION, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                // we have to deal just with root nodes here due to relative impacts in a node tree
-                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
-                if (rootNode instanceof transformNode_1.TransformNode) {
-                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
-                        scaling: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.SCALING] || '(1, 1, 1)'),
-                        position: parameter_1.Parameter.parseVector(newValue),
-                        rotation: parameter_1.Parameter.parseRotation(light.inheritedParameters[parameter_1.Parameter.ROTATION] || '(0, 0, 0)'),
-                    });
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.ROTATION, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                // we have to deal just with root nodes here due to relative impacts in a node tree
-                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
-                if (rootNode instanceof transformNode_1.TransformNode) {
-                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
-                        scaling: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.SCALING] || '(1, 1, 1)'),
-                        position: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.POSITION] || '(0, 0, 0)'),
-                        rotation: parameter_1.Parameter.parseRotation(newValue),
-                    });
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.DIRECTION, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                if ((light.light instanceof shadowLight_1.ShadowLight && !(light.light instanceof pointLight_1.PointLight)) ||
-                    light.light instanceof hemisphericLight_1.HemisphericLight) {
-                    (0, lodash_es_1.set)(light.light, 'direction', parameter_1.Parameter.parseVector(newValue));
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.ANGLE, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                if (light.light.getClassName() === 'SpotLight') {
-                    (0, lodash_es_1.set)(light.light, 'angle', parameter_1.Parameter.parseNumber(newValue));
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.EXPONENT, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                if (light.light.getClassName() === 'SpotLight') {
-                    (0, lodash_es_1.set)(light.light, 'exponent', parameter_1.Parameter.parseNumber(newValue));
-                }
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.DIFFUSE, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                (0, lodash_es_1.set)(light.light, 'diffuse', parameter_1.Parameter.parseColor(newValue));
-            }),
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.SPECULAR, [
-            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-                (0, lodash_es_1.set)(light.light, 'specular', parameter_1.Parameter.parseColor(newValue));
-            }),
-        ]);
-        return this;
-    }
-    /**
-     * @param definition
-     * @protected
-     */
-    createBabylonLightFromDefinition(definition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parameters = parameter_1.Parameter.parseFromDeclarations(parameter_1.Parameter.declarations, this.inheritedParameters);
-            const scene = this.variant.viewer.scene;
-            let lightId = this.id;
-            let babylonLight;
-            switch (definition.type) {
-                case 'baked': {
-                    if (!definition['path']) {
-                        throw new Error(`The light "${lightId}" of type "${definition.type}" needs a "path".`);
-                    }
-                    const bakedLight = this.variant.inheritedLights.find(l => l.metadata.dottedPath.path === definition['path']);
-                    if (bakedLight) {
-                        lightId = bakedLight.metadata.dottedPath.clone().unshiftPart(this.id).path;
-                        babylonLight = (0, babylonHelper_1.cloneNodeWithParents)(bakedLight);
-                        babylonLight.name = lightId;
-                        babylonLight.id = lightId;
-                    }
-                    else {
-                        throw new Error(`No light found for path "${definition['path']}" in ViewerLight "${lightId}".`);
-                    }
-                    break;
-                }
-                case 'hemispheric': {
-                    if (!parameters['direction']) {
-                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
-                    }
-                    const hemisphericLightModule = yield Promise.resolve().then(() => __importStar(require(
-                    /* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight')));
-                    babylonLight = new hemisphericLightModule.HemisphericLight(lightId, parameters['direction'], scene);
-                    break;
-                }
-                case 'point': {
-                    const pointLightModule = yield Promise.resolve().then(() => __importStar(require(
-                    /* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight')));
-                    babylonLight = new pointLightModule.PointLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
-                    scene);
-                    break;
-                }
-                case 'directional': {
-                    if (!parameters['direction']) {
-                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
-                    }
-                    const directionalLightModule = yield Promise.resolve().then(() => __importStar(require(
-                    /* webpackChunkName: "directional-light" */ '@babylonjs/core/Lights/directionalLight')));
-                    babylonLight = new directionalLightModule.DirectionalLight(lightId, parameters['direction'], scene);
-                    break;
-                }
-                case 'spot': {
-                    if (!parameters['direction']) {
-                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
-                    }
-                    if (!parameters['angle']) {
-                        throw new Error(`A ViewerLight of type "${definition.type}" needs an "angle".`);
-                    }
-                    if (!parameters['exponent']) {
-                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs an "exponent".`);
-                    }
-                    const spotLightModule = yield Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "spot-light" */ '@babylonjs/core/Lights/spotLight')));
-                    babylonLight = new spotLightModule.SpotLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
-                    parameters['direction'], parameters['angle'], parameters['exponent'], scene);
-                    break;
-                }
-                default:
-                    throw new Error(`The type "${definition.type}" for ViewerLight "${lightId}" is not implemented (yet).`);
-            }
-            if (!babylonLight) {
-                throw new Error(`The Light for ViewerLight "${lightId}" of type "${definition.type}" could no be created ` + `or found.`);
-            }
-            if (!babylonLight.parent) {
-                // Create pseudo parent since lights do not implement mutations like "rotation" by itself.
-                babylonLight.parent = new transformNode_1.TransformNode('__light__', this.variant.viewer.scene, true);
-            }
-            (0, babylonHelper_1.injectMetadata)(babylonLight.parent, {
-                variant: this.variant,
-                variantParameterizable: this,
-            });
-            // disable/hide by default
-            (0, babylonHelper_1.disableNodeWithParents)(babylonLight);
-            // process shadow generator
-            const shadowGeneratorDefinition = (0, lodash_es_1.get)(definition, 'shadowGenerator');
-            if (!(0, lodash_es_1.isEmpty)(shadowGeneratorDefinition)) {
-                if (!(babylonLight instanceof shadowLight_1.ShadowLight)) {
-                    throw new Error(`Using a ShadowGenerator with light type "${definition.type}" is not supported for ` +
-                        `"${lightId}". Use lights deriving from ShadowLight.`);
-                }
-                yield this.processShadowGenerator(babylonLight, shadowGeneratorDefinition);
-            }
-            return babylonLight;
-        });
-    }
-    /**
-     * @param babylonLight
-     * @param definition
-     * @protected
-     */
-    processShadowGenerator(babylonLight, definition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parameterDeclarations = {};
-            // define declarations here if needed in future
-            const parameterBag = definition;
-            const parameters = parameter_1.Parameter.parseFromDeclarations(parameterDeclarations, parameterBag);
-            const shadowGenerator = new shadowGenerator_1.ShadowGenerator(parameters['mapSize'], babylonLight);
-            for (const parameter in parameters) {
-                if (parameter === 'mapSize') {
-                    continue;
-                }
-                (0, lodash_es_1.set)(shadowGenerator, parameter, (0, lodash_es_1.get)(parameters, parameter));
-            }
-            return shadowGenerator;
-        });
-    }
-}
-exports.ViewerLight = ViewerLight;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewerLight = void 0;
+const babylonHelper_1 = require("./../util/babylonHelper");
+const dottedPath_1 = require("./dottedPath");
+const parameter_1 = require("./parameter");
+const variantParameterizable_1 = require("./variantParameterizable");
+const shadowGenerator_1 = require("@babylonjs/core/Lights/Shadows/shadowGenerator");
+require("@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent");
+const hemisphericLight_1 = require("@babylonjs/core/Lights/hemisphericLight");
+const pointLight_1 = require("@babylonjs/core/Lights/pointLight");
+const shadowLight_1 = require("@babylonjs/core/Lights/shadowLight");
+const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
+const transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
+require("@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual");
+const lodash_es_1 = require("lodash-es");
+/**
+ * A {@link ViewerLight} of a {@link Variant}. Acts as a container for Babylon.js lights. Lives only in the context of a
+ * {@link Variant}.
+ */
+class ViewerLight extends variantParameterizable_1.VariantParameterizable {
+    /**
+     * Constructor.
+     */
+    constructor(variant, name) {
+        super(variant, name);
+        this.variant = variant;
+        this.name = name;
+        this.addParameterObservers();
+    }
+    /**
+     * Creates a {@link ViewerLight} with given name.
+     */
+    static create(variant, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const viewerLight = new ViewerLight(variant, name);
+            viewerLight._light = yield viewerLight.createBabylonLightFromDefinition(viewerLight.definition);
+            return viewerLight;
+        });
+    }
+    /**
+     * The wrapped Light.
+     */
+    get light() {
+        if (!this._light) {
+            throw new Error(`Light for ViewerLight "${this.name}" has not been properly initialized.`);
+        }
+        return this._light;
+    }
+    /**
+     * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
+     * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
+     */
+    get dottedPath() {
+        return dottedPath_1.DottedPath.create(this.variant.dottedPath).addPart(this.name);
+    }
+    /**
+     * The id representing a {@link DottedPath}.
+     */
+    get id() {
+        const dottedPath = dottedPath_1.DottedPath.create(this.dottedPath);
+        dottedPath.shiftPart(); // remove root
+        return dottedPath.path;
+    }
+    /**
+     * The {@link LightDefinition} of the {@link ViewerLight}.
+     */
+    get definition() {
+        const definition = this.variant.structureJson.lights[this.name];
+        if ((0, lodash_es_1.isString)(definition)) {
+            return {
+                type: 'baked',
+                path: definition,
+            };
+        }
+        return definition;
+    }
+    /**
+     * The type of the {@link ViewerLight}'s light.
+     */
+    get type() {
+        return this.light.constructor.name.replace(/light/i, '').toLowerCase();
+    }
+    /**
+     * @see {@link VariantParameterizable.commitParameters}
+     * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters) {
+        const _super = Object.create(null, {
+            commitParameters: { get: () => super.commitParameters }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.commitParameters.call(this, parameters);
+        });
+    }
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    addParameterObservers() {
+        this._parameterObservers.set(parameter_1.Parameter.VISIBLE, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                let visible;
+                try {
+                    visible = parameter_1.Parameter.parseBoolean(newValue);
+                }
+                catch (e) {
+                    return;
+                }
+                if (visible === true) {
+                    (0, babylonHelper_1.enableNodeWithParents)(light.light);
+                }
+                else if (visible === false) {
+                    (0, babylonHelper_1.disableNodeWithParents)(light.light);
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.INTENSITY, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                (0, lodash_es_1.set)(light.light, 'intensity', parameter_1.Parameter.parseNumber(newValue));
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.SCALING, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
+                if (rootNode instanceof transformNode_1.TransformNode) {
+                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
+                        scaling: parameter_1.Parameter.parseScaling(newValue),
+                        position: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.POSITION] || '(0, 0, 0)'),
+                        rotation: parameter_1.Parameter.parseRotation(light.inheritedParameters[parameter_1.Parameter.ROTATION] || '(0, 0, 0)'),
+                    });
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.POSITION, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
+                if (rootNode instanceof transformNode_1.TransformNode) {
+                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
+                        scaling: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.SCALING] || '(1, 1, 1)'),
+                        position: parameter_1.Parameter.parseVector(newValue),
+                        rotation: parameter_1.Parameter.parseRotation(light.inheritedParameters[parameter_1.Parameter.ROTATION] || '(0, 0, 0)'),
+                    });
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.ROTATION, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                // we have to deal just with root nodes here due to relative impacts in a node tree
+                const rootNode = (0, babylonHelper_1.getRootNode)(light.light);
+                if (rootNode instanceof transformNode_1.TransformNode) {
+                    (0, babylonHelper_1.transformTransformNode)(rootNode, {
+                        scaling: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.SCALING] || '(1, 1, 1)'),
+                        position: parameter_1.Parameter.parseVector(light.inheritedParameters[parameter_1.Parameter.POSITION] || '(0, 0, 0)'),
+                        rotation: parameter_1.Parameter.parseRotation(newValue),
+                    });
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.DIRECTION, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                if ((light.light instanceof shadowLight_1.ShadowLight && !(light.light instanceof pointLight_1.PointLight)) ||
+                    light.light instanceof hemisphericLight_1.HemisphericLight) {
+                    (0, lodash_es_1.set)(light.light, 'direction', parameter_1.Parameter.parseVector(newValue));
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.ANGLE, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                if (light.light.getClassName() === 'SpotLight') {
+                    (0, lodash_es_1.set)(light.light, 'angle', parameter_1.Parameter.parseNumber(newValue));
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.EXPONENT, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                if (light.light.getClassName() === 'SpotLight') {
+                    (0, lodash_es_1.set)(light.light, 'exponent', parameter_1.Parameter.parseNumber(newValue));
+                }
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.DIFFUSE, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                (0, lodash_es_1.set)(light.light, 'diffuse', parameter_1.Parameter.parseColor(newValue));
+            }),
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.SPECULAR, [
+            (light, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+                (0, lodash_es_1.set)(light.light, 'specular', parameter_1.Parameter.parseColor(newValue));
+            }),
+        ]);
+        return this;
+    }
+    /**
+     * @param definition
+     * @protected
+     */
+    createBabylonLightFromDefinition(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameters = parameter_1.Parameter.parseFromDeclarations(parameter_1.Parameter.declarations, this.inheritedParameters);
+            const scene = this.variant.viewer.scene;
+            let lightId = this.id;
+            let babylonLight;
+            switch (definition.type) {
+                case 'baked': {
+                    if (!definition['path']) {
+                        throw new Error(`The light "${lightId}" of type "${definition.type}" needs a "path".`);
+                    }
+                    const bakedLight = this.variant.inheritedLights.find(l => l.metadata.dottedPath.path === definition['path']);
+                    if (bakedLight) {
+                        lightId = bakedLight.metadata.dottedPath.clone().unshiftPart(this.id).path;
+                        babylonLight = (0, babylonHelper_1.cloneNodeWithParents)(bakedLight);
+                        babylonLight.name = lightId;
+                        babylonLight.id = lightId;
+                    }
+                    else {
+                        throw new Error(`No light found for path "${definition['path']}" in ViewerLight "${lightId}".`);
+                    }
+                    break;
+                }
+                case 'hemispheric': {
+                    if (!parameters['direction']) {
+                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
+                    }
+                    const hemisphericLightModule = yield Promise.resolve().then(() => __importStar(require(
+                    /* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight')));
+                    babylonLight = new hemisphericLightModule.HemisphericLight(lightId, parameters['direction'], scene);
+                    break;
+                }
+                case 'point': {
+                    const pointLightModule = yield Promise.resolve().then(() => __importStar(require(
+                    /* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight')));
+                    babylonLight = new pointLightModule.PointLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
+                    scene);
+                    break;
+                }
+                case 'directional': {
+                    if (!parameters['direction']) {
+                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
+                    }
+                    const directionalLightModule = yield Promise.resolve().then(() => __importStar(require(
+                    /* webpackChunkName: "directional-light" */ '@babylonjs/core/Lights/directionalLight')));
+                    babylonLight = new directionalLightModule.DirectionalLight(lightId, parameters['direction'], scene);
+                    break;
+                }
+                case 'spot': {
+                    if (!parameters['direction']) {
+                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs a "direction".`);
+                    }
+                    if (!parameters['angle']) {
+                        throw new Error(`A ViewerLight of type "${definition.type}" needs an "angle".`);
+                    }
+                    if (!parameters['exponent']) {
+                        throw new Error(`The ViewerLight "${lightId}" of type "${definition.type}" needs an "exponent".`);
+                    }
+                    const spotLightModule = yield Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "spot-light" */ '@babylonjs/core/Lights/spotLight')));
+                    babylonLight = new spotLightModule.SpotLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
+                    parameters['direction'], parameters['angle'], parameters['exponent'], scene);
+                    break;
+                }
+                default:
+                    throw new Error(`The type "${definition.type}" for ViewerLight "${lightId}" is not implemented (yet).`);
+            }
+            if (!babylonLight) {
+                throw new Error(`The Light for ViewerLight "${lightId}" of type "${definition.type}" could no be created ` + `or found.`);
+            }
+            if (!babylonLight.parent) {
+                // Create pseudo parent since lights do not implement mutations like "rotation" by itself.
+                babylonLight.parent = new transformNode_1.TransformNode('__light__', this.variant.viewer.scene, true);
+            }
+            (0, babylonHelper_1.injectMetadata)(babylonLight.parent, {
+                variant: this.variant,
+                variantParameterizable: this,
+            });
+            // disable/hide by default
+            (0, babylonHelper_1.disableNodeWithParents)(babylonLight);
+            // process shadow generator
+            const shadowGeneratorDefinition = (0, lodash_es_1.get)(definition, 'shadowGenerator');
+            if (!(0, lodash_es_1.isEmpty)(shadowGeneratorDefinition)) {
+                if (!(babylonLight instanceof shadowLight_1.ShadowLight)) {
+                    throw new Error(`Using a ShadowGenerator with light type "${definition.type}" is not supported for ` +
+                        `"${lightId}". Use lights deriving from ShadowLight.`);
+                }
+                yield this.processShadowGenerator(babylonLight, shadowGeneratorDefinition);
+            }
+            return babylonLight;
+        });
+    }
+    /**
+     * @param babylonLight
+     * @param definition
+     * @protected
+     */
+    processShadowGenerator(babylonLight, definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameterDeclarations = {};
+            // define declarations here if needed in future
+            const parameterBag = definition;
+            const parameters = parameter_1.Parameter.parseFromDeclarations(parameterDeclarations, parameterBag);
+            const shadowGenerator = new shadowGenerator_1.ShadowGenerator(parameters['mapSize'], babylonLight);
+            for (const parameter in parameters) {
+                if (parameter === 'mapSize') {
+                    continue;
+                }
+                (0, lodash_es_1.set)(shadowGenerator, parameter, (0, lodash_es_1.get)(parameters, parameter));
+            }
+            return shadowGenerator;
+        });
+    }
+}
+exports.ViewerLight = ViewerLight;
 //# sourceMappingURL=viewerLight.js.map