freeform-modeling-mcp 1.0.26

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

@@ -0,0 +1,102 @@
+import { IsLower } from '../geometry/geometry.js';
+import { PhongMaterial } from '../model/material.js';
+import { RGBColor, IntegerToHexString } from '../model/color.js';
+
+export function NameFromLine (line, startIndex, commentChar)
+{
+	let name = line.substring (startIndex);
+	let commentStart = name.indexOf (commentChar);
+	if (commentStart !== -1) {
+		name = name.substring (0, commentStart);
+	}
+	return name.trim ();
+}
+
+export function ParametersFromLine (line, commentChar)
+{
+	if (commentChar !== null) {
+		let commentStart = line.indexOf (commentChar);
+		if (commentStart !== -1) {
+			line = line.substring (0, commentStart).trim ();
+		}
+	}
+	return line.split (/\s+/u);
+}
+
+export function ReadLines (str, onLine)
+{
+	function LineFound (line, onLine)
+	{
+		let trimmed = line.trim ();
+		if (trimmed.length > 0) {
+			onLine (trimmed);
+		}
+	}
+
+	let cursor = 0;
+	let next = str.indexOf ('\n', cursor);
+	while (next !== -1) {
+		LineFound (str.substring (cursor, next), onLine);
+		cursor = next + 1;
+		next = str.indexOf ('\n', cursor);
+	}
+	LineFound (str.substring (cursor), onLine);
+}
+
+export function IsPowerOfTwo (x)
+{
+	return (x & (x - 1)) === 0;
+}
+
+export function NextPowerOfTwo (x)
+{
+	if (IsPowerOfTwo (x)) {
+		return x;
+	}
+	let npot = Math.pow (2, Math.ceil (Math.log (x) / Math.log (2)));
+	return parseInt (npot, 10);
+}
+
+export function UpdateMaterialTransparency (material)
+{
+	material.transparent = false;
+	if (IsLower (material.opacity, 1.0)) {
+		material.transparent = true;
+	}
+}
+
+export class ColorToMaterialConverter
+{
+	constructor (model)
+	{
+		this.model = model;
+		this.colorToMaterialIndex = new Map ();
+	}
+
+	GetMaterialIndex (r, g, b, a)
+	{
+		let colorKey =
+			IntegerToHexString (r) +
+			IntegerToHexString (g) +
+			IntegerToHexString (b);
+		let hasAlpha = (a !== undefined && a !== null);
+		if (hasAlpha) {
+			colorKey += IntegerToHexString (a);
+		}
+
+		if (this.colorToMaterialIndex.has (colorKey)) {
+			return this.colorToMaterialIndex.get (colorKey);
+		} else {
+            let material = new PhongMaterial ();
+            material.name = colorKey.toUpperCase ();
+            material.color = new RGBColor (r, g, b);
+            if (hasAlpha && a < 255) {
+                material.opacity = a / 255.0;
+                UpdateMaterialTransparency (material);
+            }
+            let materialIndex = this.model.AddMaterial (material);
+            this.colorToMaterialIndex.set (colorKey, materialIndex);
+            return materialIndex;
+		}
+	}
+}

package/src/lib/gltf2obj/engine/io/binaryreader.js

@@ -0,0 +1,93 @@
+export class BinaryReader {
+    constructor(arrayBuffer, isLittleEndian) {
+        this.arrayBuffer = arrayBuffer;
+
+        this.dataView = new DataView(arrayBuffer);
+        this.isLittleEndian = isLittleEndian;
+        this.position = 0;
+    }
+
+    GetPosition () {
+        return this.position;
+    }
+
+    SetPosition (position) {
+        this.position = position;
+    }
+
+    GetByteLength () {
+        return this.arrayBuffer.byteLength;
+    }
+
+    Skip (bytes) {
+        this.position = this.position + bytes;
+    }
+
+    End () {
+        return this.position >= this.arrayBuffer.byteLength;
+    }
+
+    ReadArrayBuffer (byteLength) {
+        let originalBufferView = new Uint8Array(this.arrayBuffer);
+        let arrayBuffer = new ArrayBuffer(byteLength);
+        let bufferView = new Uint8Array(arrayBuffer);
+        let subArray = originalBufferView.subarray(this.position, this.position + byteLength);
+        bufferView.set(subArray, 0);
+        this.position += byteLength;
+        return arrayBuffer;
+    }
+
+    ReadBoolean8 () {
+        let result = this.dataView.getInt8(this.position);
+        this.position = this.position + 1;
+        return result ? true : false;
+    }
+
+    ReadCharacter8 () {
+        let result = this.dataView.getInt8(this.position);
+        this.position = this.position + 1;
+        return result;
+    }
+
+    ReadUnsignedCharacter8 () {
+        let result = this.dataView.getUint8(this.position);
+        this.position = this.position + 1;
+        return result;
+    }
+
+    ReadInteger16 () {
+        let result = this.dataView.getInt16(this.position, this.isLittleEndian);
+        this.position = this.position + 2;
+        return result;
+    }
+
+    ReadUnsignedInteger16 () {
+        let result = this.dataView.getUint16(this.position, this.isLittleEndian);
+        this.position = this.position + 2;
+        return result;
+    }
+
+    ReadInteger32 () {
+        let result = this.dataView.getInt32(this.position, this.isLittleEndian);
+        this.position = this.position + 4;
+        return result;
+    }
+
+    ReadUnsignedInteger32 () {
+        let result = this.dataView.getUint32(this.position, this.isLittleEndian);
+        this.position = this.position + 4;
+        return result;
+    }
+
+    ReadFloat32 () {
+        let result = this.dataView.getFloat32(this.position, this.isLittleEndian);
+        this.position = this.position + 4;
+        return result;
+    }
+
+    ReadDouble64 () {
+        let result = this.dataView.getFloat64(this.position, this.isLittleEndian);
+        this.position = this.position + 8;
+        return result;
+    }
+}

package/src/lib/gltf2obj/engine/io/binarywriter.js

@@ -0,0 +1,92 @@
+export class BinaryWriter
+{
+    constructor (byteLength, isLittleEndian)
+    {
+        this.arrayBuffer = new ArrayBuffer (byteLength);
+        this.dataView = new DataView (this.arrayBuffer);
+        this.isLittleEndian = isLittleEndian;
+        this.position = 0;
+    }
+
+    GetPosition ()
+    {
+        return this.position;
+    }
+
+    SetPosition (position)
+    {
+        this.position = position;
+    }
+
+    End ()
+    {
+        return this.position >= this.arrayBuffer.byteLength;
+    }
+
+    GetBuffer ()
+    {
+        return this.arrayBuffer;
+    }
+
+    WriteArrayBuffer (arrayBuffer)
+    {
+        let bufferView = new Uint8Array (arrayBuffer);
+        let thisBufferView = new Uint8Array (this.arrayBuffer);
+        thisBufferView.set (bufferView, this.position);
+        this.position += arrayBuffer.byteLength;
+    }
+
+    WriteBoolean8 (val)
+    {
+        this.dataView.setInt8 (this.position, val ? 1 : 0);
+        this.position = this.position + 1;
+    }
+
+    WriteCharacter8 (val)
+    {
+        this.dataView.setInt8 (this.position, val);
+        this.position = this.position + 1;
+    }
+
+    WriteUnsignedCharacter8 (val)
+    {
+        this.dataView.setUint8 (this.position, val);
+        this.position = this.position + 1;
+    }
+
+    WriteInteger16 (val)
+    {
+        this.dataView.setInt16 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 2;
+    }
+
+    WriteUnsignedInteger16 (val)
+    {
+        this.dataView.setUint16 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 2;
+    }
+
+    WriteInteger32 (val)
+    {
+        this.dataView.setInt32 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 4;
+    }
+
+    WriteUnsignedInteger32 (val)
+    {
+        this.dataView.setUint32 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 4;
+    }
+
+    WriteFloat32 (val)
+    {
+        this.dataView.setFloat32 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 4;
+    }
+
+    WriteDouble64 (val)
+    {
+        this.dataView.setFloat64 (this.position, val, this.isLittleEndian);
+        this.position = this.position + 8;
+    }
+}

package/src/lib/gltf2obj/engine/io/bufferutils.js

@@ -0,0 +1,85 @@
+export function ArrayBufferToUtf8String (buffer) {
+	let decoder = new TextDecoder('utf-8');
+	return decoder.decode(buffer);
+}
+
+export function ArrayBufferToAsciiString (buffer) {
+	let text = '';
+	let bufferView = new Uint8Array(buffer);
+	for (let i = 0; i < bufferView.byteLength; i++) {
+		text += String.fromCharCode(bufferView[i]);
+	}
+	return text;
+}
+
+export function AsciiStringToArrayBuffer (str) {
+	let buffer = new ArrayBuffer(str.length);
+	let bufferView = new Uint8Array(buffer);
+	for (let i = 0; i < str.length; i++) {
+		bufferView[i] = str.charCodeAt(i);
+	}
+	return buffer;
+}
+
+export function Utf8StringToArrayBuffer (str) {
+	let encoder = new TextEncoder();
+	let uint8Array = encoder.encode(str);
+	return uint8Array.buffer;
+}
+
+export function Base64DataURIToArrayBuffer (uri) {
+	let dataPrefix = 'data:';
+	if (!uri.startsWith(dataPrefix)) {
+		return null;
+	}
+
+	let mimeSeparator = uri.indexOf(';');
+	if (mimeSeparator === -1) {
+		return null;
+	}
+
+	let bufferSeparator = uri.indexOf(',');
+	if (bufferSeparator === -1) {
+		return null;
+	}
+
+	let mimeType = uri.substring(dataPrefix.length, dataPrefix.length + mimeSeparator - 5);
+	let base64String = atob(uri.substring(bufferSeparator + 1));
+	let buffer = new ArrayBuffer(base64String.length);
+	let bufferView = new Uint8Array(buffer);
+	for (let i = 0; i < base64String.length; i++) {
+		bufferView[i] = base64String.charCodeAt(i);
+	}
+
+	return {
+		mimeType: mimeType,
+		buffer: buffer
+	};
+}
+
+export function GetFileExtensionFromMimeType (mimeType) {
+	if (mimeType === undefined || mimeType === null) {
+		return '';
+	}
+	let mimeParts = mimeType.split('/');
+	if (mimeParts.length === 0) {
+		return '';
+	}
+	return mimeParts[mimeParts.length - 1];
+}
+
+export function CreateObjectUrl (content) {
+	let blob = new Blob([content]);
+	let url = URL.createObjectURL(blob);
+	return url;
+}
+
+export function CreateObjectUrlWithMimeType (content, mimeType) {
+	let blob = new Blob([content], { type: mimeType });
+	let url = URL.createObjectURL(blob);
+	return url;
+}
+
+export function RevokeObjectUrl (url) {
+	URL.revokeObjectURL(url);
+}

package/src/lib/gltf2obj/engine/io/externallibs.js

@@ -0,0 +1,42 @@
+let externalLibLocation = null;
+let loadedExternalLibs = new Set ();
+
+export function SetExternalLibLocation (newExternalLibLocation)
+{
+    externalLibLocation = newExternalLibLocation;
+}
+
+export function GetExternalLibPath (libName)
+{
+    if (externalLibLocation === null) {
+        return null;
+    }
+    return externalLibLocation + '/' + libName;
+}
+
+export function LoadExternalLibrary (libName)
+{
+    return new Promise ((resolve, reject) => {
+        if (externalLibLocation === null) {
+            reject ();
+            return;
+        }
+
+        if (loadedExternalLibs.has (libName)) {
+            resolve ();
+            return;
+        }
+
+        let scriptElement = document.createElement ('script');
+        scriptElement.type = 'text/javascript';
+        scriptElement.src = GetExternalLibPath (libName);
+        scriptElement.onload = () => {
+            loadedExternalLibs.add (libName);
+            resolve ();
+        };
+        scriptElement.onerror = () => {
+            reject ();
+        };
+        document.head.appendChild (scriptElement);
+    });
+}

package/src/lib/gltf2obj/engine/io/fileutils.js

@@ -0,0 +1,120 @@
+import fs from 'fs';
+import axios from 'axios';
+
+export const FileSource =
+{
+	Url: 1,
+	File: 2,
+	Decompressed: 3
+};
+
+export const FileFormat =
+{
+	Text: 1,
+	Binary: 2
+};
+
+export function GetFileName(filePath) {
+	let firstSeparator = filePath.lastIndexOf('/');
+	if (firstSeparator === -1) {
+		firstSeparator = filePath.lastIndexOf('\\');
+	}
+	let fileName = filePath;
+	if (firstSeparator !== -1) {
+		fileName = filePath.substring(firstSeparator + 1);
+	}
+	let firstParamIndex = fileName.indexOf('?');
+	if (firstParamIndex !== -1) {
+		fileName = fileName.substring(0, firstParamIndex);
+	}
+	return decodeURI(fileName);
+}
+
+export function GetFileExtension(filePath) {
+	let fileName = GetFileName(filePath);
+	let firstPoint = fileName.lastIndexOf('.');
+	if (firstPoint === -1) {
+		return '';
+	}
+	let extension = fileName.substring(firstPoint + 1);
+	return extension.toLowerCase();
+}
+
+export function RequestUrl(url, onProgress) {
+	return new Promise((resolve, reject) => {
+		axios.get(url, {
+			responseType: 'arraybuffer',
+			onDownloadProgress: function (event) {
+				onProgress(event.loaded, event.total);
+			}
+		}).then(function (res) {
+			if (res.status == 200) {
+				const arrayBuffer = new ArrayBuffer(res.data.length);
+				var view = new Uint8Array(arrayBuffer);
+				view.set(res.data);
+				resolve(arrayBuffer);
+			} else {
+				reject();
+			}
+		}).catch(function (error) {
+			reject();
+		})
+	});
+}
+
+function toArrayBuffer(buf) {
+	var ab = new ArrayBuffer(buf.length);
+	var view = new Uint8Array(ab);
+	for (var i = 0; i < buf.length; ++i) {
+		view[i] = buf[i];
+	}
+	return ab;
+}
+
+export function ReadFile(src, onProgress) {
+	return new Promise((resolve, reject) => {
+		let readStream = fs.createReadStream(src)
+		let totalSize = fs.statSync(src).size
+		let curSize = 0
+		let arr = []
+		readStream.on('data', (chunk) => {
+			curSize += chunk.length
+			arr.push(chunk)
+			onProgress(curSize, totalSize);
+		})
+		readStream.on('end', () => {
+			resolve(Buffer.concat(arr, readStream.bytesRead))
+		})
+		readStream.on('error', (e) => {
+			reject();
+		})
+	});
+}
+
+export function TransformFileHostUrls(urls) {
+	for (let i = 0; i < urls.length; i++) {
+		let url = urls[i];
+		if (url.search(/www\.dropbox\.com/u) !== -1) {
+			url = url.replace('www.dropbox.com', 'dl.dropbox.com');
+			let separatorPos = url.indexOf('?');
+			if (separatorPos !== -1) {
+				url = url.substring(0, separatorPos);
+			}
+			urls[i] = url;
+		} else if (url.search(/github\.com/u) !== -1) {
+			url = url.replace('github.com', 'raw.githubusercontent.com');
+			url = url.replace('/blob', '');
+			let separatorPos = url.indexOf('?');
+			if (separatorPos !== -1) {
+				url = url.substring(0, separatorPos);
+			}
+			urls[i] = url;
+		}
+	}
+}
+
+export function IsUrl(str) {
+	const regex = /^https?:\/\/\S+$/g;
+	const match = str.match(regex);
+	return match !== null;
+}

package/src/lib/gltf2obj/engine/io/textwriter.js

@@ -0,0 +1,41 @@
+export class TextWriter
+{
+	constructor ()
+	{
+		this.text = '';
+		this.indentation = 0;
+	}
+
+	GetText ()
+	{
+		return this.text;
+	}
+
+	Indent (diff)
+	{
+		this.indentation += diff;
+	}
+
+	WriteArrayLine (arr)
+	{
+		this.WriteLine (arr.join (' '));
+	}
+
+	WriteLine (str)
+	{
+		this.WriteIndentation ();
+		this.Write (str + '\n');
+	}
+
+	WriteIndentation ()
+	{
+		for (let i = 0; i < this.indentation; i++) {
+			this.Write ('  ');
+		}
+	}
+
+	Write (str)
+	{
+		this.text += str;
+	}
+}

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

@@ -0,0 +1,19 @@
+
+import { ImportSettings, ImportError, ImportResult, ImporterFileAccessor, Importer, ImportErrorCode } from './import/importer.js';
+import { SetExternalLibLocation } from './io/externallibs.js';
+import { GetFileName, GetFileExtension, RequestUrl, ReadFile, TransformFileHostUrls, IsUrl, FileSource, FileFormat } from './io/fileutils.js';
+import { InputFile, ImporterFile, ImporterFileList, InputFilesFromUrls, InputFilesFromFileObjects } from './import/importerfiles.js';
+import { ThreeModelLoader } from './threejs/threemodelloader.js';
+import { Exporter } from './export/exporter.js';
+import { ExporterSettings } from './export/exportermodel.js';
+export {
+
+    ImportSettings, ImportError, ImportResult, ImporterFileAccessor, Importer, ImportErrorCode,
+    SetExternalLibLocation,
+    GetFileName, GetFileExtension, RequestUrl, ReadFile, TransformFileHostUrls, IsUrl, FileSource, FileFormat,
+    InputFile, ImporterFile, ImporterFileList, InputFilesFromUrls, InputFilesFromFileObjects,
+    ThreeModelLoader,
+    Exporter,
+    ExporterSettings
+
+}