@womp/mesh-editor 0.1.0

package/dist/browser/src/mesh_editor/sculpt_normal_workers.d.ts

@@ -0,0 +1,27 @@
+interface SculptNormalBuffers {
+    positions: Float32Array;
+    indices: Uint16Array | Uint32Array | null;
+    triangleOffsets: Uint32Array;
+    triangleIndices: Uint32Array;
+    triangleNormals: Float32Array;
+    normals: Float32Array;
+    triangleCapacity: number;
+    vertexCapacity: number;
+}
+export declare class SculptNormalWorkerPool {
+    private readonly workers;
+    private readonly source;
+    private readonly positions;
+    private readonly triangleNormals;
+    private readonly normals;
+    private readonly taskTriangles;
+    private readonly taskVertices;
+    private readonly pendingTasks;
+    private nextTaskId;
+    constructor(buffers: SculptNormalBuffers, workerCount: number);
+    get worker_count(): number;
+    private run_phase;
+    refresh(affectedTriangles: number[], affectedVertices: number[]): Promise<void>;
+    dispose(): void;
+}
+export {};

package/dist/browser/src/mesh_editor/sculpt_normal_workers.js

@@ -0,0 +1,138 @@
+function shared_uint32_array(length) {
+    return new Uint32Array(new SharedArrayBuffer(length * Uint32Array.BYTES_PER_ELEMENT));
+}
+function shared_float32_copy(source) {
+    const copy = new Float32Array(new SharedArrayBuffer(source.byteLength));
+    copy.set(source);
+    return copy;
+}
+function shared_uint32_copy(source) {
+    const copy = shared_uint32_array(source.length);
+    copy.set(source);
+    return copy;
+}
+function shared_index_copy(source) {
+    if (source === null) {
+        return null;
+    }
+    if (source instanceof Uint16Array) {
+        const copy = new Uint16Array(new SharedArrayBuffer(source.byteLength));
+        copy.set(source);
+        return copy;
+    }
+    return shared_uint32_copy(source);
+}
+export class SculptNormalWorkerPool {
+    workers;
+    source;
+    positions;
+    triangleNormals;
+    normals;
+    taskTriangles;
+    taskVertices;
+    pendingTasks;
+    nextTaskId;
+    constructor(buffers, workerCount) {
+        this.workers = [];
+        this.source = buffers;
+        this.positions = shared_float32_copy(buffers.positions);
+        this.triangleNormals = shared_float32_copy(buffers.triangleNormals);
+        this.normals = shared_float32_copy(buffers.normals);
+        const indices = shared_index_copy(buffers.indices);
+        const triangleOffsets = shared_uint32_copy(buffers.triangleOffsets);
+        const triangleIndices = shared_uint32_copy(buffers.triangleIndices);
+        this.taskTriangles = shared_uint32_array(buffers.triangleCapacity);
+        this.taskVertices = shared_uint32_array(buffers.vertexCapacity);
+        this.pendingTasks = new Map();
+        this.nextTaskId = 1;
+        for (let workerIndex = 0; workerIndex < workerCount; workerIndex += 1) {
+            const worker = new Worker(new URL("./sculpt_normal_worker.js", import.meta.url), { type: "module" });
+            worker.onmessage = (event) => {
+                const taskId = Number(event.data?.taskId);
+                const pending = this.pendingTasks.get(taskId);
+                if (pending === undefined) {
+                    return;
+                }
+                pending.remaining -= 1;
+                if (pending.remaining === 0) {
+                    this.pendingTasks.delete(taskId);
+                    pending.resolve();
+                }
+            };
+            worker.onerror = (event) => {
+                const error = new Error(event.message || "Sculpt normal worker failed.");
+                for (const pending of this.pendingTasks.values()) {
+                    pending.reject(error);
+                }
+                this.pendingTasks.clear();
+            };
+            worker.postMessage({
+                type: "configure",
+                positions: this.positions.buffer,
+                indices: indices?.buffer ?? null,
+                indexBytes: indices?.BYTES_PER_ELEMENT ?? 0,
+                triangleOffsets: triangleOffsets.buffer,
+                triangleIndices: triangleIndices.buffer,
+                triangleNormals: this.triangleNormals.buffer,
+                normals: this.normals.buffer,
+                taskTriangles: this.taskTriangles.buffer,
+                taskVertices: this.taskVertices.buffer,
+            });
+            this.workers.push(worker);
+        }
+    }
+    get worker_count() {
+        return this.workers.length;
+    }
+    run_phase(phase, itemCount) {
+        if (itemCount === 0 || this.workers.length === 0) {
+            return Promise.resolve();
+        }
+        const activeWorkerCount = Math.min(this.workers.length, itemCount);
+        const taskId = this.nextTaskId;
+        this.nextTaskId += 1;
+        return new Promise((resolve, reject) => {
+            this.pendingTasks.set(taskId, { remaining: activeWorkerCount, resolve, reject });
+            for (let workerIndex = 0; workerIndex < activeWorkerCount; workerIndex += 1) {
+                const start = Math.floor(itemCount * workerIndex / activeWorkerCount);
+                const end = Math.floor(itemCount * (workerIndex + 1) / activeWorkerCount);
+                this.workers[workerIndex].postMessage({ type: "run", taskId, phase, start, end });
+            }
+        });
+    }
+    async refresh(affectedTriangles, affectedVertices) {
+        for (const vertexIndex of affectedVertices) {
+            const offset = vertexIndex * 3;
+            this.positions[offset + 0] = this.source.positions[offset + 0];
+            this.positions[offset + 1] = this.source.positions[offset + 1];
+            this.positions[offset + 2] = this.source.positions[offset + 2];
+        }
+        this.taskTriangles.set(affectedTriangles);
+        this.taskVertices.set(affectedVertices);
+        await this.run_phase("triangles", affectedTriangles.length);
+        await this.run_phase("vertices", affectedVertices.length);
+        for (const triangleIndex of affectedTriangles) {
+            const offset = triangleIndex * 3;
+            this.source.triangleNormals[offset + 0] = this.triangleNormals[offset + 0];
+            this.source.triangleNormals[offset + 1] = this.triangleNormals[offset + 1];
+            this.source.triangleNormals[offset + 2] = this.triangleNormals[offset + 2];
+        }
+        for (const vertexIndex of affectedVertices) {
+            const offset = vertexIndex * 3;
+            this.source.normals[offset + 0] = this.normals[offset + 0];
+            this.source.normals[offset + 1] = this.normals[offset + 1];
+            this.source.normals[offset + 2] = this.normals[offset + 2];
+        }
+    }
+    dispose() {
+        const error = new Error("Sculpt normal worker pool was disposed.");
+        for (const pending of this.pendingTasks.values()) {
+            pending.reject(error);
+        }
+        this.pendingTasks.clear();
+        for (const worker of this.workers) {
+            worker.terminate();
+        }
+        this.workers.length = 0;
+    }
+}

package/dist/browser/src/mesh_editor/three_geometry_adapter.d.ts

@@ -0,0 +1,6 @@
+import type { EditableMesh } from "./types.js";
+export declare function editable_mesh_from_three_geometry(geometry: any, name?: string): EditableMesh;
+export declare function editable_meshes_from_three_object(root: any, name?: string): EditableMesh[];
+export declare function editable_meshes_from_three_gltf_scene(root: any, associations: any, name?: string): EditableMesh[];
+export declare function editable_mesh_from_three_object(root: any, name?: string): EditableMesh;
+export declare function editable_mesh_to_three_geometry(THREE: any, mesh: EditableMesh): any;

package/dist/browser/src/mesh_editor/three_geometry_adapter.js

@@ -0,0 +1,334 @@
+import { clone_editable_mesh, clone_editable_materials, create_default_editable_material, validate_editable_mesh } from "./mesh_data.js";
+function array_from_attribute(attribute, itemSize) {
+    if (attribute === undefined || attribute === null) {
+        return null;
+    }
+    const output = new Float32Array(attribute.count * itemSize);
+    for (let index = 0; index < attribute.count; index += 1) {
+        for (let item = 0; item < itemSize; item += 1) {
+            output[(index * itemSize) + item] = attribute.getComponent(index, item);
+        }
+    }
+    return output;
+}
+function append_array(target, source) {
+    for (let index = 0; index < source.length; index += 1) {
+        target.push(source[index]);
+    }
+}
+function append_attribute_or_default(target, attribute, itemSize, vertexCount, fallback) {
+    if (attribute !== undefined && attribute !== null) {
+        for (let index = 0; index < attribute.count; index += 1) {
+            for (let item = 0; item < itemSize; item += 1) {
+                target.push(attribute.getComponent(index, item));
+            }
+        }
+        return;
+    }
+    for (let index = 0; index < vertexCount; index += 1) {
+        append_array(target, fallback);
+    }
+}
+function transformed_geometry_copy(geometry, matrixWorld) {
+    const source = geometry.clone();
+    if (matrixWorld !== undefined && matrixWorld !== null) {
+        source.applyMatrix4(matrixWorld);
+    }
+    return source;
+}
+function geometry_indices(geometry, vertexOffset) {
+    const indexAttribute = geometry.index;
+    const indexCount = indexAttribute === null ? geometry.getAttribute("position").count : indexAttribute.count;
+    const indices = new Array(indexCount);
+    for (let index = 0; index < indexCount; index += 1) {
+        indices[index] = vertexOffset + (indexAttribute === null ? index : indexAttribute.getX(index));
+    }
+    return indices;
+}
+function compact_index_array(indices, vertexCount) {
+    return vertexCount <= 65535 ? new Uint16Array(indices) : new Uint32Array(indices);
+}
+function three_materials_from_object(object) {
+    if (Array.isArray(object.material)) {
+        return object.material.length > 0 ? object.material : [null];
+    }
+    return [object.material || null];
+}
+function pixels_from_texture_image(image) {
+    if (image === undefined || image === null) {
+        return null;
+    }
+    const width = Number(image.width || image.videoWidth || 0);
+    const height = Number(image.height || image.videoHeight || 0);
+    if (Number.isInteger(width) === false || Number.isInteger(height) === false || width <= 0 || height <= 0) {
+        return null;
+    }
+    if (image.data !== undefined &&
+        image.data !== null &&
+        (image.data instanceof Uint8Array || image.data instanceof Uint8ClampedArray) &&
+        image.data.length === width * height * 4) {
+        return { width, height, pixels: new Uint8Array(image.data) };
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d");
+    if (context === null) {
+        return null;
+    }
+    try {
+        context.drawImage(image, 0, 0, width, height);
+        return { width, height, pixels: new Uint8Array(context.getImageData(0, 0, width, height).data) };
+    }
+    catch (_error) {
+        return null;
+    }
+}
+function editable_texture_index_for_three_texture(texture, textures, textureIndexBySource) {
+    if (texture === undefined || texture === null) {
+        return null;
+    }
+    const existing = textureIndexBySource.get(texture);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const editableTexture = pixels_from_texture_image(texture.image);
+    if (editableTexture === null) {
+        return null;
+    }
+    const index = textures.length;
+    textures.push(editableTexture);
+    textureIndexBySource.set(texture, index);
+    return index;
+}
+function editable_material_from_three_material(material, textures, textureIndexBySource) {
+    const editableMaterial = create_default_editable_material();
+    if (material === undefined || material === null) {
+        return editableMaterial;
+    }
+    if (material.color !== undefined && material.color !== null) {
+        editableMaterial.baseColorFactor[0] = Number(material.color.r ?? editableMaterial.baseColorFactor[0]);
+        editableMaterial.baseColorFactor[1] = Number(material.color.g ?? editableMaterial.baseColorFactor[1]);
+        editableMaterial.baseColorFactor[2] = Number(material.color.b ?? editableMaterial.baseColorFactor[2]);
+    }
+    editableMaterial.baseColorFactor[3] = Number(material.opacity ?? editableMaterial.baseColorFactor[3]);
+    if (material.emissive !== undefined && material.emissive !== null) {
+        editableMaterial.emissiveFactor[0] = Number(material.emissive.r ?? editableMaterial.emissiveFactor[0]);
+        editableMaterial.emissiveFactor[1] = Number(material.emissive.g ?? editableMaterial.emissiveFactor[1]);
+        editableMaterial.emissiveFactor[2] = Number(material.emissive.b ?? editableMaterial.emissiveFactor[2]);
+    }
+    editableMaterial.roughnessFactor = Number(material.roughness ?? editableMaterial.roughnessFactor);
+    editableMaterial.metalnessFactor = Number(material.metalness ?? editableMaterial.metalnessFactor);
+    editableMaterial.baseColorTextureIndex = editable_texture_index_for_three_texture(material.map, textures, textureIndexBySource);
+    return editableMaterial;
+}
+export function editable_mesh_from_three_geometry(geometry, name = "uploaded mesh") {
+    const source = transformed_geometry_copy(geometry, null);
+    const positionAttribute = source.getAttribute("position");
+    if (positionAttribute === undefined || positionAttribute === null) {
+        source.dispose();
+        throw new Error("Uploaded mesh has no position attribute.");
+    }
+    const positions = array_from_attribute(positionAttribute, 3);
+    if (positions === null) {
+        source.dispose();
+        throw new Error("Uploaded mesh has no position attribute.");
+    }
+    const normals = array_from_attribute(source.getAttribute("normal"), 3);
+    const uvs = array_from_attribute(source.getAttribute("uv"), 2);
+    const colors = array_from_attribute(source.getAttribute("color"), 3);
+    const indices = compact_index_array(geometry_indices(source, 0), positionAttribute.count);
+    const groups = source.groups.length > 0
+        ? source.groups.map((group) => ({
+            start: group.start,
+            count: group.count,
+            materialIndex: group.materialIndex,
+        }))
+        : [{ start: 0, count: indices.length, materialIndex: 0 }];
+    const maxMaterialIndex = groups.reduce((maxIndex, group) => Math.max(maxIndex, group.materialIndex), 0);
+    const mesh = {
+        name,
+        positions,
+        normals,
+        indices,
+        uvs,
+        colors,
+        materialGroups: groups,
+        sourceParts: [],
+        materials: clone_editable_materials(null, maxMaterialIndex + 1),
+        textures: [],
+    };
+    validate_editable_mesh(mesh);
+    source.dispose();
+    return mesh;
+}
+function editable_mesh_from_three_mesh_object(object, fallbackName) {
+    return editable_mesh_from_three_mesh_objects([object], object.name || fallbackName);
+}
+export function editable_meshes_from_three_object(root, name = "uploaded mesh") {
+    root.updateWorldMatrix(true, true);
+    const meshes = [];
+    let meshIndex = 0;
+    root.traverse((object) => {
+        if (object.isMesh && object.geometry) {
+            meshIndex += 1;
+            meshes.push(editable_mesh_from_three_mesh_object(object, `${name} part ${meshIndex}`));
+        }
+    });
+    if (meshes.length === 0) {
+        throw new Error("Uploaded file did not contain a mesh.");
+    }
+    return meshes;
+}
+export function editable_meshes_from_three_gltf_scene(root, associations, name = "uploaded mesh") {
+    root.updateWorldMatrix(true, true);
+    const meshes = [];
+    let meshIndex = 0;
+    root.traverse((object) => {
+        const mapping = associations?.get?.(object);
+        if (mapping === undefined || mapping === null || mapping.nodes === undefined || mapping.meshes === undefined) {
+            return;
+        }
+        meshIndex += 1;
+        const meshObjects = [];
+        collect_gltf_node_mesh_objects(object, associations, meshObjects);
+        if (meshObjects.length > 0) {
+            meshes.push(editable_mesh_from_three_mesh_objects(meshObjects, object.name || `${name} part ${meshIndex}`));
+        }
+    });
+    if (meshes.length === 0) {
+        return editable_meshes_from_three_object(root, name);
+    }
+    return meshes;
+}
+function collect_gltf_node_mesh_objects(object, associations, target) {
+    if (object.isMesh && object.geometry) {
+        target.push(object);
+    }
+    const children = object.children || [];
+    for (const child of children) {
+        const mapping = associations?.get?.(child);
+        if (mapping !== undefined && mapping !== null && mapping.nodes !== undefined && mapping.meshes !== undefined) {
+            continue;
+        }
+        collect_gltf_node_mesh_objects(child, associations, target);
+    }
+}
+export function editable_mesh_from_three_object(root, name = "uploaded mesh") {
+    root.updateWorldMatrix(true, true);
+    const objects = [];
+    root.traverse((object) => {
+        if (object.isMesh && object.geometry) {
+            objects.push(object);
+        }
+    });
+    return editable_mesh_from_three_mesh_objects(objects, name);
+}
+function editable_mesh_from_three_mesh_objects(objects, name) {
+    const sources = [];
+    for (const object of objects) {
+        sources.push({
+            geometry: transformed_geometry_copy(object.geometry, object.matrixWorld),
+            materials: three_materials_from_object(object),
+        });
+    }
+    if (sources.length === 0) {
+        throw new Error("Uploaded file did not contain a mesh.");
+    }
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const colors = [];
+    const indices = [];
+    const groups = [];
+    const materials = [];
+    const textures = [];
+    const textureIndexBySource = new Map();
+    let vertexOffset = 0;
+    let indexOffset = 0;
+    let materialOffset = 0;
+    let hasUvs = false;
+    let hasColors = false;
+    let hasNormals = true;
+    try {
+        for (const sourceInfo of sources) {
+            const source = sourceInfo.geometry;
+            const positionAttribute = source.getAttribute("position");
+            if (positionAttribute === undefined || positionAttribute === null) {
+                throw new Error("Uploaded mesh has no position attribute.");
+            }
+            const uvAttribute = source.getAttribute("uv");
+            const colorAttribute = source.getAttribute("color");
+            const normalAttribute = source.getAttribute("normal");
+            hasUvs = hasUvs || (uvAttribute !== undefined && uvAttribute !== null);
+            hasColors = hasColors || (colorAttribute !== undefined && colorAttribute !== null);
+            hasNormals = hasNormals && normalAttribute !== undefined && normalAttribute !== null;
+            append_attribute_or_default(positions, positionAttribute, 3, positionAttribute.count, [0, 0, 0]);
+            append_attribute_or_default(normals, normalAttribute, 3, positionAttribute.count, [0, 1, 0]);
+            append_attribute_or_default(uvs, uvAttribute, 2, positionAttribute.count, [0, 0]);
+            append_attribute_or_default(colors, colorAttribute, 3, positionAttribute.count, [1, 1, 1]);
+            const sourceIndices = geometry_indices(source, vertexOffset);
+            append_array(indices, sourceIndices);
+            for (const material of sourceInfo.materials) {
+                materials.push(editable_material_from_three_material(material, textures, textureIndexBySource));
+            }
+            const sourceGroups = source.groups.length > 0
+                ? source.groups
+                : [{ start: 0, count: sourceIndices.length, materialIndex: 0 }];
+            for (const group of sourceGroups) {
+                const groupMaterialIndex = Math.min(Math.max(Number(group.materialIndex || 0), 0), sourceInfo.materials.length - 1);
+                groups.push({
+                    start: indexOffset + group.start,
+                    count: group.count,
+                    materialIndex: materialOffset + groupMaterialIndex,
+                });
+            }
+            vertexOffset += positionAttribute.count;
+            indexOffset += sourceIndices.length;
+            materialOffset += Math.max(sourceInfo.materials.length, 1);
+        }
+    }
+    finally {
+        for (const sourceInfo of sources) {
+            sourceInfo.geometry.dispose();
+        }
+    }
+    const mesh = {
+        name,
+        positions: new Float32Array(positions),
+        normals: hasNormals ? new Float32Array(normals) : null,
+        indices: compact_index_array(indices, vertexOffset),
+        uvs: hasUvs ? new Float32Array(uvs) : null,
+        colors: hasColors ? new Float32Array(colors) : null,
+        materialGroups: groups,
+        sourceParts: [],
+        materials: clone_editable_materials(materials, materialOffset),
+        textures,
+    };
+    validate_editable_mesh(mesh);
+    return mesh;
+}
+export function editable_mesh_to_three_geometry(THREE, mesh) {
+    const copy = clone_editable_mesh(mesh);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(copy.positions, 3));
+    if (copy.normals !== null) {
+        geometry.setAttribute("normal", new THREE.BufferAttribute(copy.normals, 3));
+    }
+    if (copy.uvs !== null) {
+        geometry.setAttribute("uv", new THREE.BufferAttribute(copy.uvs, 2));
+    }
+    if (copy.colors !== null) {
+        geometry.setAttribute("color", new THREE.BufferAttribute(copy.colors, 3));
+    }
+    if (copy.indices !== null) {
+        geometry.setIndex(new THREE.BufferAttribute(copy.indices, 1));
+    }
+    for (const group of copy.materialGroups) {
+        geometry.addGroup(group.start, group.count, group.materialIndex);
+    }
+    if (copy.normals === null) {
+        geometry.computeVertexNormals();
+    }
+    return geometry;
+}

package/dist/browser/src/mesh_editor/types.d.ts

@@ -0,0 +1,44 @@
+export interface EditableMeshMaterialGroup {
+    start: number;
+    count: number;
+    materialIndex: number;
+}
+export interface EditableMeshSourcePart {
+    name: string;
+    start: number;
+    count: number;
+    nodeTransform: number[][];
+    inverseNodeTransform: number[][];
+}
+export interface EditableTexture {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+}
+export interface EditableMaterial {
+    baseColorTextureIndex: number | null;
+    baseColorFactor: [number, number, number, number];
+    emissiveFactor: [number, number, number, number];
+    roughnessFactor: number;
+    metalnessFactor: number;
+}
+export interface EditableMesh {
+    name: string;
+    positions: Float32Array;
+    normals: Float32Array | null;
+    indices: Uint16Array | Uint32Array | null;
+    uvs: Float32Array | null;
+    colors: Float32Array | null;
+    materialGroups: EditableMeshMaterialGroup[];
+    sourceParts: EditableMeshSourcePart[];
+    materials: EditableMaterial[];
+    textures: EditableTexture[];
+}
+export interface EditableMeshBounds {
+    min: [number, number, number];
+    max: [number, number, number];
+    center: [number, number, number];
+    radius: number;
+}
+export type Vec3 = [number, number, number];
+export type Vec2 = [number, number];

package/dist/browser/src/mesh_editor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/src/session/edit_session.d.ts

@@ -0,0 +1,23 @@
+import * as DEFAULT_THREE from "three";
+import type { EditableMesh } from "../mesh_editor/types.js";
+export interface OpenEditSessionOptions {
+    title?: string;
+    source_id?: unknown;
+    editable_mesh: EditableMesh;
+    three?: typeof DEFAULT_THREE;
+    container?: HTMLElement;
+    root_class?: string;
+    symmetry_enabled?: boolean;
+    symmetry_vertical?: boolean;
+    symmetry_horizontal?: boolean;
+    on_commit?: (result: EditSessionCommitResult) => void | Promise<void>;
+}
+export type EditSessionCommitResult = {
+    action: "commit";
+    mode: "edit";
+    mesh: EditableMesh;
+};
+export type EditSessionResult = {
+    action: "cancel";
+} | EditSessionCommitResult;
+export declare function open_edit_session(options: OpenEditSessionOptions): Promise<EditSessionResult>;