freeform-modeling-mcp 1.0.26

package/src/lib/gltf2obj/engine/model/meshinstance.js

@@ -0,0 +1,128 @@
+import { TransformMesh } from './meshutils.js';
+import { ModelObject3D } from './object.js';
+
+export class MeshInstanceId
+{
+    constructor (nodeId, meshIndex)
+    {
+        this.nodeId = nodeId;
+        this.meshIndex = meshIndex;
+    }
+
+    IsEqual (rhs)
+    {
+        return this.nodeId === rhs.nodeId && this.meshIndex === rhs.meshIndex;
+    }
+
+    GetKey ()
+    {
+        return this.nodeId.toString () + ':' + this.meshIndex.toString ();
+    }
+}
+
+export class MeshInstance extends ModelObject3D
+{
+    constructor (id, node, mesh)
+    {
+        super ();
+        this.id = id;
+        this.node = node;
+        this.mesh = mesh;
+    }
+
+    GetId ()
+    {
+        return this.id;
+    }
+
+    GetTransformation ()
+    {
+        return this.node.GetWorldTransformation ();
+    }
+
+    GetMesh ()
+    {
+        return this.mesh;
+    }
+
+    VertexCount ()
+    {
+        return this.mesh.VertexCount ();
+    }
+
+    VertexColorCount ()
+    {
+        return this.mesh.VertexColorCount ();
+    }
+
+    NormalCount ()
+    {
+        return this.mesh.NormalCount ();
+    }
+
+    TextureUVCount ()
+    {
+        return this.mesh.TextureUVCount ();
+    }
+
+    TriangleCount ()
+    {
+        return this.mesh.TriangleCount ();
+    }
+
+    EnumerateVertices (onVertex)
+    {
+        let transformation = this.node.GetWorldTransformation ();
+        if (transformation.IsIdentity ()) {
+            this.mesh.EnumerateVertices (onVertex);
+        } else {
+            this.mesh.EnumerateVertices ((vertex) => {
+                const transformed = transformation.TransformCoord3D (vertex);
+                onVertex (transformed);
+            });
+        }
+    }
+
+    EnumerateTriangleVertexIndices (onTriangleVertexIndices)
+    {
+        this.mesh.EnumerateTriangleVertexIndices (onTriangleVertexIndices);
+    }
+
+    EnumerateTriangleVertices (onTriangleVertices)
+    {
+        let transformation = this.node.GetWorldTransformation ();
+        if (transformation.IsIdentity ()) {
+            this.mesh.EnumerateTriangleVertices (onTriangleVertices);
+        } else {
+            this.mesh.EnumerateTriangleVertices ((v0, v1, v2) => {
+                const v0Transformed = transformation.TransformCoord3D (v0);
+                const v1Transformed = transformation.TransformCoord3D (v1);
+                const v2Transformed = transformation.TransformCoord3D (v2);
+                onTriangleVertices (v0Transformed, v1Transformed, v2Transformed);
+            });
+        }
+    }
+
+    PropertyGroupCount ()
+    {
+        return this.mesh.PropertyGroupCount ();
+    }
+
+    AddPropertyGroup (propertyGroup)
+    {
+        return this.mesh.AddPropertyGroup (propertyGroup);
+    }
+
+    GetPropertyGroup (index)
+    {
+        return this.mesh.GetPropertyGroup (index);
+    }
+
+    GetTransformedMesh ()
+    {
+        let transformation = this.node.GetWorldTransformation ();
+        let transformed = this.mesh.Clone ();
+        TransformMesh (transformed, transformation);
+        return transformed;
+    }
+}

package/src/lib/gltf2obj/engine/model/meshutils.js

@@ -0,0 +1,64 @@
+import { CrossVector3D, SubCoord3D } from '../geometry/coord3d.js';
+import { Transformation } from '../geometry/transformation.js';
+
+export const MeshType =
+{
+    Empty : 0,
+    TriangleMesh : 1
+};
+
+export function GetMeshType (mesh)
+{
+    if (mesh.TriangleCount () > 0) {
+        return MeshType.TriangleMesh;
+    }
+    return MeshType.Empty;
+}
+
+export function CalculateTriangleNormal (v0, v1, v2)
+{
+    let v = SubCoord3D (v1, v0);
+    let w = SubCoord3D (v2, v0);
+    let normal = CrossVector3D (v, w);
+    normal.Normalize ();
+    return normal;
+}
+
+export function TransformMesh (mesh, transformation)
+{
+    if (transformation.IsIdentity ()) {
+        return;
+    }
+
+    for (let i = 0; i < mesh.VertexCount (); i++) {
+        let vertex = mesh.GetVertex (i);
+        let transformed = transformation.TransformCoord3D (vertex);
+        vertex.x = transformed.x;
+        vertex.y = transformed.y;
+        vertex.z = transformed.z;
+    }
+
+    if (mesh.NormalCount () > 0) {
+        let normalMatrix = transformation.GetMatrix ().InvertTranspose ();
+        if (normalMatrix !== null) {
+            let normalTransformation = new Transformation (normalMatrix);
+            for (let i = 0; i < mesh.NormalCount (); i++) {
+                let normal = mesh.GetNormal (i);
+                let transformed = normalTransformation.TransformCoord3D (normal);
+                normal.x = transformed.x;
+                normal.y = transformed.y;
+                normal.z = transformed.z;
+            }
+        }
+    }
+}
+
+export function FlipMeshTrianglesOrientation (mesh)
+{
+    for (let i = 0; i < mesh.TriangleCount (); i++) {
+        let triangle = mesh.GetTriangle (i);
+        let tmp = triangle.v1;
+        triangle.v1 = triangle.v2;
+        triangle.v2 = tmp;
+    }
+}

package/src/lib/gltf2obj/engine/model/model.js

@@ -0,0 +1,195 @@
+import { MeshInstance, MeshInstanceId } from './meshinstance.js';
+import { Node } from './node.js';
+import { ModelObject3D } from './object.js';
+
+export class Model extends ModelObject3D
+{
+    constructor ()
+    {
+        super ();
+        this.root = new Node ();
+        this.materials = [];
+        this.meshes = [];
+    }
+
+    GetRootNode ()
+    {
+        return this.root;
+    }
+
+    MaterialCount ()
+    {
+        return this.materials.length;
+    }
+
+    MeshCount ()
+    {
+        return this.meshes.length;
+    }
+
+    MeshInstanceCount ()
+    {
+        let count = 0;
+        this.root.Enumerate ((node) => {
+            count += node.MeshIndexCount ();
+        });
+        return count;
+    }
+
+    VertexCount ()
+    {
+        let count = 0;
+        this.EnumerateMeshInstances ((meshInstance) => {
+            count += meshInstance.VertexCount ();
+        });
+        return count;
+    }
+
+    VertexColorCount ()
+    {
+        let count = 0;
+        this.EnumerateMeshInstances ((meshInstance) => {
+            count += meshInstance.VertexColorCount ();
+        });
+        return count;
+    }
+
+    NormalCount ()
+    {
+        let count = 0;
+        this.EnumerateMeshInstances ((meshInstance) => {
+            count += meshInstance.NormalCount ();
+        });
+        return count;
+    }
+
+    TextureUVCount ()
+    {
+        let count = 0;
+        this.EnumerateMeshInstances ((meshInstance) => {
+            count += meshInstance.TextureUVCount ();
+        });
+        return count;
+    }
+
+    TriangleCount ()
+    {
+        let count = 0;
+        this.EnumerateMeshInstances ((meshInstance) => {
+            count += meshInstance.TriangleCount ();
+        });
+        return count;
+    }
+
+    AddMaterial (material)
+    {
+        this.materials.push (material);
+        return this.materials.length - 1;
+    }
+
+    GetMaterial (index)
+    {
+        return this.materials[index];
+    }
+
+    AddMesh (mesh)
+    {
+        this.meshes.push (mesh);
+        return this.meshes.length - 1;
+    }
+
+    AddMeshToRootNode (mesh)
+    {
+        const meshIndex = this.AddMesh (mesh);
+        this.root.AddMeshIndex (meshIndex);
+        return meshIndex;
+    }
+
+    RemoveMesh (index)
+    {
+        this.meshes.splice (index, 1);
+        this.root.Enumerate ((node) => {
+            for (let i = 0; i < node.meshIndices.length; i++) {
+                if (node.meshIndices[i] === index) {
+                    node.meshIndices.splice (i, 1);
+                    i -= 1;
+                } else if (node.meshIndices[i] > index) {
+                    node.meshIndices[i] -= 1;
+                }
+            }
+        });
+    }
+
+    GetMesh (index)
+    {
+        return this.meshes[index];
+    }
+
+    GetMeshInstance (instanceId)
+    {
+        let foundNode = null;
+        this.root.Enumerate ((node) => {
+            if (node.GetId () === instanceId.nodeId) {
+                foundNode = node;
+            }
+        });
+        if (foundNode === null) {
+            return null;
+        }
+        const nodeMeshIndices = foundNode.GetMeshIndices ();
+        if (nodeMeshIndices.indexOf (instanceId.meshIndex) === -1) {
+            return null;
+        }
+        let foundMesh = this.GetMesh (instanceId.meshIndex);
+        let id = new MeshInstanceId (foundNode.GetId (), instanceId.meshIndex);
+        return new MeshInstance (id, foundNode, foundMesh);
+    }
+
+    EnumerateMeshes (onMesh)
+    {
+        for (const mesh of this.meshes) {
+            onMesh (mesh);
+        }
+    }
+
+    EnumerateMeshInstances (onMeshInstance)
+    {
+        this.root.Enumerate ((node) => {
+            for (let meshIndex of node.GetMeshIndices ()) {
+                let id = new MeshInstanceId (node.GetId (), meshIndex);
+                let mesh = this.GetMesh (meshIndex);
+                let meshInstance = new MeshInstance (id, node, mesh);
+                onMeshInstance (meshInstance);
+            }
+        });
+    }
+
+    EnumerateTransformedMeshes (onMesh)
+    {
+        this.EnumerateMeshInstances ((meshInstance) => {
+            const transformed = meshInstance.GetTransformedMesh ();
+            onMesh (transformed);
+        });
+    }
+
+    EnumerateVertices (onVertex)
+    {
+        this.EnumerateMeshInstances ((meshInstance) => {
+            meshInstance.EnumerateVertices (onVertex);
+        });
+    }
+
+    EnumerateTriangleVertexIndices (onTriangleVertexIndices)
+    {
+        this.EnumerateMeshInstances ((meshInstance) => {
+            meshInstance.EnumerateTriangleVertexIndices (onTriangleVertexIndices);
+        });
+    }
+
+    EnumerateTriangleVertices (onTriangleVertices)
+    {
+        this.EnumerateMeshInstances ((meshInstance) => {
+            meshInstance.EnumerateTriangleVertices (onTriangleVertices);
+        });
+    }
+}