lots of performance improvements, bug fixes and some new features

frontend/misc/distances.ts

@@ -1,16 +1,17 @@
 import {BufferAttribute, InterleavedBufferAttribute, Vector3} from 'three';
 import type {MObject3D} from "../tools/Selection.vue";
-import type { ModelScene } from '@google/model-viewer/lib/three-components/ModelScene';
+import type {ModelScene} from '@google/model-viewer/lib/three-components/ModelScene';
+import type {SelectionInfo} from "../tools/selection";
 
 
-function getCenterAndVertexList(obj: MObject3D, scene: ModelScene): {
+function getCenterAndVertexList(selInfo: SelectionInfo, scene: ModelScene): {
     center: Vector3,
     vertices: Array<Vector3>
 } {
-    obj.updateMatrixWorld();
-    let pos: BufferAttribute | InterleavedBufferAttribute = obj.geometry.getAttribute('position');
-    let ind: BufferAttribute | null = obj.geometry.index;
-    if (!ind) {
+    selInfo.object.updateMatrixWorld();
+    let pos: BufferAttribute | InterleavedBufferAttribute = selInfo.object.geometry.getAttribute('position');
+    let ind: BufferAttribute | null = selInfo.object.geometry.index;
+    if (ind === null) {
         ind = new BufferAttribute(new Uint16Array(pos.count), 1);
         for (let i = 0; i < pos.count; i++) {
             ind.array[i] = i;
@@ -18,14 +19,14 @@ function getCenterAndVertexList(obj: MObject3D, scene: ModelScene): {
     }
     let center = new Vector3();
     let vertices = [];
-    for (let i = 0; i < ind.count; i++) {
-        let index = ind.array[i];
+    for (let i = selInfo.indices[0]; i < selInfo.indices[1]; i++) {
+        let index = ind.getX(i)
         let vertex = new Vector3(pos.getX(index), pos.getY(index), pos.getZ(index));
-        vertex = scene.target.worldToLocal(obj.localToWorld(vertex));
+        vertex = scene.target.worldToLocal(selInfo.object.localToWorld(vertex));
         center.add(vertex);
         vertices.push(vertex);
     }
-    center = center.divideScalar(ind.count);
+    center = center.divideScalar(selInfo.indices[1] - selInfo.indices[0]);
     return {center, vertices};
 }
 
@@ -33,7 +34,7 @@ function getCenterAndVertexList(obj: MObject3D, scene: ModelScene): {
  * Given two THREE.Object3D objects, returns their closest and farthest vertices, and the geometric centers.
  * All of them are approximated and should not be used for precise calculations.
  */
-export function distances(a: MObject3D, b: MObject3D, scene: ModelScene): {
+export function distances(a: SelectionInfo, b: SelectionInfo, scene: ModelScene): {
     min: Array<Vector3>,
     center: Array<Vector3>,
     max: Array<Vector3>

frontend/misc/gltf.ts

@@ -1,4 +1,4 @@
-import {Document, Scene, type Transform, WebIO, Buffer} from "@gltf-transform/core";
+import {Buffer, Document, Scene, type Transform, WebIO} from "@gltf-transform/core";
 import {unpartition} from "@gltf-transform/functions";
 
 let io = new WebIO();
@@ -12,10 +12,16 @@ export let extrasNameValueHelpers = "__helpers";
  *
  * Remember to call mergeFinalize after all models have been merged (slower required operations).
  */
-export async function mergePartial(url: string, name: string, document: Document, networkFinished: () => void = () => {}): Promise<Document> {
+export async function mergePartial(url: string, name: string, document: Document, networkFinished: () => void = () => {
+}): Promise<Document> {
+    // Fetch the complete document from the network
+    // This could be done at the same time as the document is being processed, but I wanted better metrics
+    let response = await fetch(url);
+    let buffer = await response.arrayBuffer();
+    networkFinished();
+
     // Load the new document
-    let newDoc = await io.read(url);
-    networkFinished()
+    let newDoc = await io.readBinary(new Uint8Array(buffer));
 
     // Remove any previous model with the same name
     await document.transform(dropByName(name));

frontend/misc/helpers.ts

@@ -1,3 +1,5 @@
+// noinspection JSVoidFunctionReturnValueUsed,JSUnresolvedReference
+
 import {Document, type TypedArray} from '@gltf-transform/core'
 import {Vector2} from "three/src/math/Vector2.js"
 import {Vector3} from "three/src/math/Vector3.js"
@@ -26,7 +28,7 @@ function buildSimpleGltf(doc: Document, rawPositions: number[], rawIndices: numb
     if (rawColors) {
         colors = doc.createAccessor(name + 'Color')
             .setArray(new Float32Array(rawColors) as TypedArray)
-            .setType('VEC3')
+            .setType('VEC4')
             .setBuffer(buffer);
     }
     const material = doc.createMaterial(name + 'Material')
@@ -39,6 +41,11 @@ function buildSimpleGltf(doc: Document, rawPositions: number[], rawIndices: numb
     if (rawColors) {
         geometry.setAttribute('COLOR_0', colors)
     }
+    if (mode == WebGL2RenderingContext.TRIANGLES) {
+        geometry.setExtras({face_triangles_end: [rawIndices.length / 6, rawIndices.length * 2 / 6, rawIndices.length * 3 / 6, rawIndices.length * 4 / 6, rawIndices.length * 5 / 6, rawIndices.length]})
+    } else if (mode == WebGL2RenderingContext.LINES) {
+        geometry.setExtras({edge_points_end: [rawIndices.length / 3, rawIndices.length * 2 / 3, rawIndices.length]})
+    }
     const mesh = doc.createMesh(name + 'Mesh').addPrimitive(geometry)
     const node = doc.createNode(name + 'Node').setMesh(mesh).setMatrix(transform.elements as any)
     scene.addChild(node)
@@ -48,21 +55,19 @@ function buildSimpleGltf(doc: Document, rawPositions: number[], rawIndices: numb
  * Create a new Axes helper as a GLTF model, useful for debugging positions and orientations.
  */
 export function newAxes(doc: Document, size: Vector3, transform: Matrix4) {
+    let rawIndices = [0, 1, 2, 3, 4, 5];
     let rawPositions = [
-        [0, 0, 0, size.x, 0, 0],
-        [0, 0, 0, 0, size.y, 0],
-        [0, 0, 0, 0, 0, -size.z],
+        0, 0, 0, size.x, 0, 0,
+        0, 0, 0, 0, size.y, 0,
+        0, 0, 0, 0, 0, -size.z,
     ];
-    let rawIndices = [0, 1];
     let rawColors = [
-        [...(AxesColors.x[0]), ...(AxesColors.x[1])],
-        [...(AxesColors.y[0]), ...(AxesColors.y[1])],
-        [...(AxesColors.z[0]), ...(AxesColors.z[1])],
-    ].map(g => g.map(x => x / 255.0));
-    buildSimpleGltf(doc, rawPositions[0], rawIndices, rawColors[0], transform, '__helper_axes');
-    buildSimpleGltf(doc, rawPositions[1], rawIndices, rawColors[1], transform, '__helper_axes');
-    buildSimpleGltf(doc, rawPositions[2], rawIndices, rawColors[2], transform, '__helper_axes');
-    buildSimpleGltf(doc, [0, 0, 0], [0], null, transform, '__helper_axes', WebGL2RenderingContext.POINTS);
+        ...(AxesColors.x[0]), 255, ...(AxesColors.x[1]), 255,
+        ...(AxesColors.y[0]), 255, ...(AxesColors.y[1]), 255,
+        ...(AxesColors.z[0]), 255, ...(AxesColors.z[1]), 255
+    ].map(x => x / 255.0);
+    buildSimpleGltf(doc, rawPositions, rawIndices, rawColors, new Matrix4(), '__helper_axes'); // Axes at (0,0,0)!
+    buildSimpleGltf(doc, [0, 0, 0], [0], [1, 1, 1, 1], transform, '__helper_axes', WebGL2RenderingContext.POINTS);
 }
 
 /**
@@ -71,8 +76,10 @@ export function newAxes(doc: Document, size: Vector3, transform: Matrix4) {
  * The grid is built as a box of triangles (representing lines) looking to the inside of the box.
  * This ensures that only the back of the grid is always visible, regardless of the camera position.
  */
-export function newGridBox(doc: Document, size: Vector3, baseTransform: Matrix4 = new Matrix4(), divisions = 10) {
+export async function newGridBox(doc: Document, size: Vector3, baseTransform: Matrix4, divisions = 10) {
     // Create transformed positions for the inner faces of the box
+    let allPositions: number[] = [];
+    let allIndices: number[] = [];
     for (let axis of [new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, -1)]) {
         for (let positive of [1, -1]) {
             let offset = axis.clone().multiply(size.clone().multiplyScalar(0.5 * positive));
@@ -82,13 +89,25 @@ export function newGridBox(doc: Document, size: Vector3, baseTransform: Matrix4
             if (axis.x) size2.set(size.z, size.y);
             if (axis.y) size2.set(size.x, size.z);
             if (axis.z) size2.set(size.x, size.y);
-            let transform = baseTransform.clone().multiply(translation).multiply(rotation);
-            newGridPlane(doc, size2, transform, divisions);
+            let transform = new Matrix4().multiply(translation).multiply(rotation);
+            let [rawPositions, rawIndices] = newGridPlane(size2, divisions);
+            let baseIndex = allPositions.length / 3;
+            for (let i of rawIndices) {
+                allIndices.push(i + baseIndex);
+            }
+            // Apply transform to the positions before adding them to the list
+            for (let i = 0; i < rawPositions.length; i += 3) {
+                let pos = new Vector3(rawPositions[i], rawPositions[i + 1], rawPositions[i + 2]);
+                pos.applyMatrix4(transform);
+                allPositions.push(pos.x, pos.y, pos.z);
+            }
         }
     }
+    let colors = new Array(allPositions.length / 3 * 4).fill(1);
+    buildSimpleGltf(doc, allPositions, allIndices, colors, baseTransform, '__helper_grid', WebGL2RenderingContext.TRIANGLES);
 }
 
-export function newGridPlane(doc: Document, size: Vector2, transform: Matrix4 = new Matrix4(), divisions = 10, divisionWidth = 0.002) {
+export function newGridPlane(size: Vector2, divisions = 10, divisionWidth = 0.002): [number[], number[]] {
     const rawPositions = [];
     const rawIndices = [];
     // Build the grid as triangles
@@ -114,5 +133,5 @@ export function newGridPlane(doc: Document, size: Vector2, transform: Matrix4 =
         rawIndices.push(baseIndex2, baseIndex2 + 1, baseIndex2 + 2);
         rawIndices.push(baseIndex2, baseIndex2 + 2, baseIndex2 + 3);
     }
-    buildSimpleGltf(doc, rawPositions, rawIndices, null, transform, '__helper_grid', WebGL2RenderingContext.TRIANGLES);
+    return [rawPositions, rawIndices];
 }

frontend/misc/lines.ts

@@ -0,0 +1,55 @@
+import {BufferGeometry} from 'three/src/core/BufferGeometry.js';
+import {Vector2} from 'three/src/math/Vector2.js';
+
+// The following imports must be done dynamically to be able to import three.js separately (smaller bundle sizee)
+// import {LineSegments2} from "three/examples/jsm/lines/LineSegments2.js";
+// import {LineMaterial} from "three/examples/jsm/lines/LineMaterial.js";
+// import {LineSegmentsGeometry} from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+const LineSegments2Import = import('three/examples/jsm/lines/LineSegments2.js');
+const LineMaterialImport = import('three/examples/jsm/lines/LineMaterial.js');
+const LineSegmentsGeometryImport = import('three/examples/jsm/lines/LineSegmentsGeometry.js');
+
+export async function toLineSegments(bufferGeometry: BufferGeometry) {
+    const LineSegments2 = (await LineSegments2Import).LineSegments2;
+    const LineMaterial = (await LineMaterialImport).LineMaterial;
+    return new LineSegments2(await toLineSegmentsGeometry(bufferGeometry), new LineMaterial({
+        color: 0xffffffff,
+        vertexColors: true,
+        linewidth: 0.1, // mm
+        worldUnits: true,
+        resolution: new Vector2(1, 1), // Update resolution on resize!!!
+    }));
+}
+
+async function toLineSegmentsGeometry(bufferGeometry: BufferGeometry) {
+    const LineSegmentsGeometry = (await LineSegmentsGeometryImport).LineSegmentsGeometry;
+    const lg = new LineSegmentsGeometry();
+
+    const position = bufferGeometry.getAttribute('position');
+    const indexAttribute = bufferGeometry.index!!;
+    const positions = [];
+    for (let index = 0; index != indexAttribute.count; ++index) {
+        const i = indexAttribute.getX(index);
+        const x = position.getX(i);
+        const y = position.getY(i);
+        const z = position.getZ(i);
+        positions.push(x, y, z);
+    }
+    lg.setPositions(positions);
+
+    const colors = [];
+    const color = bufferGeometry.getAttribute('color');
+    if (color) {
+        for (let index = 0; index != indexAttribute.count; ++index) {
+            const i = indexAttribute.getX(index);
+            const r = color.getX(i);
+            const g = color.getY(i);
+            const b = color.getZ(i);
+            colors.push(r, g, b);
+        }
+        lg.setColors(colors);
+    }
+
+    lg.userData = bufferGeometry.userData;
+    return lg;
+}

frontend/misc/scene.ts

@@ -9,13 +9,15 @@ import {Matrix4} from "three/src/math/Matrix4.js"
 /** This class helps manage SceneManagerData. All methods are static to support reactivity... */
 export class SceneMgr {
     /** Loads a GLB model from a URL and adds it to the viewer or replaces it if the names match */
-    static async loadModel(sceneUrl: Ref<string>, document: Document, name: string, url: string, updateHelpers: boolean = true, reloadScene: boolean = true, networkFinished: () => void = () => {}): Promise<Document> {
+    static async loadModel(sceneUrl: Ref<string>, document: Document, name: string, url: string, updateHelpers: boolean = true, reloadScene: boolean = true): Promise<Document> {
         let loadStart = performance.now();
+        let loadNetworkEnd: number;
 
         // Start merging into the current document, replacing or adding as needed
-        document = await mergePartial(url, name, document, networkFinished);
+        document = await mergePartial(url, name, document, () => loadNetworkEnd = performance.now());
 
-        console.log("Model", name, "loaded in", performance.now() - loadStart, "ms");
+        console.log("Model", name, "loaded in", performance.now() - loadNetworkEnd!, "ms after",
+            loadNetworkEnd! - loadStart, "ms of transferring data (maybe building the object on the server)");
 
         if (updateHelpers) {
             // Reload the helpers to fit the new model

frontend/misc/settings.ts

@@ -12,6 +12,7 @@ export const settings = {
         // Websocket URLs automatically listen for new models from the python backend
         "dev+http://127.0.0.1:32323/"
     ],
+    loadHelpers: true,
     displayLoadingEveryMs: 1000, /* How often to display partially loaded models */
     monitorEveryMs: 100,
     monitorOpenTimeoutMs: 1000,