@series-inc/stowkit-cli 0.1.0

package/dist/pipeline.js

@@ -0,0 +1,354 @@
+import { AssetType, TextureChannelFormat, TextureResize, AudioSampleRate } from './core/types.js';
+import { dracoPresetToSettings } from './encoders/draco-encoder.js';
+import { buildSkinnedMeshData } from './encoders/skinned-mesh-builder.js';
+import { serializeTextureMetadata, serializeAudioMetadata, serializeMeshMetadata, serializeAnimationClipMetadata, serializeSkinnedMeshMetadata, serializeMaterialSchemaMetadata, deserializeSkinnedMeshMetadata, deserializeAnimationClipMetadata, } from './format/metadata.js';
+import { StowPacker } from './format/packer.js';
+import { BlobStore } from './app/blob-store.js';
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function resizeDivisor(resize) {
+    switch (resize) {
+        case TextureResize.Full: return 1;
+        case TextureResize.Half: return 2;
+        case TextureResize.Quarter: return 4;
+        case TextureResize.Eighth: return 8;
+    }
+}
+function flipPixelsY(pixels, width, height, channels) {
+    const rowBytes = width * channels;
+    const temp = new Uint8Array(rowBytes);
+    for (let y = 0; y < Math.floor(height / 2); y++) {
+        const topOffset = y * rowBytes;
+        const botOffset = (height - 1 - y) * rowBytes;
+        temp.set(pixels.subarray(topOffset, topOffset + rowBytes));
+        pixels.copyWithin(topOffset, botOffset, botOffset + rowBytes);
+        pixels.set(temp, botOffset);
+    }
+}
+function resampleChannel(src, srcRate, dstRate) {
+    if (dstRate >= srcRate)
+        return src;
+    const ratio = srcRate / dstRate;
+    const dstLen = Math.ceil(src.length / ratio);
+    const dst = new Float32Array(dstLen);
+    for (let i = 0; i < dstLen; i++) {
+        const srcIdx = i * ratio;
+        const lo = Math.floor(srcIdx);
+        const hi = Math.min(lo + 1, src.length - 1);
+        const frac = srcIdx - lo;
+        dst[i] = src[lo] + frac * (src[hi] - src[lo]);
+    }
+    return dst;
+}
+export async function processAsset(id, sourceData, type, stringId, settings, ctx) {
+    const log = (msg) => ctx.onProgress?.(id, msg);
+    if (type === AssetType.Texture2D) {
+        log('decoding image...');
+        let { pixels, width, height } = await ctx.imageDecoder.loadPixels(sourceData);
+        const divisor = resizeDivisor(settings.resize);
+        if (divisor > 1) {
+            ({ pixels, width, height } = await ctx.imageDecoder.resizePixels(pixels, width, height, divisor));
+            log(`resized to ${width}x${height}`);
+        }
+        flipPixelsY(pixels, width, height, 4);
+        log('encoding KTX2...');
+        const result = await ctx.textureEncoder.encode(pixels, width, height, 4, settings.quality, TextureChannelFormat.RGBA, settings.generateMipmaps);
+        result.metadata.stringId = stringId;
+        BlobStore.setProcessed(id, result.data);
+        log(`KTX2 encoded (${(result.data.length / 1024).toFixed(0)} KB)`);
+        return { metadata: result.metadata, processedSize: result.data.length };
+    }
+    if (type === AssetType.StaticMesh) {
+        log('importing FBX...');
+        const imported = await ctx.meshImporter.import(sourceData, id);
+        const verts = imported.subMeshes.reduce((s, m) => s + m.positions.length / 3, 0);
+        log(`imported (${verts} verts, ${imported.subMeshes.length} submeshes)`);
+        const meshSettings = dracoPresetToSettings(settings.dracoQuality);
+        const result = await ctx.meshEncoder.encode(imported, meshSettings);
+        result.metadata.stringId = stringId;
+        BlobStore.setProcessed(id, result.data);
+        log(`Draco encoded (${(result.data.length / 1024).toFixed(0)} KB)`);
+        return { metadata: result.metadata, processedSize: result.data.length };
+    }
+    if (type === AssetType.SkinnedMesh) {
+        log('importing FBX...');
+        const imported = await ctx.meshImporter.import(sourceData, id);
+        const animCount = imported.animations?.length ?? 0;
+        log(`imported (${imported.bones?.length ?? 0} bones, ${animCount} clips)`);
+        const skinnedResult = buildSkinnedMeshData(imported, 0.01);
+        skinnedResult.metadata.stringId = stringId;
+        BlobStore.setProcessed(id, skinnedResult.data);
+        BlobStore.setProcessed(`${id}:skinnedMeta`, serializeSkinnedMeshMetadata(skinnedResult.metadata));
+        if (animCount > 0 && imported.animations) {
+            const animBlobs = buildAnimationDataBlobsV2(imported);
+            for (let ci = 0; ci < animBlobs.length; ci++) {
+                const ab = animBlobs[ci];
+                ab.metadata.stringId = animBlobs.length === 1
+                    ? `${stringId}_anim`
+                    : `${stringId}_anim_${ci}`;
+                ab.metadata.targetMeshId = stringId;
+                BlobStore.setProcessed(`${id}:anim:${ci}`, ab.data);
+                BlobStore.setProcessed(`${id}:animMeta:${ci}`, serializeAnimationClipMetadata(ab.metadata));
+            }
+            BlobStore.setProcessed(`${id}:animCount`, new Uint8Array([animBlobs.length]));
+        }
+        log(`skinned mesh built (${(skinnedResult.data.length / 1024).toFixed(0)} KB)`);
+        return { metadata: skinnedResult.metadata, processedSize: skinnedResult.data.length };
+    }
+    if (type === AssetType.AnimationClip) {
+        log('importing FBX...');
+        const imported = await ctx.meshImporter.import(sourceData, id);
+        const animCount = imported.animations?.length ?? 0;
+        if (animCount === 0)
+            throw new Error('No animation clips found in FBX file');
+        const animBlobs = buildAnimationDataBlobsV2(imported);
+        if (animBlobs.length === 0)
+            throw new Error('All animation tracks were stripped');
+        const primary = animBlobs[0];
+        primary.metadata.stringId = stringId;
+        BlobStore.setProcessed(id, primary.data);
+        BlobStore.setProcessed(`${id}:animMeta`, serializeAnimationClipMetadata(primary.metadata));
+        for (let ci = 1; ci < animBlobs.length; ci++) {
+            const ab = animBlobs[ci];
+            ab.metadata.stringId = `${stringId}_${ci}`;
+            BlobStore.setProcessed(`${id}:anim:${ci}`, ab.data);
+            BlobStore.setProcessed(`${id}:animMeta:${ci}`, serializeAnimationClipMetadata(ab.metadata));
+        }
+        BlobStore.setProcessed(`${id}:animCount`, new Uint8Array([animBlobs.length]));
+        const totalAnimBytes = animBlobs.reduce((s, a) => s + a.data.length, 0);
+        log(`animation serialized (${(totalAnimBytes / 1024).toFixed(0)} KB, ${animBlobs.length} clips)`);
+        return { metadata: primary.metadata, processedSize: totalAnimBytes };
+    }
+    if (type === AssetType.Audio) {
+        log('decoding audio...');
+        const pcm = await ctx.audioDecoder.decodeToPcm(sourceData, id);
+        log(`decoded (${pcm.sampleRate}Hz, ${pcm.channels.length}ch, ${pcm.durationMs}ms)`);
+        let { channels, sampleRate } = pcm;
+        const targetRate = settings.audioSampleRate;
+        if (targetRate !== AudioSampleRate.Auto && targetRate < sampleRate) {
+            channels = channels.map((ch) => resampleChannel(ch, sampleRate, targetRate));
+            sampleRate = targetRate;
+            log(`resampled to ${sampleRate}Hz`);
+        }
+        log('encoding AAC...');
+        const aacData = await ctx.aacEncoder.encode(channels, sampleRate, settings.aacQuality);
+        BlobStore.setProcessed(id, aacData);
+        const metadata = {
+            stringId,
+            sampleRate,
+            channels: pcm.channels.length,
+            durationMs: pcm.durationMs,
+        };
+        log(`AAC encoded (${(aacData.length / 1024).toFixed(0)} KB)`);
+        return { metadata, processedSize: aacData.length };
+    }
+    return { processedSize: 0 };
+}
+// ─── Build Pack ──────────────────────────────────────────────────────────────
+export function buildPack(assets, assetsById) {
+    const packer = new StowPacker();
+    const materialsByStringId = new Map(assets
+        .filter(a => a.type === AssetType.MaterialSchema)
+        .map(a => [a.stringId.toLowerCase(), a]));
+    for (const asset of assets) {
+        if (asset.status !== 'ready')
+            continue;
+        if (asset.type === AssetType.MaterialSchema) {
+            const schemaMeta = buildMaterialSchemaMetadata(asset, assetsById);
+            const schemaBytes = serializeMaterialSchemaMetadata(schemaMeta);
+            packer.addAsset(asset.stringId, AssetType.MaterialSchema, new Uint8Array(0), schemaBytes, asset.settings.tags);
+            continue;
+        }
+        const processedData = BlobStore.getProcessed(asset.id);
+        if (!processedData) {
+            console.warn(`[buildPack] Skipping ${asset.id} (type=${asset.type}): no processed data in BlobStore`);
+            continue;
+        }
+        let metadataBytes = null;
+        if (asset.type === AssetType.Texture2D && asset.metadata) {
+            metadataBytes = serializeTextureMetadata(asset.metadata);
+        }
+        else if (asset.type === AssetType.Audio && asset.metadata) {
+            metadataBytes = serializeAudioMetadata(asset.metadata);
+        }
+        else if (asset.type === AssetType.StaticMesh && asset.metadata) {
+            const meshMeta = applyMaterialAssignments(asset, asset.metadata, assetsById, materialsByStringId);
+            meshMeta.stringId = asset.stringId;
+            metadataBytes = serializeMeshMetadata(meshMeta);
+        }
+        else if (asset.type === AssetType.SkinnedMesh) {
+            const skinnedMetaBlob = BlobStore.getProcessed(`${asset.id}:skinnedMeta`);
+            if (skinnedMetaBlob) {
+                const skinnedMeta = deserializeSkinnedMeshMetadata(skinnedMetaBlob);
+                const patched = applyMaterialAssignments(asset, skinnedMeta, assetsById, materialsByStringId);
+                patched.stringId = asset.stringId;
+                metadataBytes = serializeSkinnedMeshMetadata(patched);
+            }
+            else {
+                metadataBytes = null;
+            }
+        }
+        else if (asset.type === AssetType.AnimationClip) {
+            const animMetaBlob = BlobStore.getProcessed(`${asset.id}:animMeta`);
+            if (animMetaBlob) {
+                const animMeta = deserializeAnimationClipMetadata(animMetaBlob);
+                animMeta.stringId = asset.stringId;
+                if (asset.settings.targetMeshId) {
+                    const targetMesh = assetsById.get(asset.settings.targetMeshId);
+                    animMeta.targetMeshId = targetMesh?.type === AssetType.SkinnedMesh ? targetMesh.stringId : '';
+                }
+                metadataBytes = serializeAnimationClipMetadata(animMeta);
+            }
+        }
+        packer.addAsset(asset.stringId, asset.type, processedData, metadataBytes, asset.settings.tags);
+        // Embedded animations for skinned meshes
+        if (asset.type === AssetType.SkinnedMesh) {
+            const animCountBlob = BlobStore.getProcessed(`${asset.id}:animCount`);
+            const clipCount = animCountBlob ? animCountBlob[0] : 0;
+            for (let ci = 0; ci < clipCount; ci++) {
+                const animData = BlobStore.getProcessed(`${asset.id}:anim:${ci}`);
+                const animMeta = BlobStore.getProcessed(`${asset.id}:animMeta:${ci}`);
+                if (animData && animMeta) {
+                    const meta = JSON.parse(new TextDecoder().decode(animMeta));
+                    packer.addAsset(meta.stringId, AssetType.AnimationClip, animData, animMeta, []);
+                }
+            }
+        }
+    }
+    return packer.build();
+}
+// ─── Material Assignment Resolution ─────────────────────────────────────────
+function resolveAssignedMaterial(meshAsset, subMeshIndex, sourceMaterialName, assetsById, materialsByStringId) {
+    const explicitId = meshAsset.settings.materialOverrides[subMeshIndex];
+    if (explicitId !== undefined) {
+        if (!explicitId)
+            return null;
+        const explicitAsset = assetsById.get(explicitId);
+        return explicitAsset?.type === AssetType.MaterialSchema ? explicitAsset : null;
+    }
+    if (!sourceMaterialName)
+        return null;
+    return materialsByStringId.get(sourceMaterialName.toLowerCase()) ?? null;
+}
+function toMaterialPropertyValue(prop, assetsById) {
+    const textureAsset = prop.textureAssetId ? assetsById.get(prop.textureAssetId) : undefined;
+    return {
+        fieldName: prop.fieldName,
+        value: [prop.value[0], prop.value[1], prop.value[2], prop.value[3]],
+        textureId: textureAsset?.stringId ?? '',
+    };
+}
+function applyMaterialAssignments(meshAsset, metadata, assetsById, materialsByStringId) {
+    const materials = metadata.materials.map((m) => ({
+        name: m.name,
+        schemaId: m.schemaId,
+        propertyCount: m.properties.length,
+        properties: m.properties.map((p) => ({
+            fieldName: p.fieldName,
+            value: [p.value[0], p.value[1], p.value[2], p.value[3]],
+            textureId: p.textureId,
+        })),
+    }));
+    for (let i = 0; i < materials.length; i++) {
+        const assigned = resolveAssignedMaterial(meshAsset, i, metadata.materials[i]?.name ?? '', assetsById, materialsByStringId);
+        if (!assigned)
+            continue;
+        const config = assigned.settings.materialConfig;
+        const propertyValues = config.properties
+            .filter((prop) => prop.fieldName.trim().length > 0)
+            .map((prop) => toMaterialPropertyValue(prop, assetsById));
+        materials[i].schemaId = config.schemaId || assigned.stringId;
+        materials[i].properties = propertyValues;
+        materials[i].propertyCount = propertyValues.length;
+    }
+    return { ...metadata, materials, materialCount: materials.length };
+}
+// ─── Material Schema Metadata Builder ───────────────────────────────────────
+function buildMaterialSchemaMetadata(asset, assetsById) {
+    const fields = asset.settings.materialConfig.properties
+        .filter((prop) => prop.fieldName.trim().length > 0)
+        .map((prop) => {
+        const textureAsset = prop.textureAssetId
+            ? assetsById.get(prop.textureAssetId)
+            : undefined;
+        return {
+            name: prop.fieldName,
+            fieldType: prop.fieldType,
+            previewFlags: prop.previewFlag,
+            defaultValue: [...prop.value],
+            defaultTextureId: prop.fieldType === 0 // MaterialFieldType.Texture
+                ? (textureAsset?.stringId ?? '')
+                : '',
+        };
+    });
+    return {
+        stringId: asset.stringId,
+        schemaName: asset.fileName,
+        fieldCount: fields.length,
+        fields,
+    };
+}
+// ─── Animation data blob builder (v2) ────────────────────────────────────────
+export function buildAnimationDataBlobsV2(imported) {
+    const results = [];
+    for (const clip of imported.animations) {
+        const clipTracks = clip.tracks;
+        if (!clipTracks || !Array.isArray(clipTracks) || clipTracks.length === 0)
+            continue;
+        const preparedTracks = [];
+        for (const track of clipTracks) {
+            const keyframeCount = Math.min(track.times.length, Math.floor(track.values.length / track.valuesPerKey));
+            if (keyframeCount <= 0)
+                continue;
+            const times = track.times.subarray(0, keyframeCount);
+            const values = track.values.subarray(0, keyframeCount * track.valuesPerKey);
+            // Strip scale tracks
+            if (track.name.endsWith('.scale'))
+                continue;
+            preparedTracks.push({
+                trackName: track.name,
+                keyframeCount,
+                valuesPerKey: track.valuesPerKey,
+                times,
+                values,
+            });
+        }
+        let dataSize = 0;
+        const trackDescriptors = [];
+        for (const track of preparedTracks) {
+            const timesOffset = dataSize;
+            dataSize += track.keyframeCount * 4;
+            const valuesOffset = dataSize;
+            dataSize += track.keyframeCount * track.valuesPerKey * 4;
+            trackDescriptors.push({
+                trackName: track.trackName,
+                keyframeCount: track.keyframeCount,
+                valuesPerKey: track.valuesPerKey,
+                timesOffset,
+                valuesOffset,
+            });
+        }
+        const data = new Uint8Array(dataSize);
+        const view = new DataView(data.buffer);
+        let offset = 0;
+        for (const track of preparedTracks) {
+            for (let i = 0; i < track.keyframeCount; i++) {
+                view.setFloat32(offset, track.times[i], true);
+                offset += 4;
+            }
+            for (let i = 0; i < track.keyframeCount * track.valuesPerKey; i++) {
+                view.setFloat32(offset, track.values[i], true);
+                offset += 4;
+            }
+        }
+        const metadata = {
+            stringId: clip.name || 'default',
+            targetMeshId: '',
+            metadataVersion: 2,
+            duration: clip.duration,
+            trackCount: trackDescriptors.length,
+            tracks: trackDescriptors,
+        };
+        results.push({ data, metadata });
+    }
+    return results;
+}

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+import * as http from 'node:http';
+export interface ServerOptions {
+    port?: number;
+    projectDir?: string;
+    wasmDir?: string;
+    /** Static apps to serve. Key = URL prefix (e.g. '/packer'), value = directory path. Use '/' for root. */
+    staticApps?: Record<string, string>;
+}
+export declare function startServer(opts?: ServerOptions): Promise<http.Server>;