@configura/babylon-view 1.2.1 → 1.3.0-alpha.3

package/dist/geometry/geoSplitter.js

@@ -1,192 +1,192 @@
-import { VertexBuffer } from "@babylonjs/core/Meshes/buffer.js";
-// Will try to split the geometry along planes on the xy, yz and xz-planes for
-// a total of maximum 8 groups. If a triangle straddles a plane those groups
-// will be merged
-export function splitIndexQuick(logger, geo) {
-    const indexArray = geo.getIndices();
-    if (!indexArray) {
-        logger.info("No index array, could not try split geo");
-        return;
-    }
-    const indexCount = geo.getTotalIndices();
-    if (indexCount === 0) {
-        logger.warn("Empty geo index");
-        return;
-    }
-    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
-    if (!positionArray) {
-        logger.info("No position array, could not try split geo");
-        return;
-    }
-    // Three axis, so max potential resultGroups 2^3
-    const resultGroups = [[], [], [], [], [], [], [], []];
-    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
-        const belongsInGroups = [];
-        // For each triangle
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            const offset = indexArray[i] * 3;
-            let belongsIndex = 0;
-            for (let c = 0; c < 3; c++) {
-                belongsIndex += 0 <= positionArray[offset + c] ? 1 << c : 0;
-            }
-            if (!belongsInGroups.some((g) => g === belongsIndex)) {
-                belongsInGroups.push(belongsIndex);
-            }
-        }
-        const targetGroup = resultGroups[belongsInGroups[0]];
-        // Merge groups straddled by this triangle (if needed)
-        for (let i = 1; i < belongsInGroups.length; i++) {
-            const resultGroupIndex = belongsInGroups[i];
-            const otherGroup = resultGroups[resultGroupIndex];
-            // Let this position in the result groups array point to the same group as they share
-            // at least one triangle
-            if (targetGroup !== otherGroup) {
-                // The group can be in multiple positions
-                let j = resultGroups.length;
-                while (j--) {
-                    if (otherGroup === resultGroups[j]) {
-                        resultGroups[j] = targetGroup;
-                    }
-                }
-                const otherGroupLength = otherGroup.length;
-                for (let j = 0; j < otherGroupLength; j++) {
-                    targetGroup.push(otherGroup[j]);
-                }
-            }
-        }
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            targetGroup.push(indexArray[i]);
-        }
-    }
-    // Filter so that we only get one instance of each group and no empty groups
-    let i = resultGroups.length;
-    while (i--) {
-        const group = resultGroups[i];
-        if (group.length === 0) {
-            resultGroups.splice(i, 1);
-            continue;
-        }
-        let j = i;
-        while (j--) {
-            if (group === resultGroups[j]) {
-                resultGroups.splice(i, 1);
-                break;
-            }
-        }
-    }
-    return resultGroups;
-}
-export function splitIndexComplete(logger, geo, conf) {
-    const { maxProgressGroups, maxFinalGroups, acceptCoordinateMatch } = conf;
-    const indexArray = geo.getIndices();
-    if (!indexArray) {
-        logger.info("No index array, could not try split geo");
-        return;
-    }
-    const indexCount = geo.getTotalIndices();
-    if (indexCount === 0) {
-        logger.warn("Empty geo index");
-        return;
-    }
-    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
-    if (!positionArray) {
-        logger.info("No position array, could not try split geo");
-        return;
-    }
-    const resultGroups = [];
-    let targetGroup;
-    // Loop over each triangle in the index
-    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
-        // Groups that neighbor this triangle
-        const intersectingGroupIndices = [];
-        const resultGroupsCount = resultGroups.length;
-        if (maxProgressGroups < resultGroupsCount) {
-            logger.info(`Geo split into too many groups while in progress`, `(max allowed ${maxProgressGroups})`);
-            return;
-        }
-        // Loop over each group.
-        for (let resultGroupIndex = 0; resultGroupIndex < resultGroupsCount; resultGroupIndex++) {
-            const group = resultGroups[resultGroupIndex];
-            const groupLength = group.length;
-            let found = false;
-            // For nodes in the current triangle
-            for (let i = triIndex; i < triIndex + 3; i++) {
-                let j = groupLength;
-                // Loop backwards through indices in the group. Backwards since it's likely new
-                // nodes will be close to previous ones
-                while (j--) {
-                    if (indexArray[i] === group[j]) {
-                        intersectingGroupIndices.push(resultGroupIndex);
-                        found = true;
-                        break;
-                    }
-                }
-                if (found) {
-                    break;
-                }
-            }
-            if (!found && acceptCoordinateMatch) {
-                // For nodes in the current triangle
-                for (let i = triIndex; i < triIndex + 3; i++) {
-                    let j = groupLength;
-                    // Loop backwards through indices in the group. Backwards since it's likely new
-                    // nodes will be close to previous ones
-                    while (j--) {
-                        const offset1 = indexArray[i] * 3;
-                        const offset2 = group[j] * 3;
-                        let c = 3;
-                        while (c--) {
-                            if (positionArray[offset1 + c] !== positionArray[offset2 + c]) {
-                                break;
-                            }
-                        }
-                        if (c === -1) {
-                            intersectingGroupIndices.push(resultGroupIndex);
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (found) {
-                        break;
-                    }
-                }
-            }
-        }
-        targetGroup = undefined;
-        const intersectingGroupIndicesCount = intersectingGroupIndices.length;
-        if (intersectingGroupIndicesCount === 0) {
-            // The triangle is not adjacent to any existing node in any group
-            targetGroup = [];
-            resultGroups.push(targetGroup);
-        }
-        else {
-            let i = intersectingGroupIndicesCount - 1;
-            // Pick one (probably not important which one) to merge the other groups into. If this
-            // was the only one it will skip the loop
-            targetGroup = resultGroups[intersectingGroupIndices[i]];
-            // The nodes are sorted in ascending order. So we back through to nodes to allow us to
-            // use splice without disturbing unbroken ground.
-            while (i--) {
-                // Move all nodes to the target group and remove this one, as the latest triangle
-                // is adjacent to both
-                const resultGroupIndex = intersectingGroupIndices[i];
-                const group = resultGroups[resultGroupIndex];
-                resultGroups.splice(resultGroupIndex, 1);
-                const resultGroupCount = group.length;
-                for (let j = 0; j < resultGroupCount; j++) {
-                    targetGroup.push(group[j]);
-                }
-            }
-        }
-        // Add the latest triangle to the target group
-        for (let i = triIndex; i < triIndex + 3; i++) {
-            targetGroup.push(indexArray[i]);
-        }
-    }
-    const resultGroupsCount = resultGroups.length;
-    if (resultGroupsCount > maxFinalGroups) {
-        logger.info(`Geo split into too many final groups`, `(actual ${resultGroupsCount}, max allowed ${maxFinalGroups})`);
-        return;
-    }
-    return resultGroups;
-}
+import { VertexBuffer } from "@babylonjs/core/Meshes/buffer.js";
+// Will try to split the geometry along planes on the xy, yz and xz-planes for
+// a total of maximum 8 groups. If a triangle straddles a plane those groups
+// will be merged
+export function splitIndexQuick(logger, geo) {
+    const indexArray = geo.getIndices();
+    if (!indexArray) {
+        logger.info("No index array, could not try split geo");
+        return;
+    }
+    const indexCount = geo.getTotalIndices();
+    if (indexCount === 0) {
+        logger.warn("Empty geo index");
+        return;
+    }
+    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
+    if (!positionArray) {
+        logger.info("No position array, could not try split geo");
+        return;
+    }
+    // Three axis, so max potential resultGroups 2^3
+    const resultGroups = [[], [], [], [], [], [], [], []];
+    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
+        const belongsInGroups = [];
+        // For each triangle
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            const offset = indexArray[i] * 3;
+            let belongsIndex = 0;
+            for (let c = 0; c < 3; c++) {
+                belongsIndex += 0 <= positionArray[offset + c] ? 1 << c : 0;
+            }
+            if (!belongsInGroups.some((g) => g === belongsIndex)) {
+                belongsInGroups.push(belongsIndex);
+            }
+        }
+        const targetGroup = resultGroups[belongsInGroups[0]];
+        // Merge groups straddled by this triangle (if needed)
+        for (let i = 1; i < belongsInGroups.length; i++) {
+            const resultGroupIndex = belongsInGroups[i];
+            const otherGroup = resultGroups[resultGroupIndex];
+            // Let this position in the result groups array point to the same group as they share
+            // at least one triangle
+            if (targetGroup !== otherGroup) {
+                // The group can be in multiple positions
+                let j = resultGroups.length;
+                while (j--) {
+                    if (otherGroup === resultGroups[j]) {
+                        resultGroups[j] = targetGroup;
+                    }
+                }
+                const otherGroupLength = otherGroup.length;
+                for (let j = 0; j < otherGroupLength; j++) {
+                    targetGroup.push(otherGroup[j]);
+                }
+            }
+        }
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            targetGroup.push(indexArray[i]);
+        }
+    }
+    // Filter so that we only get one instance of each group and no empty groups
+    let i = resultGroups.length;
+    while (i--) {
+        const group = resultGroups[i];
+        if (group.length === 0) {
+            resultGroups.splice(i, 1);
+            continue;
+        }
+        let j = i;
+        while (j--) {
+            if (group === resultGroups[j]) {
+                resultGroups.splice(i, 1);
+                break;
+            }
+        }
+    }
+    return resultGroups;
+}
+export function splitIndexComplete(logger, geo, conf) {
+    const { maxProgressGroups, maxFinalGroups, acceptCoordinateMatch } = conf;
+    const indexArray = geo.getIndices();
+    if (!indexArray) {
+        logger.info("No index array, could not try split geo");
+        return;
+    }
+    const indexCount = geo.getTotalIndices();
+    if (indexCount === 0) {
+        logger.warn("Empty geo index");
+        return;
+    }
+    const positionArray = geo.getVerticesData(VertexBuffer.PositionKind);
+    if (!positionArray) {
+        logger.info("No position array, could not try split geo");
+        return;
+    }
+    const resultGroups = [];
+    let targetGroup;
+    // Loop over each triangle in the index
+    for (let triIndex = 0; triIndex < indexCount; triIndex += 3) {
+        // Groups that neighbor this triangle
+        const intersectingGroupIndices = [];
+        const resultGroupsCount = resultGroups.length;
+        if (maxProgressGroups < resultGroupsCount) {
+            logger.info(`Geo split into too many groups while in progress`, `(max allowed ${maxProgressGroups})`);
+            return;
+        }
+        // Loop over each group.
+        for (let resultGroupIndex = 0; resultGroupIndex < resultGroupsCount; resultGroupIndex++) {
+            const group = resultGroups[resultGroupIndex];
+            const groupLength = group.length;
+            let found = false;
+            // For nodes in the current triangle
+            for (let i = triIndex; i < triIndex + 3; i++) {
+                let j = groupLength;
+                // Loop backwards through indices in the group. Backwards since it's likely new
+                // nodes will be close to previous ones
+                while (j--) {
+                    if (indexArray[i] === group[j]) {
+                        intersectingGroupIndices.push(resultGroupIndex);
+                        found = true;
+                        break;
+                    }
+                }
+                if (found) {
+                    break;
+                }
+            }
+            if (!found && acceptCoordinateMatch) {
+                // For nodes in the current triangle
+                for (let i = triIndex; i < triIndex + 3; i++) {
+                    let j = groupLength;
+                    // Loop backwards through indices in the group. Backwards since it's likely new
+                    // nodes will be close to previous ones
+                    while (j--) {
+                        const offset1 = indexArray[i] * 3;
+                        const offset2 = group[j] * 3;
+                        let c = 3;
+                        while (c--) {
+                            if (positionArray[offset1 + c] !== positionArray[offset2 + c]) {
+                                break;
+                            }
+                        }
+                        if (c === -1) {
+                            intersectingGroupIndices.push(resultGroupIndex);
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (found) {
+                        break;
+                    }
+                }
+            }
+        }
+        targetGroup = undefined;
+        const intersectingGroupIndicesCount = intersectingGroupIndices.length;
+        if (intersectingGroupIndicesCount === 0) {
+            // The triangle is not adjacent to any existing node in any group
+            targetGroup = [];
+            resultGroups.push(targetGroup);
+        }
+        else {
+            let i = intersectingGroupIndicesCount - 1;
+            // Pick one (probably not important which one) to merge the other groups into. If this
+            // was the only one it will skip the loop
+            targetGroup = resultGroups[intersectingGroupIndices[i]];
+            // The nodes are sorted in ascending order. So we back through to nodes to allow us to
+            // use splice without disturbing unbroken ground.
+            while (i--) {
+                // Move all nodes to the target group and remove this one, as the latest triangle
+                // is adjacent to both
+                const resultGroupIndex = intersectingGroupIndices[i];
+                const group = resultGroups[resultGroupIndex];
+                resultGroups.splice(resultGroupIndex, 1);
+                const resultGroupCount = group.length;
+                for (let j = 0; j < resultGroupCount; j++) {
+                    targetGroup.push(group[j]);
+                }
+            }
+        }
+        // Add the latest triangle to the target group
+        for (let i = triIndex; i < triIndex + 3; i++) {
+            targetGroup.push(indexArray[i]);
+        }
+    }
+    const resultGroupsCount = resultGroups.length;
+    if (resultGroupsCount > maxFinalGroups) {
+        logger.info(`Geo split into too many final groups`, `(actual ${resultGroupsCount}, max allowed ${maxFinalGroups})`);
+        return;
+    }
+    return resultGroups;
+}

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./animation/coordinator/CoordinatorDropAndSpin.js";
-export * from "./animation/coordinator/CoordinatorPulseBounce.js";
-export * from "./animation/coordinator/CoordinatorPulseHighlight.js";
-export * from "./animation/coordinator/CoordinatorPulseInflate.js";
-export * from "./camera/CfgOrbitalCameraControlProps.js";
-export * from "./utilities/utilities3D.js";
-export * from "./view/BaseView.js";
-export * from "./view/BaseViewConfiguration.js";
-export * from "./view/RenderEnv.js";
-export * from "./view/SingleProductDefaultCameraView.js";
-export * from "./view/SingleProductDefaultCameraViewConfiguration.js";
-export * from "./view/SingleProductView.js";
-export * from "./view/SingleProductViewConfiguration.js";
+export * from "./animation/coordinator/CoordinatorDropAndSpin.js";
+export * from "./animation/coordinator/CoordinatorPulseBounce.js";
+export * from "./animation/coordinator/CoordinatorPulseHighlight.js";
+export * from "./animation/coordinator/CoordinatorPulseInflate.js";
+export * from "./camera/CfgOrbitalCameraControlProps.js";
+export * from "./utilities/utilities3D.js";
+export * from "./view/BaseView.js";
+export * from "./view/BaseViewConfiguration.js";
+export * from "./view/RenderEnv.js";
+export * from "./view/SingleProductDefaultCameraView.js";
+export * from "./view/SingleProductDefaultCameraViewConfiguration.js";
+export * from "./view/SingleProductView.js";
+export * from "./view/SingleProductViewConfiguration.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,13 +1,13 @@
-export * from "./animation/coordinator/CoordinatorDropAndSpin.js";
-export * from "./animation/coordinator/CoordinatorPulseBounce.js";
-export * from "./animation/coordinator/CoordinatorPulseHighlight.js";
-export * from "./animation/coordinator/CoordinatorPulseInflate.js";
-export * from "./camera/CfgOrbitalCameraControlProps.js";
-export * from "./utilities/utilities3D.js";
-export * from "./view/BaseView.js";
-export * from "./view/BaseViewConfiguration.js";
-export * from "./view/RenderEnv.js";
-export * from "./view/SingleProductDefaultCameraView.js";
-export * from "./view/SingleProductDefaultCameraViewConfiguration.js";
-export * from "./view/SingleProductView.js";
-export * from "./view/SingleProductViewConfiguration.js";
+export * from "./animation/coordinator/CoordinatorDropAndSpin.js";
+export * from "./animation/coordinator/CoordinatorPulseBounce.js";
+export * from "./animation/coordinator/CoordinatorPulseHighlight.js";
+export * from "./animation/coordinator/CoordinatorPulseInflate.js";
+export * from "./camera/CfgOrbitalCameraControlProps.js";
+export * from "./utilities/utilities3D.js";
+export * from "./view/BaseView.js";
+export * from "./view/BaseViewConfiguration.js";
+export * from "./view/RenderEnv.js";
+export * from "./view/SingleProductDefaultCameraView.js";
+export * from "./view/SingleProductDefaultCameraViewConfiguration.js";
+export * from "./view/SingleProductView.js";
+export * from "./view/SingleProductViewConfiguration.js";

package/dist/light/CfgDirectionalLight.d.ts

@@ -1,9 +1,9 @@
-import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { Node } from "@babylonjs/core/node.js";
-import { Scene } from "@babylonjs/core/scene.js";
-export declare class CfgDirectionalLight extends DirectionalLight {
-    constructor(name: string, scene: Scene, parent?: Node, direction?: Vector3, color?: Color3 | string | number, intensity?: number);
-}
+import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Node } from "@babylonjs/core/node.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export declare class CfgDirectionalLight extends DirectionalLight {
+    constructor(name: string, scene: Scene, parent?: Node, direction?: Vector3, color?: Color3 | string | number, intensity?: number);
+}
 //# sourceMappingURL=CfgDirectionalLight.d.ts.map

package/dist/light/CfgDirectionalLight.js

@@ -1,18 +1,18 @@
-import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { toColor3 } from "../utilities/utilitiesColor.js";
-export class CfgDirectionalLight extends DirectionalLight {
-    constructor(name, scene, parent, direction, color, intensity) {
-        if (direction === undefined) {
-            direction = Vector3.Down();
-        }
-        super(name, direction, scene);
-        if (parent) {
-            this.parent = parent;
-        }
-        this.specular = this.diffuse = toColor3(color);
-        if (intensity !== undefined) {
-            this.intensity = intensity;
-        }
-    }
-}
+import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { toColor3 } from "../utilities/utilitiesColor.js";
+export class CfgDirectionalLight extends DirectionalLight {
+    constructor(name, scene, parent, direction, color, intensity) {
+        if (direction === undefined) {
+            direction = Vector3.Down();
+        }
+        super(name, direction, scene);
+        if (parent) {
+            this.parent = parent;
+        }
+        this.specular = this.diffuse = toColor3(color);
+        if (intensity !== undefined) {
+            this.intensity = intensity;
+        }
+    }
+}

package/dist/light/CfgHemisphericLight.d.ts

@@ -1,8 +1,8 @@
-import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import { Node } from "@babylonjs/core/node.js";
-import { Scene } from "@babylonjs/core/scene.js";
-export declare class CfgHemisphericLight extends HemisphericLight {
-    constructor(name: string, scene: Scene, parent?: Node, color?: Color3 | string | number, intensity?: number);
-}
+import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Node } from "@babylonjs/core/node.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export declare class CfgHemisphericLight extends HemisphericLight {
+    constructor(name: string, scene: Scene, parent?: Node, color?: Color3 | string | number, intensity?: number);
+}
 //# sourceMappingURL=CfgHemisphericLight.d.ts.map

package/dist/light/CfgHemisphericLight.js

@@ -1,17 +1,17 @@
-import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { toColor3 } from "../utilities/utilitiesColor.js";
-export class CfgHemisphericLight extends HemisphericLight {
-    constructor(name, scene, parent, color, intensity) {
-        super(name, new Vector3(0, 0, 1), scene);
-        if (parent) {
-            this.parent = parent;
-        }
-        this.groundColor = Color3.Black();
-        this.specular = this.diffuse = toColor3(color);
-        if (intensity !== undefined) {
-            this.intensity = intensity;
-        }
-    }
-}
+import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { toColor3 } from "../utilities/utilitiesColor.js";
+export class CfgHemisphericLight extends HemisphericLight {
+    constructor(name, scene, parent, color, intensity) {
+        super(name, new Vector3(0, 0, 1), scene);
+        if (parent) {
+            this.parent = parent;
+        }
+        this.groundColor = Color3.Black();
+        this.specular = this.diffuse = toColor3(color);
+        if (intensity !== undefined) {
+            this.intensity = intensity;
+        }
+    }
+}

package/dist/light/CfgPointLight.d.ts

@@ -1,9 +1,9 @@
-import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { Node } from "@babylonjs/core/node.js";
-import { Scene } from "@babylonjs/core/scene.js";
-export declare class CfgPointLight extends PointLight {
-    constructor(name: string, scene: Scene, parent?: Node, position?: Vector3, color?: Color3 | string | number, intensity?: number);
-}
+import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Node } from "@babylonjs/core/node.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export declare class CfgPointLight extends PointLight {
+    constructor(name: string, scene: Scene, parent?: Node, position?: Vector3, color?: Color3 | string | number, intensity?: number);
+}
 //# sourceMappingURL=CfgPointLight.d.ts.map

package/dist/light/CfgPointLight.js

@@ -1,18 +1,18 @@
-import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { toColor3 } from "../utilities/utilitiesColor.js";
-export class CfgPointLight extends PointLight {
-    constructor(name, scene, parent, position, color, intensity) {
-        if (position === undefined) {
-            position = Vector3.Zero();
-        }
-        super(name, position, scene);
-        if (parent) {
-            this.parent = parent;
-        }
-        this.specular = this.diffuse = toColor3(color);
-        if (intensity !== undefined) {
-            this.intensity = intensity;
-        }
-    }
-}
+import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { toColor3 } from "../utilities/utilitiesColor.js";
+export class CfgPointLight extends PointLight {
+    constructor(name, scene, parent, position, color, intensity) {
+        if (position === undefined) {
+            position = Vector3.Zero();
+        }
+        super(name, position, scene);
+        if (parent) {
+            this.parent = parent;
+        }
+        this.specular = this.diffuse = toColor3(color);
+        if (intensity !== undefined) {
+            this.intensity = intensity;
+        }
+    }
+}

package/dist/light/DefaultLightRig.d.ts

@@ -1,20 +1,20 @@
-import { Node } from "@babylonjs/core/node.js";
-import { Scene } from "@babylonjs/core/scene.js";
-import { LightRig, LightRigCreator } from "./LightRigCreator.js";
-export declare const getDefaultLightRigCreator: (relativeToCamera: boolean) => LightRigCreator;
-export declare class DefaultLightRig extends LightRig {
-    private _allLights;
-    private _allPointLights;
-    private _defaultIntensities;
-    private _dimLevel;
-    get dimLevel(): number;
-    set dimLevel(v: number);
-    private _scale;
-    get scale(): number;
-    set scale(v: number);
-    private applyDimLevel;
-    private applyScale;
-    constructor(scene: Scene, target: Node | undefined);
-    get lightCount(): number;
-}
+import { Node } from "@babylonjs/core/node.js";
+import { Scene } from "@babylonjs/core/scene.js";
+import { LightRig, LightRigCreator } from "./LightRigCreator.js";
+export declare const getDefaultLightRigCreator: (relativeToCamera: boolean) => LightRigCreator;
+export declare class DefaultLightRig extends LightRig {
+    private _allLights;
+    private _allPointLights;
+    private _defaultIntensities;
+    private _dimLevel;
+    get dimLevel(): number;
+    set dimLevel(v: number);
+    private _scale;
+    get scale(): number;
+    set scale(v: number);
+    private applyDimLevel;
+    private applyScale;
+    constructor(scene: Scene, target: Node | undefined);
+    get lightCount(): number;
+}
 //# sourceMappingURL=DefaultLightRig.d.ts.map