@womp/mesh-editor 0.1.0

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

@@ -0,0 +1,14 @@
+import type { EditableMaterial, EditableMesh, EditableMeshBounds, EditableMeshSourcePart, EditableTexture } from "./types.js";
+export declare function create_default_editable_material(): EditableMaterial;
+export declare function clone_editable_material(material: Partial<EditableMaterial> | undefined | null): EditableMaterial;
+export declare function clone_editable_texture(texture: Partial<EditableTexture> | undefined | null): EditableTexture;
+export declare function clone_editable_source_part(part: Partial<EditableMeshSourcePart> | undefined | null): EditableMeshSourcePart;
+export declare function clone_editable_materials(materials: unknown, minimumCount: number): EditableMaterial[];
+export declare function clone_editable_textures(textures: unknown): EditableTexture[];
+export declare function clone_editable_source_parts(sourceParts: unknown): EditableMeshSourcePart[];
+export declare function clone_editable_mesh(mesh: any): EditableMesh;
+export declare function validate_editable_mesh(mesh: any): void;
+export declare function editable_mesh_bounds(mesh: EditableMesh): EditableMeshBounds;
+export declare function create_grid_fixture(size?: number, segments?: number): EditableMesh;
+export declare function create_cube_fixture(size?: number): EditableMesh;
+export declare function create_sphere_fixture(radius?: number, subdivisions?: number): EditableMesh;

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

@@ -0,0 +1,543 @@
+export function create_default_editable_material() {
+    return {
+        baseColorTextureIndex: null,
+        baseColorFactor: [0.42, 0.42, 0.42, 1],
+        emissiveFactor: [0, 0, 0, 0],
+        roughnessFactor: 0.55,
+        metalnessFactor: 0,
+    };
+}
+function clone_vec4(value, fallback) {
+    const source = value;
+    if (source === undefined || source === null) {
+        return [fallback[0], fallback[1], fallback[2], fallback[3]];
+    }
+    return [
+        Number(source[0] ?? fallback[0]),
+        Number(source[1] ?? fallback[1]),
+        Number(source[2] ?? fallback[2]),
+        Number(source[3] ?? fallback[3]),
+    ];
+}
+export function clone_editable_material(material) {
+    const fallback = create_default_editable_material();
+    if (material === undefined || material === null) {
+        return fallback;
+    }
+    const textureIndex = material.baseColorTextureIndex;
+    return {
+        baseColorTextureIndex: textureIndex === null || textureIndex === undefined ? null : Number(textureIndex),
+        baseColorFactor: clone_vec4(material.baseColorFactor, fallback.baseColorFactor),
+        emissiveFactor: clone_vec4(material.emissiveFactor, fallback.emissiveFactor),
+        roughnessFactor: Number(material.roughnessFactor ?? fallback.roughnessFactor),
+        metalnessFactor: Number(material.metalnessFactor ?? fallback.metalnessFactor),
+    };
+}
+export function clone_editable_texture(texture) {
+    const width = Number(texture?.width || 0);
+    const height = Number(texture?.height || 0);
+    const pixels = texture?.pixels instanceof Uint8Array ? new Uint8Array(texture.pixels) : new Uint8Array();
+    return { width, height, pixels };
+}
+function clone_matrix4(value) {
+    const source = value;
+    const output = [];
+    for (let column = 0; column < 4; column += 1) {
+        const sourceColumn = source?.[column];
+        output.push([
+            Number(sourceColumn?.[0] ?? (column === 0 ? 1 : 0)),
+            Number(sourceColumn?.[1] ?? (column === 1 ? 1 : 0)),
+            Number(sourceColumn?.[2] ?? (column === 2 ? 1 : 0)),
+            Number(sourceColumn?.[3] ?? (column === 3 ? 1 : 0)),
+        ]);
+    }
+    return output;
+}
+export function clone_editable_source_part(part) {
+    return {
+        name: String(part?.name || "mesh part"),
+        start: Number(part?.start || 0),
+        count: Number(part?.count || 0),
+        nodeTransform: clone_matrix4(part?.nodeTransform),
+        inverseNodeTransform: clone_matrix4(part?.inverseNodeTransform),
+    };
+}
+export function clone_editable_materials(materials, minimumCount) {
+    const output = Array.from(materials || [], clone_editable_material);
+    while (output.length < Math.max(minimumCount, 1)) {
+        output.push(create_default_editable_material());
+    }
+    return output;
+}
+export function clone_editable_textures(textures) {
+    return Array.from(textures || [], clone_editable_texture);
+}
+export function clone_editable_source_parts(sourceParts) {
+    return Array.from(sourceParts || [], clone_editable_source_part);
+}
+export function clone_editable_mesh(mesh) {
+    const positions = new Float32Array(mesh.positions || []);
+    const normals = mesh.normals !== undefined && mesh.normals !== null
+        ? new Float32Array(mesh.normals)
+        : null;
+    const indices = mesh.indices !== undefined && mesh.indices !== null
+        ? new Uint32Array(mesh.indices)
+        : null;
+    const uvs = mesh.uvs !== undefined && mesh.uvs !== null ? new Float32Array(mesh.uvs) : null;
+    const colors = mesh.colors !== undefined && mesh.colors !== null
+        ? new Float32Array(mesh.colors)
+        : null;
+    const materialGroups = Array.from(mesh.materialGroups || [], (group) => ({
+        start: Number(group.start || 0),
+        count: Number(group.count || 0),
+        materialIndex: Number(group.materialIndex || 0),
+    }));
+    const maxGroupMaterialIndex = materialGroups.reduce((maxIndex, group) => Math.max(maxIndex, group.materialIndex), 0);
+    const textures = clone_editable_textures(mesh.textures);
+    const materials = clone_editable_materials(mesh.materials, maxGroupMaterialIndex + 1);
+    const sourceParts = clone_editable_source_parts(mesh.sourceParts);
+    return {
+        name: String(mesh.name || "mesh"),
+        positions,
+        normals,
+        indices,
+        uvs,
+        colors,
+        materialGroups,
+        sourceParts,
+        materials,
+        textures,
+    };
+}
+function validate_range_partition(ranges, indexCount, label, requireOrdered) {
+    if (ranges.length === 0) {
+        return;
+    }
+    const ordered = Array.from(ranges);
+    if (requireOrdered === false) {
+        ordered.sort((a, b) => Number(a.start) - Number(b.start));
+    }
+    let expectedStart = 0;
+    for (const range of ordered) {
+        const start = Number(range.start);
+        const count = Number(range.count);
+        if (count <= 0 || start !== expectedStart) {
+            throw new Error(`${label} must form a complete, non-overlapping partition of the index buffer.`);
+        }
+        expectedStart += count;
+    }
+    if (expectedStart !== indexCount) {
+        throw new Error(`${label} must form a complete, non-overlapping partition of the index buffer.`);
+    }
+}
+function validate_source_part_transform(part) {
+    const matrices = [
+        { value: part.nodeTransform, label: "nodeTransform" },
+        { value: part.inverseNodeTransform, label: "inverseNodeTransform" },
+    ];
+    for (const matrix of matrices) {
+        if (Array.isArray(matrix.value) === false || matrix.value.length !== 4) {
+            throw new Error(`Mesh source part ${matrix.label} must be a 4x4 matrix.`);
+        }
+        for (const column of matrix.value) {
+            if (Array.isArray(column) === false || column.length !== 4) {
+                throw new Error(`Mesh source part ${matrix.label} must be a 4x4 matrix.`);
+            }
+            for (const value of column) {
+                if (Number.isFinite(Number(value)) === false) {
+                    throw new Error(`Mesh source part ${matrix.label} must contain finite values.`);
+                }
+            }
+        }
+    }
+    for (let column = 0; column < 4; column += 1) {
+        for (let row = 0; row < 4; row += 1) {
+            let product = 0;
+            for (let inner = 0; inner < 4; inner += 1) {
+                product += part.nodeTransform[inner][row] * part.inverseNodeTransform[column][inner];
+            }
+            const expected = column === row ? 1 : 0;
+            if (Math.abs(product - expected) > 0.001) {
+                throw new Error("Mesh source part transforms must be inverses.");
+            }
+        }
+    }
+}
+export function validate_editable_mesh(mesh) {
+    if (mesh === undefined || mesh === null) {
+        throw new Error("Mesh is required.");
+    }
+    if ((mesh.positions instanceof Float32Array) === false) {
+        throw new Error("Mesh positions must be a Float32Array.");
+    }
+    if ((mesh.positions.length % 3) !== 0) {
+        throw new Error("Mesh positions length must be divisible by 3.");
+    }
+    const vertexCount = mesh.positions.length / 3;
+    for (let index = 0; index < mesh.positions.length; index += 1) {
+        if (Number.isFinite(mesh.positions[index]) === false) {
+            throw new Error("Mesh positions must contain finite values.");
+        }
+    }
+    if (mesh.indices !== null && mesh.indices !== undefined) {
+        if ((mesh.indices instanceof Uint16Array) === false && (mesh.indices instanceof Uint32Array) === false) {
+            throw new Error("Mesh indices must be Uint16Array or Uint32Array.");
+        }
+        if ((mesh.indices.length % 3) !== 0) {
+            throw new Error("Mesh indices length must be divisible by 3.");
+        }
+        for (let index = 0; index < mesh.indices.length; index += 1) {
+            if (mesh.indices[index] >= vertexCount) {
+                throw new Error("Mesh indices contain an out-of-range vertex index.");
+            }
+        }
+    }
+    else if ((vertexCount % 3) !== 0) {
+        throw new Error("Non-indexed mesh vertex count must be divisible by 3.");
+    }
+    if (mesh.uvs !== null && mesh.uvs !== undefined) {
+        if ((mesh.uvs instanceof Float32Array) === false || ((mesh.uvs.length % 2) !== 0)) {
+            throw new Error("Mesh uvs must be a Float32Array with vec2 elements.");
+        }
+        if ((mesh.uvs.length / 2) !== vertexCount) {
+            throw new Error("Mesh uv count must match position count.");
+        }
+        for (let index = 0; index < mesh.uvs.length; index += 1) {
+            if (Number.isFinite(mesh.uvs[index]) === false) {
+                throw new Error("Mesh uvs must contain finite values.");
+            }
+        }
+    }
+    if (mesh.colors !== null && mesh.colors !== undefined) {
+        if ((mesh.colors instanceof Float32Array) === false || ((mesh.colors.length % 3) !== 0)) {
+            throw new Error("Mesh colors must be a Float32Array with vec3 elements.");
+        }
+        if ((mesh.colors.length / 3) !== vertexCount) {
+            throw new Error("Mesh color count must match position count.");
+        }
+        for (let index = 0; index < mesh.colors.length; index += 1) {
+            if (Number.isFinite(mesh.colors[index]) === false) {
+                throw new Error("Mesh colors must contain finite values.");
+            }
+        }
+    }
+    const materialGroups = mesh.materialGroups || [];
+    if (Array.isArray(materialGroups) === false) {
+        throw new Error("Mesh materialGroups must be an array.");
+    }
+    const indexCount = mesh.indices !== null && mesh.indices !== undefined ? mesh.indices.length : vertexCount;
+    for (const group of materialGroups) {
+        const start = Number(group.start);
+        const count = Number(group.count);
+        const materialIndex = Number(group.materialIndex);
+        if (Number.isInteger(start) === false ||
+            Number.isInteger(count) === false ||
+            Number.isInteger(materialIndex) === false ||
+            start < 0 ||
+            count < 0 ||
+            materialIndex < 0) {
+            throw new Error("Mesh material groups must contain non-negative integer fields.");
+        }
+        if (((start + count) > indexCount) || ((start % 3) !== 0) || ((count % 3) !== 0)) {
+            throw new Error("Mesh material group ranges must contain whole triangles inside the index buffer.");
+        }
+    }
+    if (mesh.normals !== null && mesh.normals !== undefined) {
+        if ((mesh.normals instanceof Float32Array) === false || mesh.normals.length !== mesh.positions.length) {
+            throw new Error("Mesh normals must be a Float32Array matching position count.");
+        }
+        for (let index = 0; index < mesh.normals.length; index += 1) {
+            if (Number.isFinite(mesh.normals[index]) === false) {
+                throw new Error("Mesh normals must contain finite values.");
+            }
+        }
+    }
+    validate_range_partition(materialGroups, indexCount, "Mesh material groups", false);
+    const sourceParts = mesh.sourceParts || [];
+    if (Array.isArray(sourceParts) === false) {
+        throw new Error("Mesh sourceParts must be an array.");
+    }
+    for (const part of sourceParts) {
+        const start = Number(part.start);
+        const count = Number(part.count);
+        if (Number.isInteger(start) === false || Number.isInteger(count) === false || start < 0 || count < 0) {
+            throw new Error("Mesh source parts must contain non-negative integer ranges.");
+        }
+        if (((start + count) > indexCount) || ((start % 3) !== 0) || ((count % 3) !== 0)) {
+            throw new Error("Mesh source part ranges must contain whole triangles inside the index buffer.");
+        }
+        validate_source_part_transform(part);
+    }
+    validate_range_partition(sourceParts, indexCount, "Mesh source parts", true);
+    const textures = mesh.textures || [];
+    if (Array.isArray(textures) === false) {
+        throw new Error("Mesh textures must be an array.");
+    }
+    for (const texture of textures) {
+        const width = Number(texture.width);
+        const height = Number(texture.height);
+        if (Number.isInteger(width) === false || Number.isInteger(height) === false || width <= 0 || height <= 0) {
+            throw new Error("Mesh textures must have positive integer dimensions.");
+        }
+        if ((texture.pixels instanceof Uint8Array) === false || texture.pixels.length !== width * height * 4) {
+            throw new Error("Mesh texture pixels must be RGBA8 data matching dimensions.");
+        }
+    }
+    const materials = mesh.materials || [];
+    if (Array.isArray(materials) === false) {
+        throw new Error("Mesh materials must be an array.");
+    }
+    for (const material of materials) {
+        const textureIndex = material.baseColorTextureIndex;
+        if (textureIndex !== null &&
+            textureIndex !== undefined &&
+            (Number.isInteger(Number(textureIndex)) === false || Number(textureIndex) < 0 || Number(textureIndex) >= textures.length)) {
+            throw new Error("Mesh material references an out-of-range texture.");
+        }
+        if (Array.isArray(material.baseColorFactor) === false || material.baseColorFactor.length !== 4) {
+            throw new Error("Mesh material base color factor must contain four values.");
+        }
+        for (const value of material.baseColorFactor) {
+            if (Number.isFinite(Number(value)) === false || Number(value) < 0 || Number(value) > 1) {
+                throw new Error("Mesh material base color factors must be finite values from zero to one.");
+            }
+        }
+        if (Array.isArray(material.emissiveFactor) === false || material.emissiveFactor.length !== 4) {
+            throw new Error("Mesh material emissive factor must contain four values.");
+        }
+        for (const value of material.emissiveFactor) {
+            if (Number.isFinite(Number(value)) === false || Number(value) < 0 || Number(value) > 1) {
+                throw new Error("Mesh material emissive factors must be finite values from zero to one.");
+            }
+        }
+        if (Number.isFinite(Number(material.roughnessFactor)) === false ||
+            Number(material.roughnessFactor) < 0 ||
+            Number(material.roughnessFactor) > 1 ||
+            Number.isFinite(Number(material.metalnessFactor)) === false ||
+            Number(material.metalnessFactor) < 0 ||
+            Number(material.metalnessFactor) > 1) {
+            throw new Error("Mesh material scalar factors must be finite values from zero to one.");
+        }
+    }
+    for (const group of materialGroups) {
+        if (group.materialIndex >= materials.length) {
+            throw new Error("Mesh material group references an out-of-range material.");
+        }
+    }
+}
+export function editable_mesh_bounds(mesh) {
+    validate_editable_mesh(mesh);
+    const positions = mesh.positions;
+    const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+    const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    for (let index = 0; index < positions.length; index += 3) {
+        const x = positions[index + 0];
+        const y = positions[index + 1];
+        const z = positions[index + 2];
+        min[0] = Math.min(min[0], x);
+        min[1] = Math.min(min[1], y);
+        min[2] = Math.min(min[2], z);
+        max[0] = Math.max(max[0], x);
+        max[1] = Math.max(max[1], y);
+        max[2] = Math.max(max[2], z);
+    }
+    if (positions.length === 0) {
+        return { min: [0, 0, 0], max: [0, 0, 0], center: [0, 0, 0], radius: 1 };
+    }
+    const center = [
+        (min[0] + max[0]) * 0.5,
+        (min[1] + max[1]) * 0.5,
+        (min[2] + max[2]) * 0.5,
+    ];
+    let radiusSq = 0;
+    for (let index = 0; index < positions.length; index += 3) {
+        const dx = positions[index + 0] - center[0];
+        const dy = positions[index + 1] - center[1];
+        const dz = positions[index + 2] - center[2];
+        radiusSq = Math.max(radiusSq, (dx * dx) + (dy * dy) + (dz * dz));
+    }
+    return { min, max, center, radius: Math.max(Math.sqrt(radiusSq), Number.MIN_VALUE) };
+}
+export function create_grid_fixture(size = 3, segments = 8) {
+    const vertexCount = (segments + 1) * (segments + 1);
+    const positions = new Float32Array(vertexCount * 3);
+    const uvs = new Float32Array(vertexCount * 2);
+    const colors = new Float32Array(vertexCount * 3);
+    let vertex = 0;
+    for (let y = 0; y <= segments; y += 1) {
+        for (let x = 0; x <= segments; x += 1) {
+            const u = x / segments;
+            const v = y / segments;
+            positions[(vertex * 3) + 0] = (u - 0.5) * size;
+            positions[(vertex * 3) + 1] = 0;
+            positions[(vertex * 3) + 2] = (v - 0.5) * size;
+            uvs[(vertex * 2) + 0] = u;
+            uvs[(vertex * 2) + 1] = v;
+            colors[(vertex * 3) + 0] = 1;
+            colors[(vertex * 3) + 1] = 1;
+            colors[(vertex * 3) + 2] = 1;
+            vertex += 1;
+        }
+    }
+    const indices = new Uint32Array(segments * segments * 6);
+    let offset = 0;
+    for (let y = 0; y < segments; y += 1) {
+        for (let x = 0; x < segments; x += 1) {
+            const a = x + (y * (segments + 1));
+            const b = a + 1;
+            const c = a + segments + 1;
+            const d = c + 1;
+            indices[offset + 0] = a;
+            indices[offset + 1] = c;
+            indices[offset + 2] = b;
+            indices[offset + 3] = b;
+            indices[offset + 4] = c;
+            indices[offset + 5] = d;
+            offset += 6;
+        }
+    }
+    return {
+        name: "grid",
+        positions,
+        normals: null,
+        indices,
+        uvs,
+        colors,
+        materialGroups: [{ start: 0, count: indices.length, materialIndex: 0 }],
+        sourceParts: [],
+        materials: [create_default_editable_material()],
+        textures: [],
+    };
+}
+export function create_cube_fixture(size = 2) {
+    const h = size * 0.5;
+    const positions = new Float32Array([
+        -h, -h, h, h, -h, h, h, h, h, -h, h, h,
+        h, -h, -h, -h, -h, -h, -h, h, -h, h, h, -h,
+        -h, h, h, h, h, h, h, h, -h, -h, h, -h,
+        -h, -h, -h, h, -h, -h, h, -h, h, -h, -h, h,
+        h, -h, h, h, -h, -h, h, h, -h, h, h, h,
+        -h, -h, -h, -h, -h, h, -h, h, h, -h, h, -h,
+    ]);
+    const indices = new Uint32Array([
+        0, 1, 2, 0, 2, 3,
+        4, 5, 6, 4, 6, 7,
+        8, 9, 10, 8, 10, 11,
+        12, 13, 14, 12, 14, 15,
+        16, 17, 18, 16, 18, 19,
+        20, 21, 22, 20, 22, 23,
+    ]);
+    const uvs = new Float32Array(24 * 2);
+    const colors = new Float32Array(24 * 3);
+    for (let index = 0; index < 24; index += 1) {
+        uvs[(index * 2) + 0] = index % 2;
+        uvs[(index * 2) + 1] = Math.floor(index / 2) % 2;
+        colors[(index * 3) + 0] = 1;
+        colors[(index * 3) + 1] = 1;
+        colors[(index * 3) + 2] = 1;
+    }
+    return {
+        name: "cube",
+        positions,
+        normals: null,
+        indices,
+        uvs,
+        colors,
+        materialGroups: [{ start: 0, count: indices.length, materialIndex: 0 }],
+        sourceParts: [],
+        materials: [create_default_editable_material()],
+        textures: [],
+    };
+}
+export function create_sphere_fixture(radius = 1, subdivisions = 4) {
+    const t = (1 + Math.sqrt(5)) * 0.5;
+    const vertices = [
+        [-1, t, 0], [1, t, 0], [-1, -t, 0], [1, -t, 0],
+        [0, -1, t], [0, 1, t], [0, -1, -t], [0, 1, -t],
+        [t, 0, -1], [t, 0, 1], [-t, 0, -1], [-t, 0, 1],
+    ];
+    let faces = [
+        [0, 11, 5], [0, 5, 1], [0, 1, 7], [0, 7, 10], [0, 10, 11],
+        [1, 5, 9], [5, 11, 4], [11, 10, 2], [10, 7, 6], [7, 1, 8],
+        [3, 9, 4], [3, 4, 2], [3, 2, 6], [3, 6, 8], [3, 8, 9],
+        [4, 9, 5], [2, 4, 11], [6, 2, 10], [8, 6, 7], [9, 8, 1],
+    ];
+    function normalize_vertex(index) {
+        const vertex = vertices[index];
+        const length = Math.hypot(vertex[0], vertex[1], vertex[2]);
+        vertex[0] = (vertex[0] / length) * radius;
+        vertex[1] = (vertex[1] / length) * radius;
+        vertex[2] = (vertex[2] / length) * radius;
+    }
+    for (let index = 0; index < vertices.length; index += 1) {
+        normalize_vertex(index);
+    }
+    for (let level = 0; level < subdivisions; level += 1) {
+        const midpointCache = new Map();
+        const midpoint = (a, b) => {
+            const min = Math.min(a, b);
+            const max = Math.max(a, b);
+            const key = `${min}:${max}`;
+            const cached = midpointCache.get(key);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const va = vertices[a];
+            const vb = vertices[b];
+            const index = vertices.length;
+            vertices.push([
+                (va[0] + vb[0]) * 0.5,
+                (va[1] + vb[1]) * 0.5,
+                (va[2] + vb[2]) * 0.5,
+            ]);
+            normalize_vertex(index);
+            midpointCache.set(key, index);
+            return index;
+        };
+        const nextFaces = [];
+        for (const face of faces) {
+            const ab = midpoint(face[0], face[1]);
+            const bc = midpoint(face[1], face[2]);
+            const ca = midpoint(face[2], face[0]);
+            nextFaces.push([face[0], ab, ca], [face[1], bc, ab], [face[2], ca, bc], [ab, bc, ca]);
+        }
+        faces = nextFaces;
+    }
+    const positions = new Float32Array(vertices.length * 3);
+    const uvs = new Float32Array(vertices.length * 2);
+    const colors = new Float32Array(vertices.length * 3);
+    for (let index = 0; index < vertices.length; index += 1) {
+        const vertex = vertices[index];
+        const nx = vertex[0] / radius;
+        const ny = vertex[1] / radius;
+        const nz = vertex[2] / radius;
+        positions[(index * 3) + 0] = vertex[0];
+        positions[(index * 3) + 1] = vertex[1];
+        positions[(index * 3) + 2] = vertex[2];
+        uvs[(index * 2) + 0] = 0.5 + (Math.atan2(nz, nx) / (Math.PI * 2));
+        uvs[(index * 2) + 1] = 0.5 - (Math.asin(ny) / Math.PI);
+        colors[(index * 3) + 0] = 1;
+        colors[(index * 3) + 1] = 1;
+        colors[(index * 3) + 2] = 1;
+    }
+    const indices = new Uint32Array(faces.length * 3);
+    let offset = 0;
+    for (const face of faces) {
+        indices[offset + 0] = face[0];
+        indices[offset + 1] = face[1];
+        indices[offset + 2] = face[2];
+        offset += 3;
+    }
+    return {
+        name: "icosphere",
+        positions,
+        normals: null,
+        indices,
+        uvs,
+        colors,
+        materialGroups: [{ start: 0, count: indices.length, materialIndex: 0 }],
+        sourceParts: [],
+        materials: [create_default_editable_material()],
+        textures: [],
+    };
+}

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

@@ -0,0 +1,36 @@
+type WorkerPhase = "triangles" | "vertices";
+interface ConfigureMessage {
+    type: "configure";
+    positions: SharedArrayBuffer;
+    indices: SharedArrayBuffer | null;
+    indexBytes: number;
+    triangleOffsets: SharedArrayBuffer;
+    triangleIndices: SharedArrayBuffer;
+    triangleNormals: SharedArrayBuffer;
+    normals: SharedArrayBuffer;
+    taskTriangles: SharedArrayBuffer;
+    taskVertices: SharedArrayBuffer;
+}
+interface RunMessage {
+    type: "run";
+    taskId: number;
+    phase: WorkerPhase;
+    start: number;
+    end: number;
+}
+declare let positions: Float32Array<ArrayBufferLike>;
+declare let indices: Uint16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | null;
+declare let triangleOffsets: Uint32Array<ArrayBufferLike>;
+declare let triangleIndices: Uint32Array<ArrayBufferLike>;
+declare let triangleNormals: Float32Array<ArrayBufferLike>;
+declare let normals: Float32Array<ArrayBufferLike>;
+declare let taskTriangles: Uint32Array<ArrayBufferLike>;
+declare let taskVertices: Uint32Array<ArrayBufferLike>;
+declare function configure(message: ConfigureMessage): void;
+declare function source_vertex(indexOffset: number): number;
+declare function refresh_triangles(start: number, end: number): void;
+declare function refresh_vertices(start: number, end: number): void;
+declare const workerScope: {
+    onmessage: ((event: MessageEvent<ConfigureMessage | RunMessage>) => void) | null;
+    postMessage: (message: unknown) => void;
+};

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

@@ -0,0 +1,83 @@
+"use strict";
+let positions = new Float32Array();
+let indices = null;
+let triangleOffsets = new Uint32Array();
+let triangleIndices = new Uint32Array();
+let triangleNormals = new Float32Array();
+let normals = new Float32Array();
+let taskTriangles = new Uint32Array();
+let taskVertices = new Uint32Array();
+function configure(message) {
+    positions = new Float32Array(message.positions);
+    indices = message.indices === null
+        ? null
+        : message.indexBytes === Uint16Array.BYTES_PER_ELEMENT
+            ? new Uint16Array(message.indices)
+            : new Uint32Array(message.indices);
+    triangleOffsets = new Uint32Array(message.triangleOffsets);
+    triangleIndices = new Uint32Array(message.triangleIndices);
+    triangleNormals = new Float32Array(message.triangleNormals);
+    normals = new Float32Array(message.normals);
+    taskTriangles = new Uint32Array(message.taskTriangles);
+    taskVertices = new Uint32Array(message.taskVertices);
+}
+function source_vertex(indexOffset) {
+    return indices === null ? indexOffset : indices[indexOffset];
+}
+function refresh_triangles(start, end) {
+    for (let taskIndex = start; taskIndex < end; taskIndex += 1) {
+        const triangleIndex = taskTriangles[taskIndex];
+        const triangleOffset = triangleIndex * 3;
+        const a = source_vertex(triangleOffset + 0) * 3;
+        const b = source_vertex(triangleOffset + 1) * 3;
+        const c = source_vertex(triangleOffset + 2) * 3;
+        const abX = positions[b + 0] - positions[a + 0];
+        const abY = positions[b + 1] - positions[a + 1];
+        const abZ = positions[b + 2] - positions[a + 2];
+        const acX = positions[c + 0] - positions[a + 0];
+        const acY = positions[c + 1] - positions[a + 1];
+        const acZ = positions[c + 2] - positions[a + 2];
+        triangleNormals[triangleOffset + 0] = (abY * acZ) - (abZ * acY);
+        triangleNormals[triangleOffset + 1] = (abZ * acX) - (abX * acZ);
+        triangleNormals[triangleOffset + 2] = (abX * acY) - (abY * acX);
+    }
+}
+function refresh_vertices(start, end) {
+    for (let taskIndex = start; taskIndex < end; taskIndex += 1) {
+        const vertexIndex = taskVertices[taskIndex];
+        let normalX = 0;
+        let normalY = 0;
+        let normalZ = 0;
+        const triangleStart = triangleOffsets[vertexIndex];
+        const triangleEnd = triangleOffsets[vertexIndex + 1];
+        for (let adjacencyIndex = triangleStart; adjacencyIndex < triangleEnd; adjacencyIndex += 1) {
+            const triangleOffset = triangleIndices[adjacencyIndex] * 3;
+            normalX += triangleNormals[triangleOffset + 0];
+            normalY += triangleNormals[triangleOffset + 1];
+            normalZ += triangleNormals[triangleOffset + 2];
+        }
+        const length = Math.hypot(normalX, normalY, normalZ);
+        if (length <= Number.MIN_VALUE) {
+            continue;
+        }
+        const offset = vertexIndex * 3;
+        normals[offset + 0] = normalX / length;
+        normals[offset + 1] = normalY / length;
+        normals[offset + 2] = normalZ / length;
+    }
+}
+const workerScope = self;
+workerScope.onmessage = (event) => {
+    const message = event.data;
+    if (message.type === "configure") {
+        configure(message);
+        return;
+    }
+    if (message.phase === "triangles") {
+        refresh_triangles(message.start, message.end);
+    }
+    else {
+        refresh_vertices(message.start, message.end);
+    }
+    workerScope.postMessage({ type: "done", taskId: message.taskId });
+};