freeform-modeling-mcp 1.0.26

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

@@ -0,0 +1,243 @@
+import { Coord2D, CoordIsEqual2D } from '../geometry/coord2d.js';
+import { IsEqual } from '../geometry/geometry.js';
+import { RGBColor, RGBColorIsEqual } from './color.js';
+
+export class TextureMap
+{
+    constructor ()
+    {
+        this.name = null;
+        this.mimeType = null;
+        this.buffer = null;
+        this.offset = new Coord2D (0.0, 0.0);
+        this.scale = new Coord2D (1.0, 1.0);
+        this.rotation = 0.0; // radians
+    }
+
+    IsValid ()
+    {
+        return this.name !== null && this.buffer !== null;
+    }
+
+    HasTransformation ()
+    {
+        if (!CoordIsEqual2D (this.offset, new Coord2D (0.0, 0.0))) {
+            return true;
+        }
+        if (!CoordIsEqual2D (this.scale, new Coord2D (1.0, 1.0))) {
+            return true;
+        }
+        if (!IsEqual (this.rotation, 0.0)) {
+            return true;
+        }
+        return false;
+    }
+
+    IsEqual (rhs)
+    {
+        if (this.name !== rhs.name) {
+            return false;
+        }
+        if (this.mimeType !== rhs.mimeType) {
+            return false;
+        }
+        if (!CoordIsEqual2D (this.offset, rhs.offset)) {
+            return false;
+        }
+        if (!CoordIsEqual2D (this.scale, rhs.scale)) {
+            return false;
+        }
+        if (!IsEqual (this.rotation, rhs.rotation)) {
+            return false;
+        }
+        return true;
+    }
+}
+
+export function TextureMapIsEqual (aTex, bTex)
+{
+    if (aTex === null && bTex === null) {
+        return true;
+    } else if (aTex === null || bTex === null) {
+        return false;
+    }
+    return aTex.IsEqual (bTex);
+}
+
+export const MaterialType =
+{
+    Phong : 1,
+    Physical : 2
+};
+
+export class MaterialBase
+{
+    constructor (type)
+    {
+        this.type = type;
+        this.isDefault = false;
+
+        this.name = '';
+        this.color = new RGBColor (0, 0, 0);
+
+        this.vertexColors = false;
+    }
+
+    IsEqual (rhs)
+    {
+        if (this.type !== rhs.type) {
+            return false;
+        }
+        if (this.isDefault !== rhs.isDefault) {
+            return false;
+        }
+        if (this.name !== rhs.name) {
+            return false;
+        }
+        if (!RGBColorIsEqual (this.color, rhs.color)) {
+            return false;
+        }
+        if (this.vertexColors !== rhs.vertexColors) {
+            return false;
+        }
+        return true;
+    }
+}
+
+export class FaceMaterial extends MaterialBase
+{
+    constructor (type)
+    {
+        super (type);
+
+        this.emissive = new RGBColor (0, 0, 0);
+
+        this.opacity = 1.0; // 0.0 .. 1.0
+        this.transparent = false;
+
+        this.diffuseMap = null;
+        this.bumpMap = null;
+        this.normalMap = null;
+        this.emissiveMap = null;
+
+        this.alphaTest = 0.0; // 0.0 .. 1.0
+        this.multiplyDiffuseMap = false;
+    }
+
+    IsEqual (rhs)
+    {
+        if (!super.IsEqual (rhs)) {
+            return false;
+        }
+        if (!RGBColorIsEqual (this.emissive, rhs.emissive)) {
+            return false;
+        }
+        if (!IsEqual (this.opacity, rhs.opacity)) {
+            return false;
+        }
+        if (this.transparent !== rhs.transparent) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.diffuseMap, rhs.diffuseMap)) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.bumpMap, rhs.bumpMap)) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.normalMap, rhs.normalMap)) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.emissiveMap, rhs.emissiveMap)) {
+            return false;
+        }
+        if (!IsEqual (this.alphaTest, rhs.alphaTest)) {
+            return false;
+        }
+        if (this.multiplyDiffuseMap !== rhs.multiplyDiffuseMap) {
+            return false;
+        }
+        return true;
+    }
+}
+
+export class PhongMaterial extends FaceMaterial
+{
+    constructor ()
+    {
+        super (MaterialType.Phong);
+
+        this.ambient = new RGBColor (0, 0, 0);
+        this.specular = new RGBColor (0, 0, 0);
+        this.shininess = 0.0; // 0.0 .. 1.0
+        this.specularMap = null;
+    }
+
+    IsEqual (rhs)
+    {
+        if (!super.IsEqual (rhs)) {
+            return false;
+        }
+        if (!RGBColorIsEqual (this.ambient, rhs.ambient)) {
+            return false;
+        }
+        if (!RGBColorIsEqual (this.specular, rhs.specular)) {
+            return false;
+        }
+        if (!IsEqual (this.shininess, rhs.shininess)) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.specularMap, rhs.specularMap)) {
+            return false;
+        }
+        return true;
+    }
+}
+
+export class PhysicalMaterial extends FaceMaterial
+{
+    constructor ()
+    {
+        super (MaterialType.Physical);
+
+        this.metalness = 0.0; // 0.0 .. 1.0
+        this.roughness = 1.0; // 0.0 .. 1.0
+        this.metalnessMap = null;
+    }
+
+    IsEqual (rhs)
+    {
+        if (!super.IsEqual (rhs)) {
+            return false;
+        }
+        if (!IsEqual (this.metalness, rhs.metalness)) {
+            return false;
+        }
+        if (!IsEqual (this.roughness, rhs.roughness)) {
+            return false;
+        }
+        if (!TextureMapIsEqual (this.metalnessMap, rhs.metalnessMap)) {
+            return false;
+        }
+        return true;
+    }
+}
+
+export function TextureIsEqual (a, b)
+{
+    if (a.name !== b.name) {
+        return false;
+    }
+    if (a.mimeType !== b.mimeType) {
+        return false;
+    }
+    if (!CoordIsEqual2D (a.offset, b.offset)) {
+        return false;
+    }
+    if (!CoordIsEqual2D (a.scale, b.scale)) {
+        return false;
+    }
+    if (!IsEqual (a.rotation, b.rotation)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,173 @@
+import { ModelObject3D } from './object.js';
+
+export class Mesh extends ModelObject3D
+{
+    constructor ()
+    {
+        super ();
+        this.vertices = [];
+        this.vertexColors = [];
+        this.normals = [];
+        this.uvs = [];
+        this.triangles = [];
+    }
+
+    VertexCount ()
+    {
+        return this.vertices.length;
+    }
+
+    VertexColorCount ()
+    {
+        return this.vertexColors.length;
+    }
+
+    NormalCount ()
+    {
+        return this.normals.length;
+    }
+
+    TextureUVCount ()
+    {
+        return this.uvs.length;
+    }
+
+    TriangleCount ()
+    {
+        return this.triangles.length;
+    }
+
+    AddVertex (vertex)
+    {
+        this.vertices.push (vertex);
+        return this.vertices.length - 1;
+    }
+
+    SetVertex (index, vertex)
+    {
+        this.vertices[index] = vertex;
+    }
+
+    GetVertex (index)
+    {
+        return this.vertices[index];
+    }
+
+    AddVertexColor (color)
+    {
+        this.vertexColors.push (color);
+        return this.vertexColors.length - 1;
+    }
+
+    SetVertexColor (index, color)
+    {
+        this.vertexColors[index] = color;
+    }
+
+    GetVertexColor (index)
+    {
+        return this.vertexColors[index];
+    }
+
+    AddNormal (normal)
+    {
+        this.normals.push (normal);
+        return this.normals.length - 1;
+    }
+
+SetNormal (index, normal)
+    {
+        this.normals[index] = normal;
+    }
+
+    GetNormal (index)
+    {
+        return this.normals[index];
+    }
+
+    AddTextureUV (uv)
+    {
+        this.uvs.push (uv);
+        return this.uvs.length - 1;
+    }
+
+    SetTextureUV (index, uv)
+    {
+        this.uvs[index] = uv;
+    }
+
+    GetTextureUV (index)
+    {
+        return this.uvs[index];
+    }
+
+    AddTriangle (triangle)
+    {
+        this.triangles.push (triangle);
+        return this.triangles.length - 1;
+    }
+
+    GetTriangle (index)
+    {
+        return this.triangles[index];
+    }
+
+    EnumerateVertices (onVertex)
+    {
+        for (const vertex of this.vertices) {
+            onVertex (vertex);
+        }
+    }
+
+    EnumerateTriangleVertexIndices (onTriangleVertexIndices)
+    {
+        for (const triangle of this.triangles) {
+            onTriangleVertexIndices (triangle.v0, triangle.v1, triangle.v2);
+        }
+    }
+
+    EnumerateTriangleVertices (onTriangleVertices)
+    {
+        for (const triangle of this.triangles) {
+            let v0 = this.vertices[triangle.v0];
+            let v1 = this.vertices[triangle.v1];
+            let v2 = this.vertices[triangle.v2];
+            onTriangleVertices (v0, v1, v2);
+        }
+    }
+
+    Clone ()
+    {
+        let cloned = new Mesh ();
+
+        cloned.SetName (this.GetName ());
+        this.CloneProperties (cloned);
+
+        for (let i = 0; i < this.VertexCount (); i++) {
+            let vertex = this.GetVertex (i);
+            cloned.AddVertex (vertex.Clone ());
+        }
+
+        for (let i = 0; i < this.VertexColorCount (); i++) {
+            let color = this.GetVertexColor (i);
+            cloned.AddVertexColor (color.Clone ());
+        }
+
+        for (let i = 0; i < this.NormalCount (); i++) {
+            let normal = this.GetNormal (i);
+            cloned.AddNormal (normal.Clone ());
+        }
+
+        for (let i = 0; i < this.TextureUVCount (); i++) {
+            let uv = this.GetTextureUV (i);
+            cloned.AddTextureUV (uv.Clone ());
+        }
+
+        for (let i = 0; i < this.TriangleCount (); i++) {
+            let triangle = this.GetTriangle (i);
+            cloned.AddTriangle (triangle.Clone ());
+        }
+
+        return cloned;
+    }
+}

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

@@ -0,0 +1,233 @@
+import { Coord2D, CoordIsEqual2D } from '../geometry/coord2d.js';
+import { CoordIsEqual3D } from '../geometry/coord3d.js';
+import { RGBColor, RGBColorIsEqual } from './color.js';
+
+export class MeshPrimitiveBuffer
+{
+    constructor ()
+    {
+        this.indices = [];
+        this.vertices = [];
+        this.colors = [];
+        this.normals = [];
+        this.uvs = [];
+        this.material = null;
+    }
+
+    GetBounds ()
+    {
+        let min = [Infinity, Infinity, Infinity];
+        let max = [-Infinity, -Infinity, -Infinity];
+        for (let i = 0; i < this.vertices.length / 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                min[j] = Math.min (min[j], this.vertices[i * 3 + j]);
+                max[j] = Math.max (max[j], this.vertices[i * 3 + j]);
+            }
+        }
+        return {
+            min : min,
+            max : max
+        };
+    }
+
+    GetByteLength (indexTypeSize, numberTypeSize)
+    {
+        let indexCount = this.indices.length;
+        let numberCount = this.vertices.length + this.colors.length + this.normals.length + this.uvs.length;
+        return indexCount * indexTypeSize + numberCount * numberTypeSize;
+    }
+}
+
+export class MeshBuffer
+{
+    constructor ()
+    {
+        this.primitives = [];
+    }
+
+    PrimitiveCount ()
+    {
+        return this.primitives.length;
+    }
+
+    GetPrimitive (index)
+    {
+        return this.primitives[index];
+    }
+
+    GetByteLength (indexTypeSize, numberTypeSize)
+    {
+        let byteLength = 0;
+        for (let i = 0; i < this.primitives.length; i++) {
+            let primitive = this.primitives[i];
+            byteLength += primitive.GetByteLength (indexTypeSize, numberTypeSize);
+        }
+        return byteLength;
+    }
+}
+
+export function ConvertMeshToMeshBuffer (mesh)
+{
+    function AddVertexToPrimitiveBuffer (mesh, indices, primitiveBuffer, meshVertexToPrimitiveVertices)
+    {
+        function GetColorOrDefault (mesh, colorIndex, forceColors)
+        {
+            if (colorIndex !== null) {
+                return mesh.GetVertexColor (colorIndex);
+            } else if (forceColors) {
+                return new RGBColor (0, 0, 0);
+            } else {
+                return null;
+            }
+        }
+
+        function GetUVOrDefault (mesh, uvIndex, forceUVs)
+        {
+            if (uvIndex !== null) {
+                return mesh.GetTextureUV (uvIndex);
+            } else if (forceUVs) {
+                return new Coord2D (0.0, 0.0);
+            } else {
+                return null;
+            }
+        }
+
+        function AddVertex (mesh, indices, primitiveBuffer)
+        {
+            let forceColors = mesh.VertexColorCount () > 0;
+            let forceUVs = mesh.TextureUVCount () > 0;
+
+            let vertex = mesh.GetVertex (indices.vertex);
+            let normal = mesh.GetNormal (indices.normal);
+
+            let primitiveVertexIndex = primitiveBuffer.vertices.length / 3;
+            primitiveBuffer.indices.push (primitiveVertexIndex);
+            primitiveBuffer.vertices.push (vertex.x, vertex.y, vertex.z);
+
+            let color = GetColorOrDefault (mesh, indices.color, forceColors);
+            if (color !== null) {
+                primitiveBuffer.colors.push (color.r / 255.0, color.g / 255.0, color.b / 255.0);
+            }
+
+            primitiveBuffer.normals.push (normal.x, normal.y, normal.z);
+
+            let uv = GetUVOrDefault (mesh, indices.uv, forceUVs);
+            if (uv !== null) {
+                primitiveBuffer.uvs.push (uv.x, uv.y);
+            }
+
+            return {
+                index : primitiveVertexIndex,
+                color : color,
+                normal : normal,
+                uv : uv
+            };
+        }
+
+        function FindMatchingPrimitiveVertex (mesh, primitiveVertices, indices)
+        {
+            function IsEqualColor (mesh, colorIndex, existingColor)
+            {
+                if (existingColor === null && colorIndex === null) {
+                    return true;
+                }
+                let color = GetColorOrDefault (mesh, colorIndex, true);
+                return RGBColorIsEqual (existingColor, color);
+            }
+
+            function IsEqualNormal (mesh, normalIndex, existingNormal)
+            {
+                let normal = mesh.GetNormal (normalIndex);
+                return CoordIsEqual3D (existingNormal, normal);
+            }
+
+            function IsEqualUV (mesh, uvIndex, existingUv)
+            {
+                if (existingUv === null && uvIndex === null) {
+                    return true;
+                }
+                let uv = GetUVOrDefault (mesh, uvIndex, true);
+                return CoordIsEqual2D (existingUv, uv);
+            }
+
+            for (let i = 0; i < primitiveVertices.length; i++) {
+                let primitiveVertex = primitiveVertices[i];
+                let equalColor = IsEqualColor (mesh, indices.color, primitiveVertex.color);
+                let equalNormal = IsEqualNormal (mesh, indices.normal, primitiveVertex.normal);
+                let equalUv = IsEqualUV (mesh, indices.uv, primitiveVertex.uv);
+                if (equalColor && equalNormal && equalUv) {
+                    return primitiveVertex;
+                }
+            }
+            return null;
+        }
+
+        if (meshVertexToPrimitiveVertices.has (indices.vertex)) {
+            let primitiveVertices = meshVertexToPrimitiveVertices.get (indices.vertex);
+            let existingPrimitiveVertex = FindMatchingPrimitiveVertex (mesh, primitiveVertices, indices);
+            if (existingPrimitiveVertex !== null) {
+                primitiveBuffer.indices.push (existingPrimitiveVertex.index);
+            } else {
+                let primitiveVertex = AddVertex (mesh, indices, primitiveBuffer);
+                primitiveVertices.push (primitiveVertex);
+            }
+        } else {
+            let primitiveVertex = AddVertex (mesh, indices, primitiveBuffer);
+            meshVertexToPrimitiveVertices.set (indices.vertex, [primitiveVertex]);
+        }
+    }
+
+    let meshBuffer = new MeshBuffer ();
+
+    let triangleCount = mesh.TriangleCount ();
+    if (triangleCount === 0) {
+        return null;
+    }
+
+    let triangleIndices = [];
+    for (let i = 0; i < triangleCount; i++) {
+        triangleIndices.push (i);
+    }
+    triangleIndices.sort ((a, b) => {
+        let aTriangle = mesh.GetTriangle (a);
+        let bTriangle = mesh.GetTriangle (b);
+        return aTriangle.mat - bTriangle.mat;
+    });
+
+    let primitiveBuffer = null;
+    let meshVertexToPrimitiveVertices = null;
+    for (let i = 0; i < triangleIndices.length; i++) {
+        let triangleIndex = triangleIndices[i];
+        let triangle = mesh.GetTriangle (triangleIndex);
+        if (primitiveBuffer === null || primitiveBuffer.material !== triangle.mat) {
+            primitiveBuffer = new MeshPrimitiveBuffer ();
+            primitiveBuffer.material = triangle.mat;
+            meshVertexToPrimitiveVertices = new Map ();
+            meshBuffer.primitives.push (primitiveBuffer);
+        }
+        let v0Indices = {
+            vertex : triangle.v0,
+            color : triangle.c0,
+            normal : triangle.n0,
+            uv : triangle.u0
+        };
+        let v1Indices = {
+            vertex : triangle.v1,
+            color : triangle.c1,
+            normal : triangle.n1,
+            uv : triangle.u1
+        };
+        let v2Indices = {
+            vertex : triangle.v2,
+            color : triangle.c2,
+            normal : triangle.n2,
+            uv : triangle.u2
+        };
+
+        AddVertexToPrimitiveBuffer (mesh, v0Indices, primitiveBuffer, meshVertexToPrimitiveVertices);
+        AddVertexToPrimitiveBuffer (mesh, v1Indices, primitiveBuffer, meshVertexToPrimitiveVertices);
+        AddVertexToPrimitiveBuffer (mesh, v2Indices, primitiveBuffer, meshVertexToPrimitiveVertices);
+    }
+
+    return meshBuffer;
+}