@series-inc/stowkit-cli 0.1.0

package/dist/encoders/fbx-loader.js

@@ -0,0 +1,540 @@
+import * as THREE from 'three';
+import { FBXLoader } from 'three/addons/loaders/FBXLoader.js';
+import { PropertyBinding } from 'three';
+import { parseBinary as fbxParseBinary, parseText as fbxParseText, FBXReader } from 'fbx-parser';
+// ─── Minimal DOM shim for Three.js FBXLoader in Node ────────────────────────
+function ensureDomShim() {
+    const g = globalThis;
+    if (typeof g.document !== 'undefined')
+        return;
+    // Minimal shim — FBXLoader only needs createElementNS for canvas (which we don't use)
+    g.document = {
+        createElementNS(_ns, tag) {
+            if (tag === 'img') {
+                return { set src(_) { }, set onload(_) { }, set onerror(_) { } };
+            }
+            return {};
+        },
+    };
+    if (typeof g.self === 'undefined') {
+        g.self = g;
+    }
+    if (typeof g.window === 'undefined') {
+        g.window = g;
+    }
+    if (typeof g.Blob === 'undefined') {
+        g.Blob = class Blob {
+            parts;
+            constructor(parts) { this.parts = parts; }
+        };
+    }
+    if (typeof g.URL === 'undefined' || !g.URL.createObjectURL) {
+        const UrlClass = g.URL ?? {};
+        UrlClass.createObjectURL = () => '';
+        UrlClass.revokeObjectURL = () => { };
+    }
+}
+// ─── FBX Importer ────────────────────────────────────────────────────────────
+export class NodeFbxImporter {
+    async import(data, _fileName) {
+        ensureDomShim();
+        try {
+            const loader = new FBXLoader();
+            const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            const group = loader.parse(buffer, '');
+            const mesh = extractMeshFromGroup(group);
+            mesh.animations = parseFbxAnimations(data);
+            return mesh;
+        }
+        catch (err) {
+            console.error('[NodeFbxImporter] Failed:', err);
+            return emptyMesh();
+        }
+    }
+}
+// ─── Group → ImportedMesh extraction ────────────────────────────────────────
+function extractMeshFromGroup(group) {
+    const subMeshes = [];
+    const materials = [];
+    const materialSet = new Map();
+    const nodes = [];
+    let hasSkeleton = false;
+    const allBones = [];
+    const meshObjects = [];
+    group.traverse((child) => {
+        if (child.isMesh) {
+            meshObjects.push(child);
+        }
+    });
+    const sceneBones = [];
+    const seenBoneNames = new Set();
+    group.traverse((child) => {
+        if (child.isBone) {
+            const name = child.name;
+            if (!seenBoneNames.has(name)) {
+                seenBoneNames.add(name);
+                sceneBones.push(child);
+            }
+        }
+    });
+    const perMeshSkeletons = new Map();
+    for (const mesh of meshObjects) {
+        if (mesh.isSkinnedMesh) {
+            const sm = mesh;
+            if (sm.skeleton && sm.skeleton.bones.length > 0) {
+                hasSkeleton = true;
+                perMeshSkeletons.set(sm, sm.skeleton);
+            }
+        }
+    }
+    if (sceneBones.length > 0 && hasSkeleton) {
+        group.updateMatrixWorld(true);
+        const rootInverse = new THREE.Matrix4().copy(group.matrixWorld).invert();
+        const fbxBoneInverses = new Map();
+        for (const skel of perMeshSkeletons.values()) {
+            for (let i = 0; i < skel.bones.length; i++) {
+                if (!fbxBoneInverses.has(skel.bones[i].name)) {
+                    fbxBoneInverses.set(skel.bones[i].name, skel.boneInverses[i]);
+                }
+            }
+        }
+        const boneIndexMap = new Map();
+        for (let i = 0; i < sceneBones.length; i++) {
+            boneIndexMap.set(sceneBones[i], i);
+        }
+        const intermediateMap = new Map();
+        for (const bone of sceneBones) {
+            let hasBoneAncestor = false;
+            let check = bone.parent;
+            while (check && check !== group) {
+                if (boneIndexMap.has(check)) {
+                    hasBoneAncestor = true;
+                    break;
+                }
+                check = check.parent;
+            }
+            if (!hasBoneAncestor && bone.parent && bone.parent !== group) {
+                const parent = bone.parent;
+                if (!parent.isBone && !intermediateMap.has(parent)) {
+                    const idx = sceneBones.length + intermediateMap.size;
+                    intermediateMap.set(parent, idx);
+                }
+            }
+        }
+        function computeOffset(obj) {
+            const offsetMatrix = new Array(16);
+            const localWorld = new THREE.Matrix4().multiplyMatrices(rootInverse, obj.matrixWorld);
+            localWorld.invert().toArray(offsetMatrix);
+            return offsetMatrix;
+        }
+        for (let i = 0; i < sceneBones.length; i++) {
+            const bone = sceneBones[i];
+            let parentIndex = -1;
+            let ancestor = bone.parent;
+            while (ancestor && ancestor !== group) {
+                const boneIdx = boneIndexMap.get(ancestor);
+                if (boneIdx !== undefined) {
+                    parentIndex = boneIdx;
+                    break;
+                }
+                const interIdx = intermediateMap.get(ancestor);
+                if (interIdx !== undefined) {
+                    parentIndex = interIdx;
+                    break;
+                }
+                ancestor = ancestor.parent;
+            }
+            const fbxInv = fbxBoneInverses.get(bone.name);
+            const offsetMatrix = fbxInv ? Array.from(fbxInv.elements) : computeOffset(bone);
+            allBones.push({ name: bone.name, parentIndex, offsetMatrix });
+        }
+        for (const [obj, _idx] of intermediateMap) {
+            let parentIndex = -1;
+            let ancestor = obj.parent;
+            while (ancestor && ancestor !== group) {
+                const interIdx = intermediateMap.get(ancestor);
+                if (interIdx !== undefined) {
+                    parentIndex = interIdx;
+                    break;
+                }
+                ancestor = ancestor.parent;
+            }
+            allBones.push({
+                name: obj.name || '__armature',
+                parentIndex,
+                offsetMatrix: computeOffset(obj),
+            });
+        }
+    }
+    for (let mi = 0; mi < meshObjects.length; mi++) {
+        const mesh = meshObjects[mi];
+        const geometry = mesh.geometry;
+        const posAttr = geometry.getAttribute('position');
+        if (!posAttr)
+            continue;
+        const vertCount = posAttr.count;
+        const positions = new Float32Array(vertCount * 3);
+        {
+            const worldMatrix = mesh.matrixWorld;
+            const v = new THREE.Vector3();
+            for (let vi = 0; vi < vertCount; vi++) {
+                v.fromBufferAttribute(posAttr, vi);
+                v.applyMatrix4(worldMatrix);
+                positions[vi * 3] = v.x;
+                positions[vi * 3 + 1] = v.y;
+                positions[vi * 3 + 2] = v.z;
+            }
+        }
+        let normals = null;
+        const normAttr = geometry.getAttribute('normal');
+        if (normAttr && normAttr.count === vertCount) {
+            normals = new Float32Array(vertCount * 3);
+            const normalMatrix = new THREE.Matrix3().getNormalMatrix(mesh.matrixWorld);
+            const n = new THREE.Vector3();
+            for (let vi = 0; vi < vertCount; vi++) {
+                n.fromBufferAttribute(normAttr, vi);
+                n.applyMatrix3(normalMatrix).normalize();
+                normals[vi * 3] = n.x;
+                normals[vi * 3 + 1] = n.y;
+                normals[vi * 3 + 2] = n.z;
+            }
+        }
+        let uvs = null;
+        const uvAttr = geometry.getAttribute('uv');
+        if (uvAttr && uvAttr.count === vertCount) {
+            uvs = new Float32Array(vertCount * 2);
+            for (let vi = 0; vi < vertCount; vi++) {
+                uvs[vi * 2] = uvAttr.getX(vi);
+                uvs[vi * 2 + 1] = uvAttr.getY(vi);
+            }
+        }
+        const indexAttr = geometry.getIndex();
+        let indices;
+        if (indexAttr) {
+            indices = new Uint32Array(indexAttr.count);
+            for (let ii = 0; ii < indexAttr.count; ii++)
+                indices[ii] = indexAttr.getX(ii);
+        }
+        else {
+            indices = new Uint32Array(vertCount);
+            for (let ii = 0; ii < vertCount; ii++)
+                indices[ii] = ii;
+        }
+        let skinData;
+        if (mesh.isSkinnedMesh) {
+            const skinIndexAttr = geometry.getAttribute('skinIndex');
+            const skinWeightAttr = geometry.getAttribute('skinWeight');
+            if (skinIndexAttr && skinWeightAttr) {
+                const meshSkeleton = perMeshSkeletons.get(mesh);
+                let remap = null;
+                if (meshSkeleton) {
+                    remap = new Uint32Array(meshSkeleton.bones.length);
+                    for (let si = 0; si < meshSkeleton.bones.length; si++) {
+                        const idx = sceneBones.findIndex(b => b.name === meshSkeleton.bones[si].name);
+                        remap[si] = idx >= 0 ? idx : 0;
+                    }
+                }
+                const boneIndices = new Uint32Array(vertCount * 4);
+                const boneWeights = new Float32Array(vertCount * 4);
+                for (let vi = 0; vi < vertCount; vi++) {
+                    const si0 = skinIndexAttr.getX(vi);
+                    const si1 = skinIndexAttr.getY(vi);
+                    const si2 = skinIndexAttr.getZ(vi);
+                    const si3 = skinIndexAttr.getW(vi);
+                    boneIndices[vi * 4] = remap && si0 < remap.length ? remap[si0] : si0;
+                    boneIndices[vi * 4 + 1] = remap && si1 < remap.length ? remap[si1] : si1;
+                    boneIndices[vi * 4 + 2] = remap && si2 < remap.length ? remap[si2] : si2;
+                    boneIndices[vi * 4 + 3] = remap && si3 < remap.length ? remap[si3] : si3;
+                    boneWeights[vi * 4] = skinWeightAttr.getX(vi);
+                    boneWeights[vi * 4 + 1] = skinWeightAttr.getY(vi);
+                    boneWeights[vi * 4 + 2] = skinWeightAttr.getZ(vi);
+                    boneWeights[vi * 4 + 3] = skinWeightAttr.getW(vi);
+                }
+                skinData = { boneIndices, boneWeights };
+            }
+        }
+        const meshMaterial = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+        const matName = meshMaterial?.name || 'default';
+        let matIndex;
+        if (materialSet.has(matName)) {
+            matIndex = materialSet.get(matName);
+        }
+        else {
+            matIndex = materials.length;
+            materialSet.set(matName, matIndex);
+            materials.push({ name: matName });
+        }
+        subMeshes.push({ skinData, positions, normals, uvs, indices, materialIndex: matIndex });
+        nodes.push({
+            name: mesh.name || `mesh_${mi}`,
+            parentIndex: -1,
+            position: [0, 0, 0],
+            rotation: [0, 0, 0, 1],
+            scale: [1, 1, 1],
+            meshIndices: [mi],
+        });
+    }
+    if (materials.length === 0)
+        materials.push({ name: 'default' });
+    return {
+        subMeshes,
+        materials,
+        nodes,
+        hasSkeleton,
+        bones: allBones,
+        animations: [],
+    };
+}
+function emptyMesh() {
+    return { subMeshes: [], materials: [{ name: 'default' }], nodes: [], hasSkeleton: false, bones: [], animations: [] };
+}
+// ─── fbx-parser animation extraction ─────────────────────────────────────────
+const FBX_TICKS_PER_SECOND = 46186158000;
+const DEG2RAD = Math.PI / 180;
+function isArrayLike(v) {
+    return Array.isArray(v) || ArrayBuffer.isView(v);
+}
+function parseFbxAnimations(data) {
+    let fbx;
+    try {
+        fbx = fbxParseBinary(data);
+    }
+    catch {
+        try {
+            fbx = fbxParseText(new TextDecoder().decode(data));
+        }
+        catch {
+            return [];
+        }
+    }
+    const reader = new FBXReader(fbx);
+    const objects = reader.node('Objects');
+    const connectionsNode = reader.node('Connections');
+    if (!objects || !connectionsNode)
+        return [];
+    let unitScale = 0.01;
+    const globalSettings = reader.node('GlobalSettings');
+    if (globalSettings) {
+        const props70 = globalSettings.fbxNode.nodes.find(n => n.name === 'Properties70');
+        if (props70) {
+            const unitProp = props70.nodes.find(n => n.name === 'P' && String(n.props[0]) === 'UnitScaleFactor');
+            if (unitProp) {
+                const raw = Number(unitProp.props[4]);
+                if (raw > 0)
+                    unitScale = raw / 100;
+            }
+        }
+    }
+    const connMap = new Map();
+    function getConn(id) {
+        let e = connMap.get(id);
+        if (!e) {
+            e = { parents: [], children: [] };
+            connMap.set(id, e);
+        }
+        return e;
+    }
+    for (const c of connectionsNode.fbxNode.nodes) {
+        if (c.name !== 'C')
+            continue;
+        const childID = c.props[1];
+        const parentID = c.props[2];
+        const rel = c.props.length > 3 ? String(c.props[3]) : undefined;
+        getConn(childID).parents.push({ id: parentID, rel });
+        getConn(parentID).children.push({ id: childID, rel });
+    }
+    const FBX_EULER_ORDER = ['ZYX', 'YZX', 'XZY', 'ZXY', 'YXZ', 'XYZ'];
+    const modelNames = new Map();
+    const modelInfo = new Map();
+    for (const node of objects.fbxNode.nodes) {
+        if (node.name !== 'Model')
+            continue;
+        const id = node.props[0];
+        const rawName = String(node.props[1] ?? '');
+        const name = rawName.includes('\x00\x01') ? rawName.split('\x00\x01')[0] : rawName.replace(/^Model::/, '');
+        if (!name)
+            continue;
+        modelNames.set(id, name);
+        let preRotation;
+        let postRotation;
+        let eulerOrder = 'ZYX';
+        const props70 = node.nodes.find(n => n.name === 'Properties70');
+        if (props70) {
+            for (const p of props70.nodes) {
+                if (p.name !== 'P')
+                    continue;
+                const pn = String(p.props[0]);
+                if (pn === 'PreRotation')
+                    preRotation = [Number(p.props[4]), Number(p.props[5]), Number(p.props[6])];
+                else if (pn === 'PostRotation')
+                    postRotation = [Number(p.props[4]), Number(p.props[5]), Number(p.props[6])];
+                else if (pn === 'RotationOrder') {
+                    const idx = Number(p.props[4]);
+                    if (idx >= 0 && idx < FBX_EULER_ORDER.length)
+                        eulerOrder = FBX_EULER_ORDER[idx];
+                }
+            }
+        }
+        modelInfo.set(id, { preRotation, postRotation, eulerOrder });
+    }
+    const curveNodeMap = new Map();
+    for (const node of objects.fbxNode.nodes) {
+        if (node.name !== 'AnimationCurveNode')
+            continue;
+        const id = node.props[0];
+        const rawName = String(node.props[1] ?? '');
+        const cleaned = rawName.includes('\x00\x01') ? rawName.split('\x00\x01')[0] : rawName;
+        let attr = null;
+        if (cleaned === 'T' || cleaned === 'Lcl Translation' || cleaned.endsWith('::T'))
+            attr = 'T';
+        else if (cleaned === 'R' || cleaned === 'Lcl Rotation' || cleaned.endsWith('::R'))
+            attr = 'R';
+        else if (cleaned === 'S' || cleaned === 'Lcl Scaling' || cleaned.endsWith('::S'))
+            attr = 'S';
+        if (attr)
+            curveNodeMap.set(id, { id, attr, curves: {} });
+    }
+    if (curveNodeMap.size === 0)
+        return [];
+    for (const node of objects.fbxNode.nodes) {
+        if (node.name !== 'AnimationCurve')
+            continue;
+        const curveId = node.props[0];
+        const keyTimeNode = node.nodes.find(n => n.name === 'KeyTime');
+        const keyValueNode = node.nodes.find(n => n.name === 'KeyValueFloat');
+        if (!keyTimeNode || !keyValueNode)
+            continue;
+        const rawTimes = keyTimeNode.props[0];
+        const rawValues = keyValueNode.props[0];
+        if (!isArrayLike(rawTimes) || !isArrayLike(rawValues))
+            continue;
+        const timesArr = Array.from(rawTimes);
+        const times = timesArr.map(t => Number(t) / FBX_TICKS_PER_SECOND);
+        const values = Array.isArray(rawValues) ? rawValues : Array.from(rawValues);
+        const conn = connMap.get(curveId);
+        if (!conn)
+            continue;
+        for (const parent of conn.parents) {
+            const curveNode = curveNodeMap.get(parent.id);
+            if (!curveNode)
+                continue;
+            const rel = parent.rel ?? '';
+            const curve = { times, values };
+            if (rel.includes('d|X'))
+                curveNode.curves.x = curve;
+            else if (rel.includes('d|Y'))
+                curveNode.curves.y = curve;
+            else if (rel.includes('d|Z'))
+                curveNode.curves.z = curve;
+        }
+    }
+    const targetedNodes = [];
+    for (const [, cn] of curveNodeMap) {
+        if (!cn.curves.x && !cn.curves.y && !cn.curves.z)
+            continue;
+        const conn = connMap.get(cn.id);
+        if (!conn)
+            continue;
+        for (const parent of conn.parents) {
+            const name = modelNames.get(parent.id);
+            if (name) {
+                targetedNodes.push({ modelName: name, modelId: parent.id, attr: cn.attr, curves: cn.curves });
+                break;
+            }
+        }
+    }
+    if (targetedNodes.length === 0)
+        return [];
+    let clipName = 'default';
+    let clipDuration = 0;
+    for (const node of objects.fbxNode.nodes) {
+        if (node.name !== 'AnimationStack')
+            continue;
+        const rawName = String(node.props[1] ?? 'default');
+        clipName = rawName.includes('\x00\x01') ? rawName.split('\x00\x01')[0] : rawName;
+        const props70 = node.nodes.find(n => n.name === 'Properties70');
+        if (props70) {
+            const localStop = props70.nodes.find(n => n.name === 'P' && String(n.props[0]) === 'LocalStop');
+            if (localStop) {
+                const val = localStop.props[4];
+                const num = typeof val === 'bigint' ? Number(val) : Number(val);
+                if (num > 0)
+                    clipDuration = num / FBX_TICKS_PER_SECOND;
+            }
+        }
+        break;
+    }
+    const defaultEulerOrder = 'ZYX';
+    const tracks = [];
+    for (const tn of targetedNodes) {
+        const refCurve = tn.curves.x || tn.curves.y || tn.curves.z;
+        if (!refCurve)
+            continue;
+        const keyCount = refCurve.times.length;
+        const times = new Float32Array(refCurve.times);
+        const info = modelInfo.get(tn.modelId);
+        const sanitizedName = PropertyBinding.sanitizeNodeName(tn.modelName);
+        if (tn.attr === 'T') {
+            const values = new Float32Array(keyCount * 3);
+            for (let k = 0; k < keyCount; k++) {
+                values[k * 3] = (tn.curves.x?.values[k] ?? 0) * unitScale;
+                values[k * 3 + 1] = (tn.curves.y?.values[k] ?? 0) * unitScale;
+                values[k * 3 + 2] = (tn.curves.z?.values[k] ?? 0) * unitScale;
+            }
+            tracks.push({ name: `${sanitizedName}.position`, times, values, valuesPerKey: 3 });
+            if (clipDuration === 0 && keyCount > 0)
+                clipDuration = Math.max(clipDuration, times[keyCount - 1]);
+        }
+        else if (tn.attr === 'R') {
+            const eulerOrder = info?.eulerOrder ?? defaultEulerOrder;
+            let preRotQuat = null;
+            if (info?.preRotation) {
+                const pr = info.preRotation;
+                preRotQuat = new THREE.Quaternion().setFromEuler(new THREE.Euler(pr[0] * DEG2RAD, pr[1] * DEG2RAD, pr[2] * DEG2RAD, defaultEulerOrder));
+            }
+            let postRotQuat = null;
+            if (info?.postRotation) {
+                const po = info.postRotation;
+                postRotQuat = new THREE.Quaternion().setFromEuler(new THREE.Euler(po[0] * DEG2RAD, po[1] * DEG2RAD, po[2] * DEG2RAD, defaultEulerOrder)).invert();
+            }
+            const values = new Float32Array(keyCount * 4);
+            const euler = new THREE.Euler();
+            const quat = new THREE.Quaternion();
+            const prevQuat = new THREE.Quaternion();
+            for (let k = 0; k < keyCount; k++) {
+                euler.set((tn.curves.x?.values[k] ?? 0) * DEG2RAD, (tn.curves.y?.values[k] ?? 0) * DEG2RAD, (tn.curves.z?.values[k] ?? 0) * DEG2RAD, eulerOrder);
+                quat.setFromEuler(euler);
+                if (preRotQuat)
+                    quat.premultiply(preRotQuat);
+                if (postRotQuat)
+                    quat.multiply(postRotQuat);
+                if (k > 0 && quat.dot(prevQuat) < 0) {
+                    quat.x = -quat.x;
+                    quat.y = -quat.y;
+                    quat.z = -quat.z;
+                    quat.w = -quat.w;
+                }
+                values[k * 4] = quat.x;
+                values[k * 4 + 1] = quat.y;
+                values[k * 4 + 2] = quat.z;
+                values[k * 4 + 3] = quat.w;
+                prevQuat.copy(quat);
+            }
+            tracks.push({ name: `${sanitizedName}.quaternion`, times, values, valuesPerKey: 4 });
+            if (clipDuration === 0 && keyCount > 0)
+                clipDuration = Math.max(clipDuration, times[keyCount - 1]);
+        }
+        else if (tn.attr === 'S') {
+            const values = new Float32Array(keyCount * 3);
+            for (let k = 0; k < keyCount; k++) {
+                values[k * 3] = tn.curves.x?.values[k] ?? 1;
+                values[k * 3 + 1] = tn.curves.y?.values[k] ?? 1;
+                values[k * 3 + 2] = tn.curves.z?.values[k] ?? 1;
+            }
+            tracks.push({ name: `${sanitizedName}.scale`, times, values, valuesPerKey: 3 });
+        }
+    }
+    if (tracks.length === 0)
+        return [];
+    return [{ name: clipName, duration: clipDuration, tracks }];
+}

package/dist/encoders/image-decoder.d.ts

@@ -0,0 +1,13 @@
+import type { IImageDecoder } from './interfaces.js';
+export declare class SharpImageDecoder implements IImageDecoder {
+    loadPixels(data: Uint8Array): Promise<{
+        pixels: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+    resizePixels(pixels: Uint8Array, width: number, height: number, divisor: number): Promise<{
+        pixels: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+}

package/dist/encoders/image-decoder.js

@@ -0,0 +1,33 @@
+import sharp from 'sharp';
+export class SharpImageDecoder {
+    async loadPixels(data) {
+        const image = sharp(Buffer.from(data));
+        const metadata = await image.metadata();
+        const { data: rawPixels, info } = await image
+            .ensureAlpha()
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        return {
+            pixels: new Uint8Array(rawPixels.buffer, rawPixels.byteOffset, rawPixels.byteLength),
+            width: info.width,
+            height: info.height,
+        };
+    }
+    async resizePixels(pixels, width, height, divisor) {
+        if (divisor <= 1)
+            return { pixels, width, height };
+        const newW = Math.max(1, Math.floor(width / divisor));
+        const newH = Math.max(1, Math.floor(height / divisor));
+        const { data: resizedPixels, info } = await sharp(Buffer.from(pixels), {
+            raw: { width, height, channels: 4 },
+        })
+            .resize(newW, newH)
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        return {
+            pixels: new Uint8Array(resizedPixels.buffer, resizedPixels.byteOffset, resizedPixels.byteLength),
+            width: info.width,
+            height: info.height,
+        };
+    }
+}

package/dist/encoders/interfaces.d.ts

@@ -0,0 +1,105 @@
+import type { KTX2Quality, TextureChannelFormat, TextureMetadata, MeshMetadata } from '../core/types.js';
+export interface TextureEncodeResult {
+    data: Uint8Array;
+    metadata: TextureMetadata;
+}
+export interface ITextureEncoder {
+    encode(pixels: Uint8Array, width: number, height: number, channels: number, quality: KTX2Quality, channelFormat: TextureChannelFormat, generateMipmaps?: boolean): Promise<TextureEncodeResult>;
+    isReady(): boolean;
+    initialize(): Promise<void>;
+}
+export interface ImportedSubMesh {
+    skinData?: ImportedSkinData;
+    positions: Float32Array;
+    normals: Float32Array | null;
+    uvs: Float32Array | null;
+    indices: Uint32Array;
+    materialIndex: number;
+}
+export interface ImportedMaterial {
+    name: string;
+}
+export interface ImportedNode {
+    name: string;
+    parentIndex: number;
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: [number, number, number];
+    meshIndices: number[];
+}
+export interface ImportedMesh {
+    subMeshes: ImportedSubMesh[];
+    materials: ImportedMaterial[];
+    nodes: ImportedNode[];
+    hasSkeleton: boolean;
+    bones: ImportedBone[];
+    animations: ImportedAnimation[];
+}
+export interface IMeshImporter {
+    import(data: Uint8Array, fileName: string): Promise<ImportedMesh>;
+}
+export interface MeshEncodeSettings {
+    compressionLevel: number;
+    positionQuantization: number;
+    normalQuantization: number;
+    uvQuantization: number;
+    scaleFactor: number;
+}
+export interface MeshEncodeResult {
+    data: Uint8Array;
+    metadata: MeshMetadata;
+}
+export interface IMeshEncoder {
+    encode(mesh: ImportedMesh, settings: MeshEncodeSettings): Promise<MeshEncodeResult>;
+    isReady(): boolean;
+    initialize(): Promise<void>;
+}
+export interface ImportedAnimationChannel {
+    boneName: string;
+    property: 'position' | 'quaternion' | 'scale';
+    times: Float32Array;
+    values: Float32Array;
+}
+export interface ImportedAnimationTrack {
+    name: string;
+    times: Float32Array;
+    values: Float32Array;
+    valuesPerKey: number;
+}
+export interface ImportedAnimation {
+    name: string;
+    duration: number;
+    tracks: ImportedAnimationTrack[];
+}
+export interface ImportedBone {
+    name: string;
+    parentIndex: number;
+    offsetMatrix: number[];
+}
+export interface ImportedSkinData {
+    boneIndices: Uint32Array;
+    boneWeights: Float32Array;
+}
+export interface DecodedPcm {
+    channels: Float32Array[];
+    sampleRate: number;
+    durationMs: number;
+}
+export interface IAudioDecoder {
+    decodeToPcm(audioData: Uint8Array, fileName: string): Promise<DecodedPcm>;
+}
+export interface IAacEncoder {
+    encode(channels: Float32Array[], sampleRate: number, quality: import('../core/types.js').AacQuality): Promise<Uint8Array>;
+}
+export interface IImageDecoder {
+    loadPixels(data: Uint8Array): Promise<{
+        pixels: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+    resizePixels(pixels: Uint8Array, width: number, height: number, divisor: number): Promise<{
+        pixels: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+}

package/dist/encoders/interfaces.js

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