fluidcad 0.0.26 → 0.0.28

package/lib/dist/rendering/render.js

@@ -4,252 +4,227 @@ import { AxisObjectBase } from "../features/axis-renderable-base.js";
 import { Sketch } from "../features/2d/sketch.js";
 import { transformMeshes } from "./mesh-transform.js";
 import { ShapeOps } from "../oc/shape-ops.js";
-const meshBuilder = new MeshBuilder();
-function renderSceneObject(obj, scene, buildDurationMs) {
-    const hasError = !!obj.getError();
-    const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
-    const renderedSceneShapes = [];
-    if (sceneShapes.length) {
-        console.log(` - Scene shapes: ${sceneShapes.length}`);
-        for (const shape of sceneShapes) {
-            let meshes = shape.getMeshes();
-            if (!meshes) {
-                const meshSource = shape.getMeshSource();
-                if (meshSource) {
-                    let sourceMeshes = meshSource.shape.getMeshes();
-                    if (!sourceMeshes) {
-                        sourceMeshes = meshBuilder.build(meshSource.shape);
-                        meshSource.shape.setMeshes(sourceMeshes);
-                    }
-                    meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
-                }
-                else {
-                    meshes = meshBuilder.build(shape);
-                }
-                shape.setMeshes(meshes);
+export class SceneRenderer {
+    meshBuilder = new MeshBuilder();
+    render(scene) {
+        const sceneObjects = scene.getAllSceneObjects();
+        console.log("============ Rendering ==============", sceneObjects.length);
+        const skippedContainers = new Set();
+        const buildDurations = new Map();
+        for (const object of sceneObjects) {
+            // Skip descendants of cloned sketches — their edges are already
+            // computed by the parent sketch's clone-mode build.
+            const parent = object.getParent();
+            if (parent && skippedContainers.has(parent)) {
+                skippedContainers.add(object);
+                continue;
             }
-            const shapeType = shape.getType();
-            renderedSceneShapes.push({
-                shapeId: shape.id,
-                meshes,
-                shapeType,
-                isMetaShape: shape.isMetaShape() || undefined,
-                isGuide: shape.isGuideShape() || undefined,
-                metaType: shape.metaType || undefined,
-                metaData: shape.metaData || undefined,
-            });
-        }
-    }
-    let isVisible = !!sceneShapes.length;
-    if (obj.isAlwaysVisible()) {
-        isVisible = true;
-    }
-    else if (obj.isContainer()) {
-        const children = scene.getChildren(obj);
-        isVisible = children.some(child => {
-            const shapes = child.getOwnShapes();
-            return shapes.length > 0;
-        });
-    }
-    scene.addRenderedObject(obj, {
-        id: obj.id,
-        name: obj.getName(),
-        parentId: obj.parentId,
-        object: obj.serialize(),
-        sceneShapes: renderedSceneShapes,
-        type: obj.getType(),
-        uniqueType: obj.getUniqueType(),
-        fromCache: scene.isCached(obj),
-        visible: isVisible,
-        isContainer: obj.isContainer(),
-        hasError,
-        errorMessage: obj.getError() || undefined,
-        sourceLocation: obj.getSourceLocation() || undefined,
-        buildDurationMs,
-    });
-}
-export function renderSceneRollback(scene, rollbackIndex) {
-    console.log("============ Rollback Rendering ==============", rollbackIndex);
-    const scope = new Set();
-    const allObjects = scene.getAllSceneObjects();
-    for (let i = 0; i <= rollbackIndex && i < allObjects.length; i++) {
-        scope.add(allObjects[i]);
-    }
-    scene.clearRenderedObjects();
-    for (const obj of allObjects) {
-        const inScope = scope.has(obj);
-        if (inScope) {
-            const sceneShapes = obj.getOwnShapes({ excludeMeta: false }, scope);
-            const renderedSceneShapes = [];
-            for (const shape of sceneShapes) {
-                let meshes = shape.getMeshes();
-                if (!meshes) {
-                    const meshSource = shape.getMeshSource();
-                    if (meshSource) {
-                        let sourceMeshes = meshSource.shape.getMeshes();
-                        if (!sourceMeshes) {
-                            sourceMeshes = meshBuilder.build(meshSource.shape);
-                            meshSource.shape.setMeshes(sourceMeshes);
-                        }
-                        meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : meshBuilder.build(shape);
-                    }
-                    else {
-                        meshes = meshBuilder.build(shape);
-                    }
-                    shape.setMeshes(meshes);
-                }
-                renderedSceneShapes.push({
-                    shapeId: shape.id,
-                    meshes,
-                    shapeType: shape.getType(),
-                    isMetaShape: shape.isMetaShape() || undefined,
-                    isGuide: shape.isGuideShape() || undefined,
-                    metaType: shape.metaType || undefined,
-                    metaData: shape.metaData || undefined,
-                });
+            console.log("Rendering object:", object.getUniqueType());
+            if (!scene.isCached(object)) {
+                buildDurations.set(object, this.buildObject(object, scene));
+            }
+            // After building, mark cloned sketches so their children are skipped —
+            // the sketch's build() already populated them with transformed shapes.
+            if (object instanceof Sketch && object.getCloneSource()) {
+                skippedContainers.add(object);
             }
-            let isVisible = !!sceneShapes.length;
-            if (obj.isAlwaysVisible()) {
-                isVisible = true;
+        }
+        for (const object of sceneObjects) {
+            if (skippedContainers.has(object)) {
+                continue;
             }
-            else if (obj.isContainer()) {
-                const children = scene.getChildren(obj);
-                isVisible = children.some(child => {
-                    if (!scope.has(child))
-                        return false;
-                    const shapes = child.getOwnShapes({ excludeMeta: true }, scope);
-                    return shapes.length > 0;
+            object.clean(scene.getPartScopedAllObjects(object));
+        }
+        this.aggregateContainerDurations(sceneObjects, scene, buildDurations);
+        for (const object of sceneObjects) {
+            this.renderObject(object, scene, buildDurations.get(object));
+        }
+        return scene;
+    }
+    renderRollback(scene, rollbackIndex) {
+        console.log("============ Rollback Rendering ==============", rollbackIndex);
+        const allObjects = scene.getAllSceneObjects();
+        const scope = new Set();
+        for (let i = 0; i <= rollbackIndex && i < allObjects.length; i++) {
+            scope.add(allObjects[i]);
+        }
+        scene.clearRenderedObjects();
+        for (const obj of allObjects) {
+            if (!scope.has(obj)) {
+                this.emitRendered(obj, scene, {
+                    sceneShapes: [],
+                    visible: false,
+                    hasError: false,
+                    scope,
                 });
+                continue;
             }
-            scene.addRenderedObject(obj, {
-                id: obj.id,
-                name: obj.getName(),
-                parentId: obj.parentId,
-                object: obj.serialize(scope),
+            const sceneShapes = obj.getOwnShapes({ excludeMeta: false }, scope);
+            const renderedSceneShapes = sceneShapes.map(s => this.toRenderedShape(s));
+            this.emitRendered(obj, scene, {
                 sceneShapes: renderedSceneShapes,
-                type: obj.getType(),
-                uniqueType: obj.getUniqueType(),
-                fromCache: scene.isCached(obj),
-                visible: isVisible,
-                isContainer: obj.isContainer(),
+                visible: this.computeVisibility(obj, scene, sceneShapes.length, scope),
                 hasError: false,
-                sourceLocation: obj.getSourceLocation() || undefined,
+                scope,
             });
         }
-        else {
-            scene.addRenderedObject(obj, {
-                id: obj.id,
-                name: obj.getName(),
-                parentId: obj.parentId,
-                object: obj.serialize(scope),
-                sceneShapes: [],
-                type: obj.getType(),
-                uniqueType: obj.getUniqueType(),
-                fromCache: scene.isCached(obj),
+        const result = scene.getRenderedObjects();
+        console.table(result);
+        return scene;
+    }
+    renderObject(obj, scene, buildDurationMs) {
+        const sceneShapes = obj.getOwnShapes({ excludeMeta: false, excludeGuide: false });
+        const renderedSceneShapes = [];
+        try {
+            if (sceneShapes.length) {
+                console.log(` - Scene shapes: ${sceneShapes.length}`);
+                for (const shape of sceneShapes) {
+                    renderedSceneShapes.push(this.toRenderedShape(shape));
+                }
+            }
+            const errorMessage = obj.getError();
+            this.emitRendered(obj, scene, {
+                sceneShapes: renderedSceneShapes,
+                visible: this.computeVisibility(obj, scene, sceneShapes.length),
+                hasError: !!errorMessage,
+                errorMessage: errorMessage || undefined,
+                buildDurationMs,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error rendering object ${obj.getUniqueType()}:`, error);
+            this.emitRendered(obj, scene, {
+                sceneShapes: renderedSceneShapes,
                 visible: false,
-                isContainer: obj.isContainer(),
-                hasError: false,
-                sourceLocation: obj.getSourceLocation() || undefined,
+                hasError: true,
+                errorMessage: message,
+                buildDurationMs,
             });
         }
     }
-    const result = scene.getRenderedObjects();
-    console.table(result);
-    return scene;
-}
-export function renderScene(scene) {
-    const sceneObjects = scene.getAllSceneObjects();
-    console.log("============ Rendering ==============", sceneObjects.length);
-    const skippedContainers = new Set();
-    const buildDurations = new Map();
-    for (const object of sceneObjects) {
-        // Skip descendants of cloned sketches — their edges are already
-        // computed by the parent sketch's clone-mode build.
-        const parent = object.getParent();
-        if (parent && skippedContainers.has(parent)) {
-            skippedContainers.add(object);
-            continue;
-        }
-        console.log("Rendering object:", object.getUniqueType());
-        const isCached = scene.isCached(object);
-        if (!isCached) {
-            object.clearError();
-            const buildStart = performance.now();
-            try {
-                object.build({
-                    getSceneObjects() {
-                        return scene.getPartScopedObjectsUpTo(object);
-                    },
-                    getActiveSceneObjects() {
-                        return scene.getPartScopedActiveObjectsUpTo(object);
-                    },
-                    getSceneObjectsFromTo(from, to) {
-                        return scene.getSceneObjectsFromTo(from, to);
-                    },
-                    getTransform() {
-                        return object.getTransform();
-                    },
-                    getLastObject() {
-                        const objects = scene.getSceneObjectsUpTo(object);
-                        for (let i = objects.length - 1; i >= 0; i--) {
-                            const obj = objects[i];
-                            if (!(obj instanceof PlaneObjectBase) && !(obj instanceof AxisObjectBase)) {
-                                return obj;
-                            }
+    buildObject(object, scene) {
+        object.clearError();
+        const start = performance.now();
+        try {
+            object.build({
+                getSceneObjects: () => scene.getPartScopedObjectsUpTo(object),
+                getActiveSceneObjects: () => scene.getPartScopedActiveObjectsUpTo(object),
+                getSceneObjectsFromTo: (from, to) => scene.getSceneObjectsFromTo(from, to),
+                getTransform: () => object.getTransform(),
+                getLastObject: () => {
+                    const objects = scene.getSceneObjectsUpTo(object);
+                    for (let i = objects.length - 1; i >= 0; i--) {
+                        const obj = objects[i];
+                        if (!(obj instanceof PlaneObjectBase) && !(obj instanceof AxisObjectBase)) {
+                            return obj;
                         }
-                        return null;
-                    },
-                });
-                const appliedTransform = object.getAppliedTransform();
-                if (appliedTransform && !object.isContainer()) {
-                    const shapes = object.getAddedShapes();
-                    for (let i = 0; i < shapes.length; i++) {
-                        shapes[i] = ShapeOps.transform(shapes[i], appliedTransform);
                     }
+                    return null;
+                },
+            });
+            const appliedTransform = object.getAppliedTransform();
+            if (appliedTransform && !object.isContainer()) {
+                const shapes = object.getAddedShapes();
+                for (let i = 0; i < shapes.length; i++) {
+                    shapes[i] = ShapeOps.transform(shapes[i], appliedTransform);
                 }
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`Error building object ${object.getUniqueType()}:`, error);
-                object.setError(message);
-            }
-            buildDurations.set(object, performance.now() - buildStart);
         }
-        // After building, mark cloned sketches so their children are skipped —
-        // the sketch's build() already populated them with transformed shapes.
-        if (object instanceof Sketch && object.getCloneSource()) {
-            skippedContainers.add(object);
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error building object ${object.getUniqueType()}:`, error);
+            object.setError(message);
         }
+        return performance.now() - start;
     }
-    // Cleanup pass — let objects adjust based on final scene state
-    for (const object of sceneObjects) {
-        if (skippedContainers.has(object)) {
-            continue;
+    getOrBuildMeshes(shape) {
+        const existing = shape.getMeshes();
+        if (existing) {
+            return existing;
+        }
+        let meshes;
+        const meshSource = shape.getMeshSource();
+        if (meshSource) {
+            let sourceMeshes = meshSource.shape.getMeshes();
+            if (!sourceMeshes) {
+                sourceMeshes = this.meshBuilder.build(meshSource.shape);
+                meshSource.shape.setMeshes(sourceMeshes);
+            }
+            meshes = sourceMeshes ? transformMeshes(sourceMeshes, meshSource.matrix) : this.meshBuilder.build(shape);
         }
-        object.clean(scene.getPartScopedAllObjects(object));
+        else {
+            meshes = this.meshBuilder.build(shape);
+        }
+        shape.setMeshes(meshes);
+        return meshes;
+    }
+    toRenderedShape(shape) {
+        return {
+            shapeId: shape.id,
+            meshes: this.getOrBuildMeshes(shape),
+            shapeType: shape.getType(),
+            isMetaShape: shape.isMetaShape() || undefined,
+            isGuide: shape.isGuideShape() || undefined,
+            metaType: shape.metaType || undefined,
+            metaData: shape.metaData || undefined,
+        };
     }
-    // Roll up container durations: include own build time plus all descendants.
-    // Iterate in reverse so nested containers are aggregated before their parents.
-    for (let i = sceneObjects.length - 1; i >= 0; i--) {
-        const object = sceneObjects[i];
-        if (!object.isContainer()) {
-            continue;
+    computeVisibility(obj, scene, ownShapeCount, scope) {
+        if (obj.isAlwaysVisible()) {
+            return true;
         }
-        const own = buildDurations.get(object);
-        if (own === undefined) {
-            continue;
+        if (obj.isContainer()) {
+            const children = scene.getChildren(obj);
+            return children.some(child => {
+                if (scope && !scope.has(child)) {
+                    return false;
+                }
+                const shapes = scope
+                    ? child.getOwnShapes({ excludeMeta: true }, scope)
+                    : child.getOwnShapes();
+                return shapes.length > 0;
+            });
         }
-        let total = own;
-        for (const child of scene.getChildren(object)) {
-            const childDuration = buildDurations.get(child);
-            if (childDuration !== undefined) {
-                total += childDuration;
+        return ownShapeCount > 0;
+    }
+    aggregateContainerDurations(sceneObjects, scene, durations) {
+        for (let i = sceneObjects.length - 1; i >= 0; i--) {
+            const object = sceneObjects[i];
+            if (!object.isContainer()) {
+                continue;
+            }
+            const own = durations.get(object);
+            if (own === undefined) {
+                continue;
+            }
+            let total = own;
+            for (const child of scene.getChildren(object)) {
+                const childDuration = durations.get(child);
+                if (childDuration !== undefined) {
+                    total += childDuration;
+                }
             }
+            durations.set(object, total);
         }
-        buildDurations.set(object, total);
     }
-    for (const object of sceneObjects) {
-        renderSceneObject(object, scene, buildDurations.get(object));
+    emitRendered(obj, scene, opts) {
+        const rendered = {
+            id: obj.id,
+            name: obj.getName(),
+            parentId: obj.parentId,
+            object: obj.serialize(opts.scope),
+            sceneShapes: opts.sceneShapes,
+            type: obj.getType(),
+            uniqueType: obj.getUniqueType(),
+            fromCache: scene.isCached(obj),
+            visible: opts.visible,
+            isContainer: obj.isContainer(),
+            hasError: opts.hasError,
+            errorMessage: opts.errorMessage,
+            sourceLocation: obj.getSourceLocation() || undefined,
+            buildDurationMs: opts.buildDurationMs,
+        };
+        scene.addRenderedObject(obj, rendered);
     }
-    return scene;
 }

package/lib/dist/scene-manager.d.ts

@@ -1,4 +1,5 @@
 import { Scene } from "./rendering/scene.js";
+import { SceneRenderer } from "./rendering/render.js";
 import type { ExportOptions } from "./io/file-export.js";
 import type { ShapeProperties } from "./oc/props.js";
 import type { FaceProperties } from "./oc/face-props.js";
@@ -8,6 +9,7 @@ declare class SceneManager {
     rootPath: string;
     currentScene: Scene;
     currentFile: string;
+    renderer: SceneRenderer;
     constructor(rootPath: string);
     setCurrentFile(filePath: string): void;
     startScene(): Scene;

package/lib/dist/scene-manager.js

@@ -1,5 +1,5 @@
 import { Scene } from "./rendering/scene.js";
-import { renderScene, renderSceneRollback } from "./rendering/render.js";
+import { SceneRenderer } from "./rendering/render.js";
 import { SceneCompare } from "./rendering/scene-compare.js";
 import { FileImport } from "./io/file-import.js";
 import { FileExport } from "./io/file-export.js";
@@ -12,6 +12,7 @@ class SceneManager {
     rootPath;
     currentScene = new Scene();
     currentFile = '';
+    renderer = new SceneRenderer();
     constructor(rootPath) {
         this.rootPath = rootPath;
     }
@@ -24,10 +25,10 @@ class SceneManager {
         return this.currentScene;
     }
     renderScene(scene) {
-        return renderScene(scene);
+        return this.renderer.render(scene);
     }
     rollbackScene(scene, rollbackIndex) {
-        return renderSceneRollback(scene, rollbackIndex);
+        return this.renderer.renderRollback(scene, rollbackIndex);
     }
     compare(previous, current) {
         return SceneCompare.compare(previous, current);

package/lib/dist/tests/common/scene-object-history.test.d.ts

@@ -0,0 +1 @@
+export {};