@combeenation/3d-viewer 4.0.0-beta4 → 4.0.0-beta5

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

@@ -1,323 +1,390 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerLight = void 0;
-var tslib_1 = require("tslib");
-var shadowLight_1 = require("@babylonjs/core/Lights/shadowLight");
-var shadowGenerator_1 = require("@babylonjs/core/Lights/Shadows/shadowGenerator");
-require("@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent");
-var babylonHelper_1 = require("./../util/babylonHelper");
-var lodash_es_1 = require("lodash-es");
-var dottedPath_1 = require("./dottedPath");
-var parameter_1 = require("./parameter");
-var variantParameterizable_1 = require("./variantParameterizable");
-/**
- * A {@link ViewerLight} of a {@link Variant}. Acts as a container for BabylonJS lights. Lives only in the context of a
- * {@link Variant}.
- */
-var ViewerLight = /** @class */ (function (_super) {
-    tslib_1.__extends(ViewerLight, _super);
-    /**
-     * Constructor.
-     */
-    function ViewerLight(variant, name) {
-        var _this = _super.call(this, variant, name) || this;
-        _this.variant = variant;
-        _this.name = name;
-        _this.addParameterObservers();
-        return _this;
-    }
-    /**
-     * Creates a {@link ViewerLight} with given name.
-     */
-    ViewerLight.create = function (variant, name) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var viewerLight, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        viewerLight = new ViewerLight(variant, name);
-                        _a = viewerLight;
-                        return [4 /*yield*/, viewerLight.createBabylonLightFromDefinition(viewerLight.definition)];
-                    case 1:
-                        _a._light = _b.sent();
-                        return [2 /*return*/, viewerLight];
-                }
-            });
-        });
-    };
-    Object.defineProperty(ViewerLight.prototype, "light", {
-        /**
-         * The wrapped Light.
-         */
-        get: function () {
-            if (!this._light) {
-                throw new Error("Light for ViewerLight \"" + this.name + "\" has not been properly initialized.");
-            }
-            return this._light;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewerLight.prototype, "dottedPath", {
-        /**
-         * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
-         * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
-         */
-        get: function () {
-            return dottedPath_1.DottedPath.create(this.variant.dottedPath).addPart(this.name);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewerLight.prototype, "id", {
-        /**
-         * The id representing a {@link DottedPath}.
-         */
-        get: function () {
-            var dottedPath = dottedPath_1.DottedPath.create(this.dottedPath);
-            dottedPath.shiftPart(); // remove root
-            return dottedPath.path;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewerLight.prototype, "definition", {
-        /**
-         * The {@link LightDefinition} of the {@link ViewerLight}.
-         */
-        get: function () {
-            var definition = this.variant.structureJson.lights[this.name];
-            if (lodash_es_1.isString(definition)) {
-                return {
-                    type: 'baked',
-                    path: definition
-                };
-            }
-            return definition;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewerLight.prototype, "type", {
-        /**
-         * The type of the {@link ViewerLight}'s light.
-         */
-        get: function () {
-            return this.light.constructor.name.replace(/light/i, '').toLowerCase();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * @see {@link VariantParameterizable.commitParameters}
-     * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
-     */
-    ViewerLight.prototype.commitParameters = function (parameters) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, _super.prototype.commitParameters.call(this, parameters)];
-            });
-        });
-    };
-    /**
-     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
-     */
-    ViewerLight.prototype.addParameterObservers = function () {
-        this._parameterObservers.set(parameter_1.Parameter.VISIBLE, [
-            function (light, oldValue, newValue) {
-                var visible;
-                try {
-                    visible = parameter_1.Parameter.parseBoolean(newValue);
-                }
-                catch (e) {
-                    return;
-                }
-                if (visible === true) {
-                    babylonHelper_1.enableNodeWithParents(light.light);
-                }
-                else if (visible === false) {
-                    babylonHelper_1.disableNodeWithParents(light.light);
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.INTENSITY, [
-            function (light, oldValue, newValue) {
-                if (light.light instanceof shadowLight_1.ShadowLight) {
-                    lodash_es_1.set(light.light, 'intensity', parameter_1.Parameter.parseNumber(newValue));
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.POSITION, [
-            function (light, oldValue, newValue) {
-                if (light.light instanceof shadowLight_1.ShadowLight) {
-                    lodash_es_1.set(light.light, 'position', parameter_1.Parameter.parseVector(newValue));
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.DIRECTION, [
-            function (light, oldValue, newValue) {
-                if (light.light instanceof shadowLight_1.ShadowLight) {
-                    lodash_es_1.set(light.light, 'direction', parameter_1.Parameter.parseVector(newValue));
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.ANGLE, [
-            function (light, oldValue, newValue) {
-                if (light.light.getClassName() === 'SpotLight') {
-                    lodash_es_1.set(light.light, 'angle', parameter_1.Parameter.parseNumber(newValue));
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.EXPONENT, [
-            function (light, oldValue, newValue) {
-                if (light.light.getClassName() === 'SpotLight') {
-                    lodash_es_1.set(light.light, 'exponent', parameter_1.Parameter.parseNumber(newValue));
-                }
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.DIFFUSE, [
-            function (light, oldValue, newValue) {
-                lodash_es_1.set(light.light, 'diffuse', parameter_1.Parameter.parseColor(newValue));
-            }
-        ]);
-        this._parameterObservers.set(parameter_1.Parameter.SPECULAR, [
-            function (light, oldValue, newValue) {
-                lodash_es_1.set(light.light, 'specular', parameter_1.Parameter.parseColor(newValue));
-            }
-        ]);
-        return this;
-    };
-    /**
-     * @param definition
-     * @protected
-     */
-    ViewerLight.prototype.createBabylonLightFromDefinition = function (definition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var parameters, scene, lightId, babylonLight, _a, bakedLight, hemisphericLightModule, pointLightModule, directionalLightModule, spotLightModule, shadowGeneratorDefinition;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        parameters = parameter_1.Parameter.parseFromDeclarations(parameter_1.Parameter.declarations, this.inheritedParameters);
-                        scene = this.variant.viewer.scene;
-                        lightId = this.id;
-                        _a = definition.type;
-                        switch (_a) {
-                            case 'baked': return [3 /*break*/, 1];
-                            case 'hemispheric': return [3 /*break*/, 2];
-                            case 'point': return [3 /*break*/, 4];
-                            case 'directional': return [3 /*break*/, 6];
-                            case 'spot': return [3 /*break*/, 8];
-                        }
-                        return [3 /*break*/, 10];
-                    case 1:
-                        if (!definition['path']) {
-                            throw new Error("The light \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"path\".");
-                        }
-                        bakedLight = this.variant.inheritedLights.find(function (l) { return l.metadata.dottedPath.path === definition['path']; });
-                        if (bakedLight) {
-                            lightId = bakedLight.metadata.dottedPath.clone().unshiftPart(this.id).path;
-                            babylonLight = babylonHelper_1.cloneNodeWithParents(bakedLight);
-                            babylonLight.name = lightId;
-                            babylonLight.id = lightId;
-                        }
-                        else {
-                            throw new Error("No light found for path \"" + definition['path'] + "\" in ViewerLight \"" + lightId + "\".");
-                        }
-                        return [3 /*break*/, 11];
-                    case 2:
-                        if (!parameters['direction']) {
-                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"direction\".");
-                        }
-                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight'); })];
-                    case 3:
-                        hemisphericLightModule = _b.sent();
-                        babylonLight = new hemisphericLightModule.HemisphericLight(lightId, parameters['direction'], scene);
-                        return [3 /*break*/, 11];
-                    case 4:
-                        if (!parameters['position']) {
-                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"position\".");
-                        }
-                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight'); })];
-                    case 5:
-                        pointLightModule = _b.sent();
-                        babylonLight = new pointLightModule.PointLight(lightId, parameters['position'], scene);
-                        return [3 /*break*/, 11];
-                    case 6:
-                        if (!parameters['direction']) {
-                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"direction\".");
-                        }
-                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "directional-light" */ '@babylonjs/core/Lights/directionalLight'); })];
-                    case 7:
-                        directionalLightModule = _b.sent();
-                        babylonLight = new directionalLightModule.DirectionalLight(lightId, parameters['direction'], scene);
-                        return [3 /*break*/, 11];
-                    case 8:
-                        if (!parameters['position']) {
-                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"position\".");
-                        }
-                        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\".");
-                        }
-                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "spot-light" */ '@babylonjs/core/Lights/spotLight'); })];
-                    case 9:
-                        spotLightModule = _b.sent();
-                        babylonLight = new spotLightModule.SpotLight(lightId, parameters['position'], parameters['direction'], parameters['angle'], parameters['exponent'], scene);
-                        return [3 /*break*/, 11];
-                    case 10: throw new Error("The type \"" + definition.type + "\" for ViewerLight \"" + lightId + "\" is not implemented (yet).");
-                    case 11:
-                        if (!babylonLight) {
-                            throw new Error("The Light for ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" could no be created " +
-                                "or found.");
-                        }
-                        // disable/hide by default
-                        babylonHelper_1.disableNodeWithParents(babylonLight);
-                        shadowGeneratorDefinition = lodash_es_1.get(definition, 'shadowGenerator');
-                        if (!!lodash_es_1.isEmpty(shadowGeneratorDefinition)) return [3 /*break*/, 13];
-                        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."));
-                        }
-                        return [4 /*yield*/, this.processShadowGenerator(babylonLight, shadowGeneratorDefinition)];
-                    case 12:
-                        _b.sent();
-                        _b.label = 13;
-                    case 13: return [2 /*return*/, babylonLight];
-                }
-            });
-        });
-    };
-    ;
-    /**
-     * @param babylonLight
-     * @param definition
-     * @protected
-     */
-    ViewerLight.prototype.processShadowGenerator = function (babylonLight, definition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var parameterDeclarations, parameterBag, parameters, shadowGenerator, parameter;
-            return tslib_1.__generator(this, function (_a) {
-                parameterDeclarations = {};
-                parameterBag = definition;
-                parameters = parameter_1.Parameter.parseFromDeclarations(parameterDeclarations, parameterBag);
-                shadowGenerator = new shadowGenerator_1.ShadowGenerator(parameters['mapSize'], babylonLight);
-                for (parameter in parameters) {
-                    if (parameter === 'mapSize') {
-                        continue;
-                    }
-                    lodash_es_1.set(shadowGenerator, parameter, lodash_es_1.get(parameters, parameter));
-                }
-                return [2 /*return*/, shadowGenerator];
-            });
-        });
-    };
-    ;
-    return ViewerLight;
-}(variantParameterizable_1.VariantParameterizable));
-exports.ViewerLight = ViewerLight;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewerLight = void 0;
+var tslib_1 = require("tslib");
+var core_1 = require("@babylonjs/core");
+var hemisphericLight_1 = require("@babylonjs/core/Lights/hemisphericLight");
+var shadowLight_1 = require("@babylonjs/core/Lights/shadowLight");
+var shadowGenerator_1 = require("@babylonjs/core/Lights/Shadows/shadowGenerator");
+require("@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent");
+var math_vector_1 = require("@babylonjs/core/Maths/math.vector");
+var transformNode_1 = require("@babylonjs/core/Meshes/transformNode");
+require("@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual");
+var lodash_es_1 = require("lodash-es");
+var babylonHelper_1 = require("./../util/babylonHelper");
+var dottedPath_1 = require("./dottedPath");
+var parameter_1 = require("./parameter");
+var variantParameterizable_1 = require("./variantParameterizable");
+/**
+ * A {@link ViewerLight} of a {@link Variant}. Acts as a container for BabylonJS lights. Lives only in the context of a
+ * {@link Variant}.
+ */
+var ViewerLight = /** @class */ (function (_super) {
+    tslib_1.__extends(ViewerLight, _super);
+    /**
+     * Constructor.
+     */
+    function ViewerLight(variant, name) {
+        var _this = _super.call(this, variant, name) || this;
+        _this.variant = variant;
+        _this.name = name;
+        _this.addParameterObservers();
+        return _this;
+    }
+    /**
+     * Creates a {@link ViewerLight} with given name.
+     */
+    ViewerLight.create = function (variant, name) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var viewerLight, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        viewerLight = new ViewerLight(variant, name);
+                        _a = viewerLight;
+                        return [4 /*yield*/, viewerLight.createBabylonLightFromDefinition(viewerLight.definition)];
+                    case 1:
+                        _a._light = _b.sent();
+                        return [2 /*return*/, viewerLight];
+                }
+            });
+        });
+    };
+    Object.defineProperty(ViewerLight.prototype, "light", {
+        /**
+         * The wrapped Light.
+         */
+        get: function () {
+            if (!this._light) {
+                throw new Error("Light for ViewerLight \"" + this.name + "\" has not been properly initialized.");
+            }
+            return this._light;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ViewerLight.prototype, "dottedPath", {
+        /**
+         * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
+         * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
+         */
+        get: function () {
+            return dottedPath_1.DottedPath.create(this.variant.dottedPath).addPart(this.name);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ViewerLight.prototype, "id", {
+        /**
+         * The id representing a {@link DottedPath}.
+         */
+        get: function () {
+            var dottedPath = dottedPath_1.DottedPath.create(this.dottedPath);
+            dottedPath.shiftPart(); // remove root
+            return dottedPath.path;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ViewerLight.prototype, "definition", {
+        /**
+         * The {@link LightDefinition} of the {@link ViewerLight}.
+         */
+        get: function () {
+            var definition = this.variant.structureJson.lights[this.name];
+            if (lodash_es_1.isString(definition)) {
+                return {
+                    type: 'baked',
+                    path: definition
+                };
+            }
+            return definition;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ViewerLight.prototype, "type", {
+        /**
+         * The type of the {@link ViewerLight}'s light.
+         */
+        get: function () {
+            return this.light.constructor.name.replace(/light/i, '').toLowerCase();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @see {@link VariantParameterizable.commitParameters}
+     * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
+     */
+    ViewerLight.prototype.commitParameters = function (parameters) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, _super.prototype.commitParameters.call(this, parameters)];
+            });
+        });
+    };
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    ViewerLight.prototype.addParameterObservers = function () {
+        var _this = this;
+        this._parameterObservers.set(parameter_1.Parameter.VISIBLE, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var visible;
+                return tslib_1.__generator(this, function (_a) {
+                    try {
+                        visible = parameter_1.Parameter.parseBoolean(newValue);
+                    }
+                    catch (e) {
+                        return [2 /*return*/];
+                    }
+                    if (visible === true) {
+                        babylonHelper_1.enableNodeWithParents(light.light);
+                    }
+                    else if (visible === false) {
+                        babylonHelper_1.disableNodeWithParents(light.light);
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.INTENSITY, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    lodash_es_1.set(light.light, 'intensity', parameter_1.Parameter.parseNumber(newValue));
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.POSITION, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var rootNode;
+                return tslib_1.__generator(this, function (_a) {
+                    rootNode = babylonHelper_1.getRootNode(light.light);
+                    if (rootNode instanceof transformNode_1.TransformNode) {
+                        babylonHelper_1.moveTransformNode(rootNode, parameter_1.Parameter.parseVector(newValue));
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.ROTATION, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var rootNode;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(parameter_1.Parameter.POSITION in light.inheritedParameters)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, light.commitParameter(parameter_1.Parameter.POSITION, light.inheritedParameters[parameter_1.Parameter.POSITION])];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            rootNode = babylonHelper_1.getRootNode(light.light);
+                            if (rootNode instanceof transformNode_1.TransformNode) {
+                                babylonHelper_1.rotateTransformNode(rootNode, parameter_1.Parameter.parseRotation(newValue));
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.SCALING, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var rootNode;
+                return tslib_1.__generator(this, function (_a) {
+                    rootNode = babylonHelper_1.getRootNode(light.light);
+                    if (rootNode instanceof transformNode_1.TransformNode) {
+                        rootNode.scaling = parameter_1.Parameter.parseScaling(newValue);
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.DIRECTION, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    if ((light.light instanceof shadowLight_1.ShadowLight && !(light.light instanceof core_1.PointLight))
+                        || light.light instanceof hemisphericLight_1.HemisphericLight) {
+                        lodash_es_1.set(light.light, 'direction', parameter_1.Parameter.parseVector(newValue));
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.ANGLE, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    if (light.light.getClassName() === 'SpotLight') {
+                        lodash_es_1.set(light.light, 'angle', parameter_1.Parameter.parseNumber(newValue));
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.EXPONENT, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    if (light.light.getClassName() === 'SpotLight') {
+                        lodash_es_1.set(light.light, 'exponent', parameter_1.Parameter.parseNumber(newValue));
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.DIFFUSE, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    lodash_es_1.set(light.light, 'diffuse', parameter_1.Parameter.parseColor(newValue));
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        this._parameterObservers.set(parameter_1.Parameter.SPECULAR, [
+            function (light, oldValue, newValue) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    lodash_es_1.set(light.light, 'specular', parameter_1.Parameter.parseColor(newValue));
+                    return [2 /*return*/];
+                });
+            }); }
+        ]);
+        return this;
+    };
+    /**
+     * @param definition
+     * @protected
+     */
+    ViewerLight.prototype.createBabylonLightFromDefinition = function (definition) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var parameters, scene, lightId, babylonLight, _a, bakedLight, hemisphericLightModule, pointLightModule, directionalLightModule, spotLightModule, shadowGeneratorDefinition;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        parameters = parameter_1.Parameter.parseFromDeclarations(parameter_1.Parameter.declarations, this.inheritedParameters);
+                        scene = this.variant.viewer.scene;
+                        lightId = this.id;
+                        _a = definition.type;
+                        switch (_a) {
+                            case 'baked': return [3 /*break*/, 1];
+                            case 'hemispheric': return [3 /*break*/, 2];
+                            case 'point': return [3 /*break*/, 4];
+                            case 'directional': return [3 /*break*/, 6];
+                            case 'spot': return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 10];
+                    case 1:
+                        if (!definition['path']) {
+                            throw new Error("The light \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"path\".");
+                        }
+                        bakedLight = this.variant.inheritedLights.find(function (l) { return l.metadata.dottedPath.path === definition['path']; });
+                        if (bakedLight) {
+                            lightId = bakedLight.metadata.dottedPath.clone().unshiftPart(this.id).path;
+                            babylonLight = babylonHelper_1.cloneNodeWithParents(bakedLight);
+                            babylonLight.name = lightId;
+                            babylonLight.id = lightId;
+                        }
+                        else {
+                            throw new Error("No light found for path \"" + definition['path'] + "\" in ViewerLight \"" + lightId + "\".");
+                        }
+                        return [3 /*break*/, 11];
+                    case 2:
+                        if (!parameters['direction']) {
+                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"direction\".");
+                        }
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "hemispheric-light" */ '@babylonjs/core/Lights/hemisphericLight'); })];
+                    case 3:
+                        hemisphericLightModule = _b.sent();
+                        babylonLight = new hemisphericLightModule.HemisphericLight(lightId, parameters['direction'], scene);
+                        return [3 /*break*/, 11];
+                    case 4: return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "point-light" */ '@babylonjs/core/Lights/pointLight'); })];
+                    case 5:
+                        pointLightModule = _b.sent();
+                        babylonLight = new pointLightModule.PointLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
+                        scene);
+                        return [3 /*break*/, 11];
+                    case 6:
+                        if (!parameters['direction']) {
+                            throw new Error("The ViewerLight \"" + lightId + "\" of type \"" + definition.type + "\" needs a \"direction\".");
+                        }
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "directional-light" */ '@babylonjs/core/Lights/directionalLight'); })];
+                    case 7:
+                        directionalLightModule = _b.sent();
+                        babylonLight = new directionalLightModule.DirectionalLight(lightId, parameters['direction'], scene);
+                        return [3 /*break*/, 11];
+                    case 8:
+                        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\".");
+                        }
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require(/* webpackChunkName: "spot-light" */ '@babylonjs/core/Lights/spotLight'); })];
+                    case 9:
+                        spotLightModule = _b.sent();
+                        babylonLight = new spotLightModule.SpotLight(lightId, math_vector_1.Vector3.Zero(), // position is set via parent TransformNode
+                        parameters['direction'], parameters['angle'], parameters['exponent'], scene);
+                        return [3 /*break*/, 11];
+                    case 10: throw new Error("The type \"" + definition.type + "\" for ViewerLight \"" + lightId + "\" is not implemented (yet).");
+                    case 11:
+                        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);
+                        }
+                        babylonHelper_1.injectNodeMetadata(babylonLight.parent, {
+                            variant: this.variant,
+                            variantParameterizable: this
+                        });
+                        // disable/hide by default
+                        babylonHelper_1.disableNodeWithParents(babylonLight);
+                        shadowGeneratorDefinition = lodash_es_1.get(definition, 'shadowGenerator');
+                        if (!!lodash_es_1.isEmpty(shadowGeneratorDefinition)) return [3 /*break*/, 13];
+                        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."));
+                        }
+                        return [4 /*yield*/, this.processShadowGenerator(babylonLight, shadowGeneratorDefinition)];
+                    case 12:
+                        _b.sent();
+                        _b.label = 13;
+                    case 13: return [2 /*return*/, babylonLight];
+                }
+            });
+        });
+    };
+    ;
+    /**
+     * @param babylonLight
+     * @param definition
+     * @protected
+     */
+    ViewerLight.prototype.processShadowGenerator = function (babylonLight, definition) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var parameterDeclarations, parameterBag, parameters, shadowGenerator, parameter;
+            return tslib_1.__generator(this, function (_a) {
+                parameterDeclarations = {};
+                parameterBag = definition;
+                parameters = parameter_1.Parameter.parseFromDeclarations(parameterDeclarations, parameterBag);
+                shadowGenerator = new shadowGenerator_1.ShadowGenerator(parameters['mapSize'], babylonLight);
+                for (parameter in parameters) {
+                    if (parameter === 'mapSize') {
+                        continue;
+                    }
+                    lodash_es_1.set(shadowGenerator, parameter, lodash_es_1.get(parameters, parameter));
+                }
+                return [2 /*return*/, shadowGenerator];
+            });
+        });
+    };
+    ;
+    return ViewerLight;
+}(variantParameterizable_1.VariantParameterizable));
+exports.ViewerLight = ViewerLight;
 //# sourceMappingURL=viewerLight.js.map