freeform-modeling-mcp 1.0.26

package/src/lib/gltf2obj/engine/export/exportermodel.js

@@ -0,0 +1,117 @@
+import { CopyObjectAttributes } from '../core/core.js';
+import { Transformation } from '../geometry/transformation.js';
+import { CalculateTriangleNormal, TransformMesh } from '../model/meshutils.js';
+
+export class ExporterSettings {
+    constructor(settings) {
+        this.transformation = new Transformation();
+        this.isMeshVisible = (meshInstanceId) => {
+            return true;
+        };
+
+        CopyObjectAttributes(settings, this);
+    }
+}
+
+export class ExporterModel {
+    boundingBox = {
+        min: { x: Infinity, y: Infinity, z: Infinity },
+        max: { x: -Infinity, y: -Infinity, z: -Infinity }
+    };
+
+    constructor(model, settings) {
+        this.model = model;
+        this.settings = settings || new ExporterSettings();
+    }
+
+    GetModel() {
+        return this.model;
+    }
+
+    MaterialCount() {
+        return this.model.MaterialCount();
+    }
+
+    GetMaterial(index) {
+        return this.model.GetMaterial(index);
+    }
+
+    VertexCount() {
+        let vertexCount = 0;
+        this.EnumerateMeshInstances((meshInstance) => {
+            vertexCount += meshInstance.VertexCount();
+        });
+        return vertexCount;
+    }
+
+    TriangleCount() {
+        let triangleCount = 0;
+        this.EnumerateMeshInstances((meshInstance) => {
+            triangleCount += meshInstance.TriangleCount();
+        });
+        return triangleCount;
+    }
+
+    MeshInstanceCount() {
+        let meshInstanceCount = 0;
+        this.EnumerateMeshInstances((meshInstance) => {
+            meshInstanceCount += 1;
+        });
+        return meshInstanceCount;
+    }
+
+    EnumerateMeshInstances(onMeshInstance) {
+        this.model.EnumerateMeshInstances((meshInstance) => {
+            if (this.settings.isMeshVisible(meshInstance.GetId())) {
+                onMeshInstance(meshInstance);
+            }
+        });
+    }
+
+    EnumerateTransformedMeshes(onMesh) {
+        this.EnumerateMeshInstances((meshInstance) => {
+            let transformation = meshInstance.GetTransformation();
+            if (!this.settings.transformation.IsIdentity()) {
+                transformation.Append(this.settings.transformation);
+            }
+
+            let mesh = meshInstance.GetMesh();
+            let transformed = mesh.Clone();
+            if (!transformation.IsIdentity()) {
+                TransformMesh(transformed, transformation);
+            }
+
+            onMesh(transformed);
+        });
+    }
+
+    EnumerateVerticesAndTriangles(callbacks) {
+        let transformedMeshes = [];
+        this.EnumerateTransformedMeshes((mesh) => {
+            transformedMeshes.push(mesh);
+        });
+
+        for (let mesh of transformedMeshes) {
+            mesh.EnumerateVertices((vertex) => {
+                callbacks.onVertex(vertex.x, vertex.y, vertex.z);
+            });
+        }
+
+        let vertexOffset = 0;
+        for (let mesh of transformedMeshes) {
+            mesh.EnumerateTriangleVertexIndices((v0, v1, v2) => {
+                callbacks.onTriangle(v0 + vertexOffset, v1 + vertexOffset, v2 + vertexOffset);
+            });
+            vertexOffset += mesh.VertexCount();
+        }
+    }
+
+    EnumerateTrianglesWithNormals(onTriangle) {
+        this.EnumerateTransformedMeshes((mesh) => {
+            mesh.EnumerateTriangleVertices((v0, v1, v2) => {
+                let normal = CalculateTriangleNormal(v0, v1, v2);
+                onTriangle(v0, v1, v2, normal);
+            });
+        });
+    }
+}

package/src/lib/gltf2obj/engine/export/exporterobj.js

@@ -0,0 +1,147 @@
+import { FileFormat, GetFileName } from '../io/fileutils.js';
+import { TextWriter } from '../io/textwriter.js';
+import { MaterialType } from '../model/material.js';
+import { ExportedFile, ExporterBase } from './exporterbase.js';
+
+export class ExporterObj extends ExporterBase {
+    constructor() {
+        super();
+    }
+
+    CanExport(format, extension) {
+        return format === FileFormat.Text && extension === 'obj';
+    }
+
+    ExportContent(exporterModel, format, files, onFinish) {
+        function WriteTexture(mtlWriter, keyword, texture, files) {
+            if (texture === null || !texture.IsValid()) {
+                return;
+            }
+            let fileName = GetFileName(texture.name);
+            mtlWriter.WriteArrayLine([keyword, fileName]);
+
+            let fileIndex = files.findIndex((file) => {
+                return file.GetName() === fileName;
+            });
+            if (fileIndex === -1) {
+                let textureFile = new ExportedFile(fileName);
+                textureFile.SetBufferContent(texture.buffer);
+                files.push(textureFile);
+            }
+        }
+
+        let mtlFile = new ExportedFile('model.mtl');
+        let objFile = new ExportedFile('model.obj');
+
+        files.push(mtlFile);
+        files.push(objFile);
+
+        let mtlWriter = new TextWriter();
+        mtlWriter.WriteLine(this.GetHeaderText());
+        for (let materialIndex = 0; materialIndex < exporterModel.MaterialCount(); materialIndex++) {
+            let material = exporterModel.GetMaterial(materialIndex);
+            mtlWriter.WriteArrayLine(['newmtl', this.GetExportedMaterialName(material.name)]);
+            mtlWriter.WriteArrayLine(['Kd', material.color.r / 255.0, material.color.g / 255.0, material.color.b / 255.0]);
+            mtlWriter.WriteArrayLine(['d', material.opacity]);
+            if (material.type === MaterialType.Phong) {
+                mtlWriter.WriteArrayLine(['Ka', material.ambient.r / 255.0, material.ambient.g / 255.0, material.ambient.b / 255.0]);
+                mtlWriter.WriteArrayLine(['Ks', material.specular.r / 255.0, material.specular.g / 255.0, material.specular.b / 255.0]);
+                mtlWriter.WriteArrayLine(['Ns', material.shininess * 1000.0]);
+            }
+            WriteTexture(mtlWriter, 'map_Kd', material.diffuseMap, files);
+            if (material.type === MaterialType.Phong) {
+                WriteTexture(mtlWriter, 'map_Ks', material.specularMap, files);
+            }
+            WriteTexture(mtlWriter, 'bump', material.bumpMap, files);
+        }
+        mtlFile.SetTextContent(mtlWriter.GetText());
+
+        // 初始化最小和最大坐标值
+        const boundingBox = {
+            min: { x: Infinity, y: Infinity, z: Infinity },
+            max: { x: -Infinity, y: -Infinity, z: -Infinity }
+        };
+
+        let objWriter = new TextWriter();
+        objWriter.WriteLine(this.GetHeaderText());
+        objWriter.WriteArrayLine(['mtllib', mtlFile.GetName()]);
+        let vertexOffset = 0;
+        let normalOffset = 0;
+        let uvOffset = 0;
+        let usedMaterialName = null;
+        exporterModel.EnumerateTransformedMeshes((mesh) => {
+            objWriter.WriteArrayLine(['g', this.GetExportedMeshName(mesh.GetName())]);
+            for (let vertexIndex = 0; vertexIndex < mesh.VertexCount(); vertexIndex++) {
+                let vertex = mesh.GetVertex(vertexIndex);
+
+                let z = vertex.z;
+                vertex.z = vertex.y;
+                vertex.y = z;
+
+                objWriter.WriteArrayLine(['v', vertex.x, vertex.y, vertex.z]);
+                // 更新包围盒
+                boundingBox.min.x = Math.min(boundingBox.min.x, vertex.x);
+                boundingBox.min.y = Math.min(boundingBox.min.y, vertex.y);
+                boundingBox.min.z = Math.min(boundingBox.min.z, vertex.z);
+
+                boundingBox.max.x = Math.max(boundingBox.max.x, vertex.x);
+                boundingBox.max.y = Math.max(boundingBox.max.y, vertex.y);
+                boundingBox.max.z = Math.max(boundingBox.max.z, vertex.z);
+            }
+
+            for (let normalIndex = 0; normalIndex < mesh.NormalCount(); normalIndex++) {
+                let normal = mesh.GetNormal(normalIndex);
+
+                let z = normal.z;
+                normal.z = normal.y;
+                normal.y = z;
+
+                objWriter.WriteArrayLine(['vn', normal.x, normal.y, normal.z]);
+            }
+            for (let textureUVIndex = 0; textureUVIndex < mesh.TextureUVCount(); textureUVIndex++) {
+                let uv = mesh.GetTextureUV(textureUVIndex);
+                uv.y = 1 + uv.y;
+                objWriter.WriteArrayLine(['vt', uv.x, uv.y]);
+            }
+            for (let triangleIndex = 0; triangleIndex < mesh.TriangleCount(); triangleIndex++) {
+                let triangle = mesh.GetTriangle(triangleIndex);
+                let v0 = triangle.v0 + vertexOffset + 1;
+                let v1 = triangle.v1 + vertexOffset + 1;
+                let v2 = triangle.v2 + vertexOffset + 1;
+                let n0 = triangle.n0 + normalOffset + 1;
+                let n1 = triangle.n1 + normalOffset + 1;
+                let n2 = triangle.n2 + normalOffset + 1;
+                if (triangle.mat !== null) {
+                    let material = exporterModel.GetMaterial(triangle.mat);
+                    let materialName = this.GetExportedMaterialName(material.name);
+                    if (materialName !== usedMaterialName) {
+                        objWriter.WriteArrayLine(['usemtl', materialName]);
+                        usedMaterialName = materialName;
+                    }
+                }
+                let u0 = '';
+                let u1 = '';
+                let u2 = '';
+                if (triangle.HasTextureUVs()) {
+                    u0 = triangle.u0 + uvOffset + 1;
+                    u1 = triangle.u1 + uvOffset + 1;
+                    u2 = triangle.u2 + uvOffset + 1;
+                }
+                objWriter.WriteArrayLine(['f', [v0, u0, n0].join('/'), [v1, u1, n1].join('/'), [v2, u2, n2].join('/')]);
+            }
+            vertexOffset += mesh.VertexCount();
+            normalOffset += mesh.NormalCount();
+            uvOffset += mesh.TextureUVCount();
+        });
+
+        objFile.SetTextContent(objWriter.GetText());
+
+        exporterModel.boundingBox = boundingBox;
+
+        onFinish();
+    }
+
+    GetHeaderText() {
+        return '# exported by koomaster-mcp';
+    }
+}

package/src/lib/gltf2obj/engine/geometry/box3d.js

@@ -0,0 +1,60 @@
+import { Coord3D } from './coord3d.js';
+
+export class Box3D
+{
+    constructor (min, max)
+    {
+        this.min = min;
+        this.max = max;
+    }
+
+    GetMin ()
+    {
+        return this.min;
+    }
+
+    GetMax ()
+    {
+        return this.max;
+    }
+
+    GetCenter ()
+    {
+        return new Coord3D (
+            (this.min.x + this.max.x) / 2.0,
+            (this.min.y + this.max.y) / 2.0,
+            (this.min.z + this.max.z) / 2.0
+        );
+    }
+}
+
+export class BoundingBoxCalculator3D
+{
+    constructor ()
+    {
+        this.box = new Box3D (
+            new Coord3D (Infinity, Infinity, Infinity),
+            new Coord3D (-Infinity, -Infinity, -Infinity)
+        );
+        this.isValid = false;
+    }
+
+    GetBox ()
+    {
+        if (!this.isValid) {
+            return null;
+        }
+        return this.box;
+    }
+
+    AddPoint (point)
+    {
+        this.box.min.x = Math.min (this.box.min.x, point.x);
+        this.box.min.y = Math.min (this.box.min.y, point.y);
+        this.box.min.z = Math.min (this.box.min.z, point.z);
+        this.box.max.x = Math.max (this.box.max.x, point.x);
+        this.box.max.y = Math.max (this.box.max.y, point.y);
+        this.box.max.z = Math.max (this.box.max.z, point.z);
+        this.isValid = true;
+    }
+}

package/src/lib/gltf2obj/engine/geometry/coord2d.js

@@ -0,0 +1,35 @@
+import { IsEqual } from './geometry.js';
+
+export class Coord2D
+{
+	constructor (x, y)
+	{
+		this.x = x;
+		this.y = y;
+	}
+
+	Clone ()
+	{
+		return new Coord2D (this.x, this.y);
+	}
+}
+
+export function CoordIsEqual2D (a, b)
+{
+	return IsEqual (a.x, b.x) && IsEqual (a.y, b.y);
+}
+
+export function AddCoord2D (a, b)
+{
+	return new Coord2D (a.x + b.x, a.y + b.y);
+}
+
+export function SubCoord2D (a, b)
+{
+	return new Coord2D (a.x - b.x, a.y - b.y);
+}
+
+export function CoordDistance2D (a, b)
+{
+	return Math.sqrt ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+}

package/src/lib/gltf2obj/engine/geometry/coord3d.js

@@ -0,0 +1,126 @@
+import { IsEqual } from './geometry.js';
+
+export class Coord3D
+{
+	constructor (x, y, z)
+	{
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+
+	Length ()
+	{
+		return Math.sqrt (this.x * this.x + this.y * this.y + this.z * this.z);
+	}
+
+	MultiplyScalar (scalar)
+	{
+		this.x *= scalar;
+		this.y *= scalar;
+		this.z *= scalar;
+		return this;
+	}
+
+	Normalize ()
+	{
+		let length = this.Length ();
+		if (length > 0.0) {
+			this.MultiplyScalar (1.0 / length);
+		}
+		return this;
+	}
+
+	Offset (direction, distance)
+	{
+		let normal = direction.Clone ().Normalize ();
+		this.x += normal.x * distance;
+		this.y += normal.y * distance;
+		this.z += normal.z * distance;
+		return this;
+	}
+
+	Rotate (axis, angle, origo)
+	{
+		let normal = axis.Clone ().Normalize ();
+
+		let u = normal.x;
+		let v = normal.y;
+		let w = normal.z;
+
+		let x = this.x - origo.x;
+		let y = this.y - origo.y;
+		let z = this.z - origo.z;
+
+		let si = Math.sin (angle);
+		let co = Math.cos (angle);
+		this.x = - u * (- u * x - v * y - w * z) * (1.0 - co) + x * co + (- w * y + v * z) * si;
+		this.y = - v * (- u * x - v * y - w * z) * (1.0 - co) + y * co + (w * x - u * z) * si;
+		this.z = - w * (- u * x - v * y - w * z) * (1.0 - co) + z * co + (- v * x + u * y) * si;
+
+		this.x += origo.x;
+		this.y += origo.y;
+		this.z += origo.z;
+		return this;
+	}
+
+	Clone ()
+	{
+		return new Coord3D (this.x, this.y, this.z);
+	}
+}
+
+export function CoordIsEqual3D (a, b)
+{
+	return IsEqual (a.x, b.x) && IsEqual (a.y, b.y) && IsEqual (a.z, b.z);
+}
+
+export function AddCoord3D (a, b)
+{
+	return new Coord3D (a.x + b.x, a.y + b.y, a.z + b.z);
+}
+
+export function SubCoord3D (a, b)
+{
+	return new Coord3D (a.x - b.x, a.y - b.y, a.z - b.z);
+}
+
+export function CoordDistance3D (a, b)
+{
+	return Math.sqrt ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) + (a.z - b.z) * (a.z - b.z));
+}
+
+export function DotVector3D (a, b)
+{
+	return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+export function VectorAngle3D (a, b)
+{
+	let aDirection = a.Clone ().Normalize ();
+	let bDirection = b.Clone ().Normalize ();
+	if (CoordIsEqual3D (aDirection, bDirection)) {
+		return 0.0;
+	}
+	let product = DotVector3D (aDirection, bDirection);
+	return Math.acos (product);
+}
+
+export function CrossVector3D (a, b)
+{
+	let result = new Coord3D (0.0, 0.0, 0.0);
+	result.x = a.y * b.z - a.z * b.y;
+	result.y = a.z * b.x - a.x * b.z;
+	result.z = a.x * b.y - a.y * b.x;
+	return result;
+}
+
+export function VectorLength3D (x, y, z)
+{
+	return Math.sqrt (x * x + y * y + z * z);
+}
+
+export function ArrayToCoord3D (arr)
+{
+	return new Coord3D (arr[0], arr[1], arr[2]);
+}

package/src/lib/gltf2obj/engine/geometry/coord4d.js

@@ -0,0 +1,15 @@
+export class Coord4D
+{
+	constructor (x, y, z, w)
+	{
+		this.x = x;
+		this.y = y;
+		this.z = z;
+        this.w = w;
+	}
+
+	Clone ()
+	{
+		return new Coord4D (this.x, this.y, this.z, this.w);
+	}
+}

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

@@ -0,0 +1,56 @@
+export const Eps = 0.00000001;
+export const BigEps = 0.0001;
+export const RadDeg = 57.29577951308232;
+export const DegRad = 0.017453292519943;
+
+export function IsZero (a)
+{
+	return Math.abs (a) < Eps;
+}
+
+export function IsLower (a, b)
+{
+	return b - a > Eps;
+}
+
+export function IsGreater (a, b)
+{
+	return a - b > Eps;
+}
+
+export function IsLowerOrEqual (a, b)
+{
+	return b - a > -Eps;
+}
+
+export function IsGreaterOrEqual (a, b)
+{
+	return a - b > -Eps;
+}
+
+export function IsEqual (a, b)
+{
+	return Math.abs (b - a) < Eps;
+}
+
+export function IsEqualEps (a, b, eps)
+{
+	return Math.abs (b - a) < eps;
+}
+
+export function IsPositive (a)
+{
+	return a > Eps;
+}
+
+export function IsNegative (a)
+{
+	return a < -Eps;
+}
+
+export const Direction =
+{
+	X : 1,
+	Y : 2,
+	Z : 3
+};