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

package/dist/nodes/CfgSymNode.d.ts

@@ -1,43 +1,43 @@
-import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { CfgMaterialMapping, CfgMtrlSourceWithMetaData } from "@configura/web-api";
-import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
-import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
-import { LogObservable, LogProducer } from "@configura/web-utilities";
-import { AnimatableObject } from "../animation/AnimatableObject.js";
-import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
-import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
-import { RenderEnv } from "../view/RenderEnv.js";
-import { CfgTransformNode } from "./CfgTransformNode.js";
-export declare class CfgSymNode extends CfgTransformNode implements LogProducer, AnimatableObject {
-    _detailLevel: DetailLevel;
-    _symNode: SymNode;
-    private _symNodeParent?;
-    static makeCfgSymNode(renderEnvironment: RenderEnv, detailLevel: DetailLevel, symNode: SymNode, symNodeParent?: CfgSymNode): Promise<CfgSymNode | undefined>;
-    get cfgClassName(): string;
-    static initCfgSymNode(node: CfgSymNode): Promise<void>;
-    logger: LogObservable;
-    _tag: string | undefined;
-    private _gMaterial;
-    private _symNodeChildren;
-    private _deferredMesh;
-    private _originalMatrix;
-    protected constructor(renderEnvironment: RenderEnv, _detailLevel: DetailLevel, _symNode: SymNode, _symNodeParent?: CfgSymNode | undefined);
-    getChildrenForAnimation(): CfgTransformNode[];
-    private initTag;
-    private initGMaterial;
-    get originalMatrix(): Matrix;
-    protected initTransform(): void;
-    private initChildren;
-    get isEmpty(): boolean;
-    findMaterial(areasToMaterials: CfgMaterialMapping): CfgMtrlSourceWithMetaData | undefined;
-    private loadGeo;
-    applyGeo(): void;
-    isAllMeshMaterialsReady(): boolean;
-    setMaterialsAndLoad(areasToMaterials: CfgMaterialMapping, animatorCoordinator?: CoordinatorWithMeta): Promise<void>;
-    applyMaterial(): void;
-    get boundingBox(): CfgBoundingBox;
-    protected addInspectorProperties(): void;
-    private get _inspectorLogSymNode();
-    private set _inspectorLogSymNode(value);
-}
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { CfgMaterialMapping, CfgMtrlSourceWithMetaData } from "@configura/web-api";
+import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
+import { DetailLevel } from "@configura/web-core/dist/cm/geometry/DetailMask.js";
+import { LogObservable, LogProducer } from "@configura/web-utilities";
+import { AnimatableObject } from "../animation/AnimatableObject.js";
+import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
+import { RenderEnv } from "../view/RenderEnv.js";
+import { CfgTransformNode } from "./CfgTransformNode.js";
+export declare class CfgSymNode extends CfgTransformNode implements LogProducer, AnimatableObject {
+    _detailLevel: DetailLevel;
+    _symNode: SymNode;
+    private _symNodeParent?;
+    static makeCfgSymNode(renderEnvironment: RenderEnv, detailLevel: DetailLevel, symNode: SymNode, symNodeParent?: CfgSymNode): Promise<CfgSymNode | undefined>;
+    get cfgClassName(): string;
+    static initCfgSymNode(node: CfgSymNode): Promise<void>;
+    logger: LogObservable;
+    _tag: string | undefined;
+    private _gMaterial;
+    private _symNodeChildren;
+    private _deferredMesh;
+    private _originalMatrix;
+    protected constructor(renderEnvironment: RenderEnv, _detailLevel: DetailLevel, _symNode: SymNode, _symNodeParent?: CfgSymNode | undefined);
+    getChildrenForAnimation(): CfgTransformNode[];
+    private initTag;
+    private initGMaterial;
+    get originalMatrix(): Matrix;
+    protected initTransform(): void;
+    private initChildren;
+    get isEmpty(): boolean;
+    findMaterial(areasToMaterials: CfgMaterialMapping): CfgMtrlSourceWithMetaData | undefined;
+    private loadGeo;
+    applyGeo(): void;
+    isAllMeshMaterialsReady(): boolean;
+    setMaterialsAndLoad(areasToMaterials: CfgMaterialMapping, animatorCoordinator?: CoordinatorWithMeta): Promise<void>;
+    applyMaterial(): void;
+    get boundingBox(): CfgBoundingBox;
+    protected addInspectorProperties(): void;
+    private get _inspectorLogSymNode();
+    private set _inspectorLogSymNode(value);
+}
 //# sourceMappingURL=CfgSymNode.d.ts.map

package/dist/nodes/CfgSymNode.js

@@ -1,216 +1,216 @@
-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());
-    });
-};
-import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
-import { SymTags } from "@configura/web-core/dist/cm/format/cmsym/components/SymTags.js";
-import { LogObservable } from "@configura/web-utilities";
-import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
-import { symTransformToMatrix } from "../utilities/utilities3D.js";
-import { CfgDeferredMeshNode } from "./CfgDeferredMeshNode.js";
-import { CfgTransformNode } from "./CfgTransformNode.js";
-function isNoRender(symNode) {
-    var _a;
-    const symTags = symNode.symTags();
-    return symTags instanceof SymTags && !!((_a = symTags.node) === null || _a === void 0 ? void 0 : _a.components.has("symConnector"));
-}
-export class CfgSymNode extends CfgTransformNode {
-    constructor(renderEnvironment, _detailLevel, _symNode, _symNodeParent) {
-        super(renderEnvironment, "(SymNode) " + _symNode.id);
-        this._detailLevel = _detailLevel;
-        this._symNode = _symNode;
-        this._symNodeParent = _symNodeParent;
-        this.logger = new LogObservable();
-        this._symNodeChildren = [];
-        this.initTransform();
-    }
-    static makeCfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isNoRender(symNode)) {
-                return undefined;
-            }
-            const node = new CfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent);
-            yield CfgSymNode.initCfgSymNode(node);
-            if (node.isEmpty) {
-                if (renderEnvironment.cullEmptyNodes) {
-                    node.dispose();
-                    return undefined;
-                }
-                node.logger.info("Empty node");
-            }
-            if (node._tag && node._tag.length > 0) {
-                node.name += " | " + node._tag;
-            }
-            return node;
-        });
-    }
-    get cfgClassName() {
-        return "CfgSymNode";
-    }
-    static initCfgSymNode(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            node.initTag();
-            node.initGMaterial();
-            yield node.initChildren();
-            yield node.loadGeo();
-        });
-    }
-    getChildrenForAnimation() {
-        const target = super.getChildrenForAnimation();
-        if (this._deferredMesh !== undefined) {
-            target.push(this._deferredMesh);
-        }
-        return target;
-    }
-    initTag() {
-        const symTags = this._symNode.symTags();
-        if (symTags instanceof SymTags && symTags.main !== undefined) {
-            this._tag = symTags.main;
-        }
-    }
-    initGMaterial() {
-        var _a, _b;
-        let material = this._symNode.symGMaterial();
-        if ((material === null || material === void 0 ? void 0 : material.gm) === undefined) {
-            const selectMaterial = (_a = this._symNode.symGMaterialSelector()) === null || _a === void 0 ? void 0 : _a.symGMaterial;
-            if ((selectMaterial === null || selectMaterial === void 0 ? void 0 : selectMaterial.gm) !== undefined) {
-                material = selectMaterial;
-            }
-        }
-        if ((material === null || material === void 0 ? void 0 : material.gm) === undefined) {
-            const parentMaterial = (_b = this._symNodeParent) === null || _b === void 0 ? void 0 : _b._gMaterial;
-            if ((parentMaterial === null || parentMaterial === void 0 ? void 0 : parentMaterial.gm) !== undefined) {
-                material = parentMaterial;
-            }
-        }
-        this._gMaterial = material;
-    }
-    get originalMatrix() {
-        if (this._originalMatrix === undefined) {
-            const symTransform = this._symNode.symTransform();
-            if (symTransform === undefined) {
-                this._originalMatrix = Matrix.Identity();
-            }
-            else {
-                const transform = symTransform.transform();
-                this._originalMatrix = symTransformToMatrix(transform);
-            }
-        }
-        return this._originalMatrix;
-    }
-    initTransform() {
-        this.setPreTransformMatrix(this.originalMatrix);
-    }
-    initChildren() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = [];
-            for (const childNode of (this._symNode.children(this.logger, false, true) || []).values()) {
-                promises.push((() => __awaiter(this, void 0, void 0, function* () {
-                    const childSymNode = yield CfgSymNode.makeCfgSymNode(this._renderEnvironment, this._detailLevel, childNode, this);
-                    if (childSymNode === undefined) {
-                        return;
-                    }
-                    this._symNodeChildren.push(childSymNode);
-                    this.add(childSymNode);
-                }))());
-            }
-            yield Promise.all(promises);
-        });
-    }
-    get isEmpty() {
-        return this._deferredMesh === undefined && this._symNodeChildren.length === 0;
-    }
-    findMaterial(areasToMaterials) {
-        if (this._tag !== undefined && areasToMaterials.has(this._tag)) {
-            return areasToMaterials.get(this._tag);
-        }
-        if (this._symNodeParent !== undefined) {
-            return this._symNodeParent.findMaterial(areasToMaterials);
-        }
-        return undefined;
-    }
-    loadGeo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._deferredMesh = yield CfgDeferredMeshNode.makeCfgDeferredMesh(this.logger, this._renderEnvironment, this._detailLevel, this._symNode, this._gMaterial);
-            if (this._deferredMesh === undefined) {
-                return;
-            }
-            this._deferredMesh.setEnabled(false);
-            this.add(this._deferredMesh);
-        });
-    }
-    applyGeo() {
-        if (this._deferredMesh !== undefined) {
-            this._deferredMesh.setEnabled(true);
-        }
-        for (const symNodeChild of this._symNodeChildren) {
-            symNodeChild.applyGeo();
-        }
-    }
-    isAllMeshMaterialsReady() {
-        return ((this._deferredMesh === undefined || this._deferredMesh.isAllMeshMaterialsReady()) &&
-            this._symNodeChildren.reduce((a, c) => a && c.isAllMeshMaterialsReady(), true));
-    }
-    setMaterialsAndLoad(areasToMaterials, animatorCoordinator) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = [];
-            if (this._deferredMesh !== undefined) {
-                let mtrlWithMetaData = this.findMaterial(areasToMaterials);
-                promises.push(this._deferredMesh.setMaterialAndLoad(mtrlWithMetaData, animatorCoordinator));
-            }
-            for (const symNodeChild of this._symNodeChildren) {
-                promises.push(symNodeChild.setMaterialsAndLoad(areasToMaterials, animatorCoordinator));
-            }
-            yield Promise.all(promises);
-        });
-    }
-    applyMaterial() {
-        if (this._deferredMesh !== undefined) {
-            this._deferredMesh.applyMaterial();
-        }
-        this._symNodeChildren.forEach((child) => {
-            child.applyMaterial();
-        });
-    }
-    get boundingBox() {
-        const bb = this._symNodeChildren.reduce((a, m) => {
-            a.expand(m.boundingBox);
-            return a;
-        }, new CfgBoundingBox());
-        if (this._deferredMesh !== undefined) {
-            bb.expand(this._deferredMesh.boundingBox);
-        }
-        bb.applyMatrix(this.originalMatrix);
-        return bb;
-    }
-    addInspectorProperties() {
-        super.addInspectorProperties();
-        this.addInspectableCustomProperty({
-            label: "Detail level",
-            propertyName: "_detailLevel",
-            type: InspectableType.String,
-        });
-        this.addInspectableCustomProperty({
-            label: "Tag",
-            propertyName: "_tag",
-            type: InspectableType.String,
-        });
-        this.addInspectableCustomProperty({
-            label: "log symNode",
-            propertyName: "_inspectorLogSymNode",
-            type: InspectableType.Checkbox,
-        });
-    }
-    get _inspectorLogSymNode() {
-        return this._symNode === undefined;
-    }
-    set _inspectorLogSymNode(x) {
-        console.log(this._symNode);
-    }
-}
+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());
+    });
+};
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
+import { SymTags } from "@configura/web-core/dist/cm/format/cmsym/components/SymTags.js";
+import { LogObservable } from "@configura/web-utilities";
+import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
+import { symTransformToMatrix } from "../utilities/utilities3D.js";
+import { CfgDeferredMeshNode } from "./CfgDeferredMeshNode.js";
+import { CfgTransformNode } from "./CfgTransformNode.js";
+function isNoRender(symNode) {
+    var _a;
+    const symTags = symNode.symTags();
+    return symTags instanceof SymTags && !!((_a = symTags.node) === null || _a === void 0 ? void 0 : _a.components.has("symConnector"));
+}
+export class CfgSymNode extends CfgTransformNode {
+    constructor(renderEnvironment, _detailLevel, _symNode, _symNodeParent) {
+        super(renderEnvironment, "(SymNode) " + _symNode.id);
+        this._detailLevel = _detailLevel;
+        this._symNode = _symNode;
+        this._symNodeParent = _symNodeParent;
+        this.logger = new LogObservable();
+        this._symNodeChildren = [];
+        this.initTransform();
+    }
+    static makeCfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNoRender(symNode)) {
+                return undefined;
+            }
+            const node = new CfgSymNode(renderEnvironment, detailLevel, symNode, symNodeParent);
+            yield CfgSymNode.initCfgSymNode(node);
+            if (node.isEmpty) {
+                if (renderEnvironment.cullEmptyNodes) {
+                    node.dispose();
+                    return undefined;
+                }
+                node.logger.info("Empty node");
+            }
+            if (node._tag && node._tag.length > 0) {
+                node.name += " | " + node._tag;
+            }
+            return node;
+        });
+    }
+    get cfgClassName() {
+        return "CfgSymNode";
+    }
+    static initCfgSymNode(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            node.initTag();
+            node.initGMaterial();
+            yield node.initChildren();
+            yield node.loadGeo();
+        });
+    }
+    getChildrenForAnimation() {
+        const target = super.getChildrenForAnimation();
+        if (this._deferredMesh !== undefined) {
+            target.push(this._deferredMesh);
+        }
+        return target;
+    }
+    initTag() {
+        const symTags = this._symNode.symTags();
+        if (symTags instanceof SymTags && symTags.main !== undefined) {
+            this._tag = symTags.main;
+        }
+    }
+    initGMaterial() {
+        var _a, _b;
+        let material = this._symNode.symGMaterial();
+        if ((material === null || material === void 0 ? void 0 : material.gm) === undefined) {
+            const selectMaterial = (_a = this._symNode.symGMaterialSelector()) === null || _a === void 0 ? void 0 : _a.symGMaterial;
+            if ((selectMaterial === null || selectMaterial === void 0 ? void 0 : selectMaterial.gm) !== undefined) {
+                material = selectMaterial;
+            }
+        }
+        if ((material === null || material === void 0 ? void 0 : material.gm) === undefined) {
+            const parentMaterial = (_b = this._symNodeParent) === null || _b === void 0 ? void 0 : _b._gMaterial;
+            if ((parentMaterial === null || parentMaterial === void 0 ? void 0 : parentMaterial.gm) !== undefined) {
+                material = parentMaterial;
+            }
+        }
+        this._gMaterial = material;
+    }
+    get originalMatrix() {
+        if (this._originalMatrix === undefined) {
+            const symTransform = this._symNode.symTransform();
+            if (symTransform === undefined) {
+                this._originalMatrix = Matrix.Identity();
+            }
+            else {
+                const transform = symTransform.transform();
+                this._originalMatrix = symTransformToMatrix(transform);
+            }
+        }
+        return this._originalMatrix;
+    }
+    initTransform() {
+        this.setPreTransformMatrix(this.originalMatrix);
+    }
+    initChildren() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            for (const childNode of (this._symNode.children(this.logger, false, true) || []).values()) {
+                promises.push((() => __awaiter(this, void 0, void 0, function* () {
+                    const childSymNode = yield CfgSymNode.makeCfgSymNode(this._renderEnvironment, this._detailLevel, childNode, this);
+                    if (childSymNode === undefined) {
+                        return;
+                    }
+                    this._symNodeChildren.push(childSymNode);
+                    this.add(childSymNode);
+                }))());
+            }
+            yield Promise.all(promises);
+        });
+    }
+    get isEmpty() {
+        return this._deferredMesh === undefined && this._symNodeChildren.length === 0;
+    }
+    findMaterial(areasToMaterials) {
+        if (this._tag !== undefined && areasToMaterials.has(this._tag)) {
+            return areasToMaterials.get(this._tag);
+        }
+        if (this._symNodeParent !== undefined) {
+            return this._symNodeParent.findMaterial(areasToMaterials);
+        }
+        return undefined;
+    }
+    loadGeo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._deferredMesh = yield CfgDeferredMeshNode.makeCfgDeferredMesh(this.logger, this._renderEnvironment, this._detailLevel, this._symNode, this._gMaterial);
+            if (this._deferredMesh === undefined) {
+                return;
+            }
+            this._deferredMesh.setEnabled(false);
+            this.add(this._deferredMesh);
+        });
+    }
+    applyGeo() {
+        if (this._deferredMesh !== undefined) {
+            this._deferredMesh.setEnabled(true);
+        }
+        for (const symNodeChild of this._symNodeChildren) {
+            symNodeChild.applyGeo();
+        }
+    }
+    isAllMeshMaterialsReady() {
+        return ((this._deferredMesh === undefined || this._deferredMesh.isAllMeshMaterialsReady()) &&
+            this._symNodeChildren.reduce((a, c) => a && c.isAllMeshMaterialsReady(), true));
+    }
+    setMaterialsAndLoad(areasToMaterials, animatorCoordinator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            if (this._deferredMesh !== undefined) {
+                let mtrlWithMetaData = this.findMaterial(areasToMaterials);
+                promises.push(this._deferredMesh.setMaterialAndLoad(mtrlWithMetaData, animatorCoordinator));
+            }
+            for (const symNodeChild of this._symNodeChildren) {
+                promises.push(symNodeChild.setMaterialsAndLoad(areasToMaterials, animatorCoordinator));
+            }
+            yield Promise.all(promises);
+        });
+    }
+    applyMaterial() {
+        if (this._deferredMesh !== undefined) {
+            this._deferredMesh.applyMaterial();
+        }
+        this._symNodeChildren.forEach((child) => {
+            child.applyMaterial();
+        });
+    }
+    get boundingBox() {
+        const bb = this._symNodeChildren.reduce((a, m) => {
+            a.expand(m.boundingBox);
+            return a;
+        }, new CfgBoundingBox());
+        if (this._deferredMesh !== undefined) {
+            bb.expand(this._deferredMesh.boundingBox);
+        }
+        bb.applyMatrix(this.originalMatrix);
+        return bb;
+    }
+    addInspectorProperties() {
+        super.addInspectorProperties();
+        this.addInspectableCustomProperty({
+            label: "Detail level",
+            propertyName: "_detailLevel",
+            type: InspectableType.String,
+        });
+        this.addInspectableCustomProperty({
+            label: "Tag",
+            propertyName: "_tag",
+            type: InspectableType.String,
+        });
+        this.addInspectableCustomProperty({
+            label: "log symNode",
+            propertyName: "_inspectorLogSymNode",
+            type: InspectableType.Checkbox,
+        });
+    }
+    get _inspectorLogSymNode() {
+        return this._symNode === undefined;
+    }
+    set _inspectorLogSymNode(x) {
+        console.log(this._symNode);
+    }
+}

package/dist/nodes/CfgSymRootNode.d.ts

@@ -1,34 +1,34 @@
-import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { CfgMaterialMapping, RootNodeSource, Transform as ModelTransform } from "@configura/web-api";
-import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
-import { Logger } from "@configura/web-utilities";
-import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
-import { RenderEnv } from "../view/RenderEnv.js";
-import { CfgSymNode } from "./CfgSymNode.js";
-export declare function isSymRootNode(value: unknown): value is CfgSymRootNode;
-export declare class CfgSymRootNode extends CfgSymNode {
-    private _isForDebug;
-    _identifier: string;
-    static makeCfgSymRootFromRootNodeSource(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, rootNodeSource: RootNodeSource): Promise<CfgSymRootNode | undefined>;
-    static makeCfgSymRootFromUrl(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, symUrl: string, transform: ModelTransform | undefined): Promise<CfgSymRootNode | undefined>;
-    static makeCfgSymRootFromFile(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, file: File): Promise<CfgSymRootNode | undefined>;
-    get cfgClassName(): string;
-    static makeCfgSymRootFromSymNode(logger: Logger, renderEnvironment: RenderEnv, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
-    private _destroyed;
-    private _originalMatrixWithModelTransform;
-    private constructor();
-    get isForDebug(): boolean;
-    isSameIdentifierAndTransform(rootNodeSource: RootNodeSource): boolean;
-    destroy(): void;
-    isDestroyed(): boolean;
-    applyGeo(): void;
-    setMaterialsAndLoad(areasToMaterials: CfgMaterialMapping, animatorCoordinator?: CoordinatorWithMeta): Promise<void>;
-    applyMaterial(): void;
-    private _modelTransform?;
-    private get modelTransform();
-    private set modelTransform(value);
-    get originalMatrix(): Matrix;
-    protected addInspectorProperties(): void;
-    private get _inspectorIsForDebug();
-}
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { CfgMaterialMapping, RootNodeSource, Transform as ModelTransform } from "@configura/web-api";
+import { SymNode } from "@configura/web-core/dist/cm/format/cmsym/SymNode.js";
+import { Logger } from "@configura/web-utilities";
+import { CoordinatorWithMeta } from "../animation/coordinator/Coordinator.js";
+import { RenderEnv } from "../view/RenderEnv.js";
+import { CfgSymNode } from "./CfgSymNode.js";
+export declare function isSymRootNode(value: unknown): value is CfgSymRootNode;
+export declare class CfgSymRootNode extends CfgSymNode {
+    private _isForDebug;
+    _identifier: string;
+    static makeCfgSymRootFromRootNodeSource(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, rootNodeSource: RootNodeSource): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromUrl(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, symUrl: string, transform: ModelTransform | undefined): Promise<CfgSymRootNode | undefined>;
+    static makeCfgSymRootFromFile(logger: Logger, isForDebug: boolean, renderEnvironment: RenderEnv, file: File): Promise<CfgSymRootNode | undefined>;
+    get cfgClassName(): string;
+    static makeCfgSymRootFromSymNode(logger: Logger, renderEnvironment: RenderEnv, isForDebug: boolean, identifier: string, transform: ModelTransform | undefined, symNode: SymNode): Promise<CfgSymRootNode | undefined>;
+    private _destroyed;
+    private _originalMatrixWithModelTransform;
+    private constructor();
+    get isForDebug(): boolean;
+    isSameIdentifierAndTransform(rootNodeSource: RootNodeSource): boolean;
+    destroy(): void;
+    isDestroyed(): boolean;
+    applyGeo(): void;
+    setMaterialsAndLoad(areasToMaterials: CfgMaterialMapping, animatorCoordinator?: CoordinatorWithMeta): Promise<void>;
+    applyMaterial(): void;
+    private _modelTransform?;
+    private get modelTransform();
+    private set modelTransform(value);
+    get originalMatrix(): Matrix;
+    protected addInspectorProperties(): void;
+    private get _inspectorIsForDebug();
+}
 //# sourceMappingURL=CfgSymRootNode.d.ts.map