freeform-modeling-mcp 1.0.26

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

@@ -0,0 +1,63 @@
+import { Coord3D } from './coord3d.js';
+import { Coord4D } from './coord4d.js';
+import { Matrix, MatrixIsEqual } from './matrix.js';
+
+export class Transformation
+{
+    constructor (matrix)
+    {
+        if (matrix !== undefined && matrix !== null) {
+            this.matrix = matrix;
+        } else {
+            this.matrix = new Matrix ();
+            this.matrix.CreateIdentity ();
+        }
+    }
+
+    SetMatrix (matrix)
+    {
+        this.matrix = matrix;
+        return this;
+    }
+
+    GetMatrix ()
+    {
+        return this.matrix;
+    }
+
+    IsIdentity ()
+    {
+        return this.matrix.IsIdentity ();
+    }
+
+    AppendMatrix (matrix)
+    {
+        this.matrix = this.matrix.MultiplyMatrix (matrix);
+        return this;
+    }
+
+    Append (transformation)
+    {
+        this.AppendMatrix (transformation.GetMatrix ());
+        return this;
+    }
+
+    TransformCoord3D (coord)
+    {
+        let coord4D = new Coord4D (coord.x, coord.y, coord.z, 1.0);
+        let resultCoord4D = this.matrix.MultiplyVector (coord4D);
+        let result = new Coord3D (resultCoord4D.x, resultCoord4D.y, resultCoord4D.z);
+        return result;
+    }
+
+    Clone ()
+    {
+        const clonedMatrix = this.matrix.Clone ();
+        return new Transformation (clonedMatrix);
+    }
+}
+
+export function TransformationIsEqual (a, b)
+{
+    return MatrixIsEqual (a.GetMatrix (), b.GetMatrix ());
+}

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

@@ -0,0 +1,31 @@
+import { CoordDistance3D, SubCoord3D } from './coord3d.js';
+
+export function BezierTweenFunction (distance, index, count)
+{
+    let t = index / count;
+	return distance * (t * t * (3.0 - 2.0 * t));
+}
+
+export function LinearTweenFunction (distance, index, count)
+{
+    return index * distance / count;
+}
+
+export function ParabolicTweenFunction (distance, index, count)
+{
+    let t = index / count;
+    let t2 = t * t;
+    return distance * (t2 / (2.0 * (t2 - t) + 1.0));
+}
+
+export function TweenCoord3D (a, b, count, tweenFunc)
+{
+	let dir = SubCoord3D (b, a).Normalize ();
+	let distance = CoordDistance3D (a, b);
+	let result = [];
+	for (let i = 0; i < count; i++) {
+        let step = tweenFunc (distance, i, count - 1);
+		result.push (a.Clone ().Offset (dir, step));
+	}
+	return result;
+}

package/src/lib/gltf2obj/engine/import/importer.js

@@ -0,0 +1,270 @@
+import { RunTaskAsync } from '../core/taskrunner.js';
+import { FileSource, GetFileName } from '../io/fileutils.js';
+import { RGBColor } from '../model/color.js';
+import { ImporterFile, ImporterFileList } from './importerfiles.js';
+import { ImporterGltf } from './importergltf.js';
+
+import * as fflate from 'fflate';
+
+export class ImportSettings {
+    constructor() {
+        this.defaultColor = new RGBColor(200, 200, 200);
+    }
+}
+
+export const ImportErrorCode =
+{
+    NoImportableFile: 1,
+    FailedToLoadFile: 2,
+    ImportFailed: 3,
+    UnknownError: 4
+};
+
+export class ImportError {
+    constructor(code) {
+        this.code = code;
+        this.mainFile = null;
+        this.message = null;
+    }
+}
+
+export class ImportResult {
+    constructor() {
+        this.model = null;
+        this.mainFile = null;
+        this.upVector = null;
+        this.usedFiles = null;
+        this.missingFiles = null;
+    }
+}
+
+export class ImporterFileAccessor {
+    constructor(getBufferCallback) {
+        this.getBufferCallback = getBufferCallback;
+        this.fileBuffers = new Map();
+    }
+
+    GetFileBuffer (filePath) {
+        let fileName = GetFileName(filePath);
+        if (this.fileBuffers.has(fileName)) {
+            return this.fileBuffers.get(fileName);
+        }
+        let buffer = this.getBufferCallback(fileName);
+        this.fileBuffers.set(fileName, buffer);
+        return buffer;
+    }
+}
+
+export class Importer {
+    constructor() {
+        this.importers = [
+            new ImporterGltf(),
+        ];
+        this.fileList = new ImporterFileList();
+        this.model = null;
+        this.usedFiles = [];
+        this.missingFiles = [];
+    }
+
+    AddImporter (importer) {
+        this.importers.push(importer);
+    }
+
+    ImportFiles (inputFiles, settings, callbacks) {
+        callbacks.onLoadStart();
+        this.LoadFiles(inputFiles, {
+            onReady: () => {
+                callbacks.onImportStart();
+                this.DecompressArchives(this.fileList, () => {
+                    this.ImportLoadedFiles(settings, callbacks);
+                });
+                // RunTaskAsync(() => {
+
+                // });
+
+
+
+            },
+            onFileListProgress: callbacks.onFileListProgress,
+            onFileLoadProgress: callbacks.onFileLoadProgress
+        });
+    }
+
+    LoadFiles (inputFiles, callbacks) {
+        let newFileList = new ImporterFileList();
+        newFileList.FillFromInputFiles(inputFiles);
+
+        let reset = false;
+        if (this.HasImportableFile(newFileList)) {
+            reset = true;
+        } else {
+            let foundMissingFile = false;
+            for (let i = 0; i < this.missingFiles.length; i++) {
+                let missingFile = this.missingFiles[i];
+                if (newFileList.ContainsFileByPath(missingFile)) {
+                    foundMissingFile = true;
+                }
+            }
+            if (!foundMissingFile) {
+                reset = true;
+            } else {
+                this.fileList.ExtendFromFileList(newFileList);
+                reset = false;
+            }
+        }
+        if (reset) {
+            this.fileList = newFileList;
+        }
+        this.fileList.GetContent({
+            onReady: callbacks.onReady,
+            onFileListProgress: callbacks.onFileListProgress,
+            onFileLoadProgress: callbacks.onFileLoadProgress
+        });
+    }
+
+    ImportLoadedFiles (settings, callbacks) {
+        let importableFiles = this.GetImportableFiles(this.fileList);
+        if (importableFiles.length === 0) {
+            callbacks.onImportError(new ImportError(ImportErrorCode.NoImportableFile));
+            return;
+        }
+
+        if (importableFiles.length === 1 || !callbacks.onSelectMainFile) {
+            let mainFile = importableFiles[0];
+            this.ImportLoadedMainFile(mainFile, settings, callbacks);
+        } else {
+            let fileNames = importableFiles.map(importableFile => importableFile.file.name);
+            callbacks.onSelectMainFile(fileNames, (mainFileIndex) => {
+                if (mainFileIndex === null) {
+                    callbacks.onImportError(new ImportError(ImportErrorCode.NoImportableFile));
+                    return;
+                }
+                let mainFile = importableFiles[mainFileIndex];
+                this.ImportLoadedMainFile(mainFile, settings, callbacks);
+                // RunTaskAsync(() => {
+
+                // });
+            });
+        }
+    }
+
+    ImportLoadedMainFile (mainFile, settings, callbacks) {
+        if (mainFile === null || mainFile.file === null || mainFile.file.content === null) {
+            let error = new ImportError(ImportErrorCode.FailedToLoadFile);
+            if (mainFile !== null && mainFile.file !== null) {
+                error.mainFile = mainFile.file.name;
+            }
+            callbacks.onImportError(error);
+            return;
+        }
+
+        this.model = null;
+        this.usedFiles = [];
+        this.missingFiles = [];
+        this.usedFiles.push(mainFile.file.name);
+
+        let importer = mainFile.importer;
+        let fileAccessor = new ImporterFileAccessor((fileName) => {
+            let fileBuffer = null;
+            let file = this.fileList.FindFileByPath(fileName);
+            if (file === null || file.content === null) {
+                this.missingFiles.push(fileName);
+                fileBuffer = null;
+            } else {
+                this.usedFiles.push(fileName);
+                fileBuffer = file.content;
+            }
+            return fileBuffer;
+        });
+
+        importer.Import(mainFile.file.name, mainFile.file.extension, mainFile.file.content, {
+            getDefaultMaterialColor: () => {
+                return settings.defaultColor;
+            },
+            getFileBuffer: (filePath) => {
+                return fileAccessor.GetFileBuffer(filePath);
+            },
+            onSuccess: () => {
+                this.model = importer.GetModel();
+                let result = new ImportResult();
+                result.mainFile = mainFile.file.name;
+                result.model = this.model;
+                result.usedFiles = this.usedFiles;
+                result.missingFiles = this.missingFiles;
+                result.upVector = importer.GetUpDirection();
+                callbacks.onImportSuccess(result);
+            },
+            onError: () => {
+                let error = new ImportError(ImportErrorCode.ImportFailed);
+                error.mainFile = mainFile.file.name;
+                error.message = importer.GetErrorMessage();
+                callbacks.onImportError(error);
+            },
+            onComplete: () => {
+                importer.Clear();
+            }
+        });
+    }
+
+    DecompressArchives (fileList, onReady) {
+        let files = fileList.GetFiles();
+        let archives = [];
+        for (let file of files) {
+            if (file.extension === 'zip') {
+                archives.push(file);
+            }
+        }
+        if (archives.length === 0) {
+            onReady();
+            return;
+        }
+        for (let i = 0; i < archives.length; i++) {
+            const archiveFile = archives[i];
+            const archiveBuffer = new Uint8Array(archiveFile.content);
+            const decompressed = fflate.unzipSync(archiveBuffer);
+            for (const fileName in decompressed) {
+                if (Object.prototype.hasOwnProperty.call(decompressed, fileName)) {
+                    let file = new ImporterFile(fileName, FileSource.Decompressed, null);
+                    file.SetContent(decompressed[fileName].buffer);
+                    fileList.AddFile(file);
+                }
+            }
+        }
+        onReady();
+    }
+
+    GetFileList () {
+        return this.fileList;
+    }
+
+    HasImportableFile (fileList) {
+        let importableFiles = this.GetImportableFiles(fileList);
+        return importableFiles.length > 0;
+    }
+
+    GetImportableFiles (fileList) {
+        function FindImporter (file, importers) {
+            for (let importerIndex = 0; importerIndex < importers.length; importerIndex++) {
+                let importer = importers[importerIndex];
+                if (importer.CanImportExtension(file.extension)) {
+                    return importer;
+                }
+            }
+            return null;
+        }
+
+        let importableFiles = [];
+        let files = fileList.GetFiles();
+        for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+            let file = files[fileIndex];
+            let importer = FindImporter(file, this.importers);
+            if (importer !== null) {
+                importableFiles.push({
+                    file: file,
+                    importer: importer
+                });
+            }
+        }
+        return importableFiles;
+    }
+}

package/src/lib/gltf2obj/engine/import/importerbase.js

@@ -0,0 +1,115 @@
+import { Direction } from '../geometry/geometry.js';
+import { Model } from '../model/model.js';
+import { FinalizeModel } from '../model/modelfinalization.js';
+import { IsModelEmpty } from '../model/modelutils.js';
+
+export class ImporterBase
+{
+    constructor ()
+    {
+        this.name = null;
+        this.extension = null;
+        this.callbacks = null;
+        this.model = null;
+        this.error = null;
+        this.message = null;
+    }
+
+    Import (name, extension, content, callbacks)
+    {
+        this.Clear ();
+
+        this.name = name;
+        this.extension = extension;
+        this.callbacks = callbacks;
+        this.model = new Model ();
+        this.error = false;
+        this.message = null;
+        this.ResetContent ();
+        this.ImportContent (content, () => {
+            this.CreateResult (callbacks);
+        });
+    }
+
+    Clear ()
+    {
+        this.name = null;
+        this.extension = null;
+        this.callbacks = null;
+        this.model = null;
+        this.error = null;
+        this.message = null;
+        this.ClearContent ();
+    }
+
+    CreateResult (callbacks)
+    {
+        if (this.error) {
+            callbacks.onError ();
+            callbacks.onComplete ();
+            return;
+        }
+
+        if (IsModelEmpty (this.model)) {
+            this.SetError ('The model doesn\'t contain any meshes.');
+            callbacks.onError ();
+            callbacks.onComplete ();
+            return;
+        }
+
+        FinalizeModel (this.model, {
+            getDefaultMaterialColor : this.callbacks.getDefaultMaterialColor
+        });
+
+        callbacks.onSuccess ();
+        callbacks.onComplete ();
+    }
+
+    CanImportExtension (extension)
+    {
+        return false;
+    }
+
+    GetUpDirection ()
+    {
+        return Direction.Z;
+    }
+
+    ClearContent ()
+    {
+
+    }
+
+    ResetContent ()
+    {
+
+    }
+
+    ImportContent (fileContent, onFinish)
+    {
+
+    }
+
+    GetModel ()
+    {
+        return this.model;
+    }
+
+    SetError (message)
+    {
+        this.error = true;
+        if (message !== undefined && message !== null) {
+            this.message = message;
+        }
+    }
+
+    WasError ()
+    {
+        return this.error;
+    }
+
+    GetErrorMessage ()
+    {
+        return this.message;
+    }
+}

package/src/lib/gltf2obj/engine/import/importerfiles.js

@@ -0,0 +1,139 @@
+import { RunTasks } from '../core/taskrunner.js';
+import { FileSource, GetFileExtension, GetFileName, ReadFile, RequestUrl } from '../io/fileutils.js';
+
+export class InputFile {
+    constructor(name, source, data) {
+        this.name = name;
+        this.source = source;
+        this.data = data;
+    }
+}
+
+export function InputFilesFromUrls (urls) {
+    let inputFiles = [];
+    for (let url of urls) {
+        let fileName = GetFileName(url);
+        inputFiles.push(new InputFile(fileName, FileSource.Url, url));
+    }
+    return inputFiles;
+}
+
+export function InputFilesFromFileObjects (files) {
+    let inputFiles = [];
+    for (let url of files) {
+        let fileName = GetFileName(url);
+        inputFiles.push(new InputFile(fileName, FileSource.File, url));
+    }
+    return inputFiles;
+}
+
+export class ImporterFile {
+    constructor(name, source, data) {
+        this.name = name;// GetFileName(name);
+        this.extension = GetFileExtension(name);
+        this.source = source;
+        this.data = data;
+        this.content = null;
+    }
+
+    SetContent (content) {
+        this.content = content;
+    }
+}
+
+export class ImporterFileList {
+    constructor() {
+        this.files = [];
+    }
+
+    FillFromInputFiles (inputFiles) {
+        this.files = [];
+        for (let inputFile of inputFiles) {
+            let file = new ImporterFile(inputFile.name, inputFile.source, inputFile.data);
+            this.files.push(file);
+        }
+    }
+
+
+
+    ExtendFromFileList (fileList) {
+        let files = fileList.GetFiles();
+        for (let i = 0; i < files.length; i++) {
+            let file = files[i];
+            if (!this.ContainsFileByPath(file.name)) {
+                this.files.push(file);
+            }
+        }
+    }
+
+    GetFiles () {
+        return this.files;
+    }
+
+    GetContent (callbacks) {
+        RunTasks(this.files.length, {
+            runTask: (index, onTaskComplete) => {
+                callbacks.onFileListProgress(index, this.files.length);
+                this.GetFileContent(this.files[index], {
+                    onReady: onTaskComplete,
+                    onProgress: callbacks.onFileLoadProgress
+                });
+            },
+            onReady: callbacks.onReady
+        });
+    }
+
+    ContainsFileByPath (filePath) {
+        return this.FindFileByPath(filePath) !== null;
+    }
+
+    FindFileByPath (filePath) {
+        let fileName = GetFileName(filePath).toLowerCase();
+        for (let fileIndex = 0; fileIndex < this.files.length; fileIndex++) {
+            let file = this.files[fileIndex];
+            if (file.name.toLowerCase() === fileName) {
+                return file;
+            }
+        }
+        return null;
+    }
+
+    IsOnlyUrlSource () {
+        if (this.files.length === 0) {
+            return false;
+        }
+        for (let i = 0; i < this.files.length; i++) {
+            let file = this.files[i];
+            if (file.source !== FileSource.Url && file.source !== FileSource.Decompressed) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    AddFile (file) {
+        this.files.push(file);
+    }
+
+    GetFileContent (file, callbacks) {
+        if (file.content !== null) {
+            callbacks.onReady();
+            return;
+        }
+        let loaderPromise = null;
+        if (file.source === FileSource.Url) {
+            loaderPromise = RequestUrl(file.data, callbacks.onProgress);
+        } else if (file.source === FileSource.File) {
+            loaderPromise = ReadFile(file.data, callbacks.onProgress);
+        } else {
+            callbacks.onReady();
+            return;
+        }
+        loaderPromise.then((content) => {
+            file.SetContent(content);
+        }).catch(() => {
+        }).finally(() => {
+            callbacks.onReady();
+        });
+    }
+}