@series-inc/stowkit-cli 0.1.0

package/dist/encoders/draco-encoder.js

@@ -0,0 +1,155 @@
+import draco3d from 'draco3d';
+import { DracoQualityPreset } from '../core/types.js';
+// ─── Preset → Settings ──────────────────────────────────────────────────────
+export function dracoPresetToSettings(preset) {
+    switch (preset) {
+        case DracoQualityPreset.Fast:
+            return { compressionLevel: 3, positionQuantization: 11, normalQuantization: 8, uvQuantization: 10, scaleFactor: 1.0 };
+        case DracoQualityPreset.Balanced:
+            return { compressionLevel: 7, positionQuantization: 11, normalQuantization: 8, uvQuantization: 10, scaleFactor: 1.0 };
+        case DracoQualityPreset.HighQuality:
+            return { compressionLevel: 9, positionQuantization: 12, normalQuantization: 10, uvQuantization: 11, scaleFactor: 1.0 };
+        case DracoQualityPreset.MaximumQuality:
+            return { compressionLevel: 10, positionQuantization: 14, normalQuantization: 10, uvQuantization: 12, scaleFactor: 1.0 };
+    }
+}
+// ─── NodeDracoEncoder ─────────────────────────────────────────────────────────
+export class NodeDracoEncoder {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    draco = null;
+    ready = false;
+    isReady() {
+        return this.ready;
+    }
+    async initialize() {
+        this.draco = await draco3d.createEncoderModule({});
+        this.ready = true;
+    }
+    async encode(mesh, settings) {
+        if (!this.draco || !this.ready) {
+            throw new Error('Draco encoder not initialized');
+        }
+        const compressedBuffers = [];
+        const geometries = [];
+        let dataOffset = 0;
+        for (const sub of mesh.subMeshes) {
+            let positions = sub.positions;
+            if (settings.scaleFactor !== 1.0) {
+                positions = new Float32Array(sub.positions);
+                for (let i = 0; i < positions.length; i++) {
+                    positions[i] *= settings.scaleFactor;
+                }
+            }
+            const compressed = this.encodeSubMesh(positions, sub.normals, sub.uvs, sub.indices, settings);
+            const posMin = [Infinity, Infinity, Infinity];
+            const posMax = [-Infinity, -Infinity, -Infinity];
+            for (let i = 0; i < positions.length; i += 3) {
+                if (positions[i] < posMin[0])
+                    posMin[0] = positions[i];
+                if (positions[i + 1] < posMin[1])
+                    posMin[1] = positions[i + 1];
+                if (positions[i + 2] < posMin[2])
+                    posMin[2] = positions[i + 2];
+                if (positions[i] > posMax[0])
+                    posMax[0] = positions[i];
+                if (positions[i + 1] > posMax[1])
+                    posMax[1] = positions[i + 1];
+                if (positions[i + 2] > posMax[2])
+                    posMax[2] = positions[i + 2];
+            }
+            geometries.push({
+                vertexCount: positions.length / 3,
+                indexCount: sub.indices.length,
+                hasNormals: sub.normals ? 1 : 0,
+                hasUvs: sub.uvs ? 1 : 0,
+                compressedBufferOffset: dataOffset,
+                compressedBufferSize: compressed.length,
+                materialIndex: sub.materialIndex,
+                positionMin: posMin,
+                positionMax: posMax,
+            });
+            compressedBuffers.push(compressed);
+            dataOffset += compressed.length;
+        }
+        const totalSize = compressedBuffers.reduce((s, b) => s + b.length, 0);
+        const data = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const buf of compressedBuffers) {
+            data.set(buf, offset);
+            offset += buf.length;
+        }
+        const materials = mesh.materials.map((m) => ({
+            name: m.name,
+            schemaId: '',
+            propertyCount: 0,
+            properties: [],
+        }));
+        const meshIndicesFlat = [];
+        const sceneNodes = mesh.nodes.map((n) => {
+            const firstMeshIndex = meshIndicesFlat.length;
+            meshIndicesFlat.push(...n.meshIndices);
+            return {
+                name: n.name,
+                parentIndex: n.parentIndex,
+                position: n.position,
+                rotation: n.rotation,
+                scale: n.scale,
+                meshCount: n.meshIndices.length,
+                firstMeshIndex,
+            };
+        });
+        const metadata = {
+            meshGeometryCount: geometries.length,
+            materialCount: materials.length,
+            nodeCount: sceneNodes.length,
+            stringId: '',
+            geometries,
+            materials,
+            nodes: sceneNodes,
+            meshIndices: meshIndicesFlat,
+        };
+        return { data, metadata };
+    }
+    encodeSubMesh(positions, normals, uvs, indices, settings) {
+        const draco = this.draco;
+        const encoder = new draco.Encoder();
+        const mesh = new draco.Mesh();
+        const builder = new draco.MeshBuilder();
+        try {
+            const numFaces = indices.length / 3;
+            const numPoints = positions.length / 3;
+            builder.AddFacesToMesh(mesh, numFaces, indices);
+            builder.AddFloatAttributeToMesh(mesh, draco.POSITION, numPoints, 3, positions);
+            if (normals) {
+                builder.AddFloatAttributeToMesh(mesh, draco.NORMAL, numPoints, 3, normals);
+            }
+            if (uvs) {
+                builder.AddFloatAttributeToMesh(mesh, draco.TEX_COORD, numPoints, 2, uvs);
+            }
+            encoder.SetEncodingMethod(draco.MESH_SEQUENTIAL_ENCODING);
+            encoder.SetAttributeQuantization(draco.POSITION, settings.positionQuantization);
+            if (normals)
+                encoder.SetAttributeQuantization(draco.NORMAL, settings.normalQuantization);
+            if (uvs)
+                encoder.SetAttributeQuantization(draco.TEX_COORD, settings.uvQuantization);
+            const dracoBuffer = new draco.DracoInt8Array();
+            const encodedLen = encoder.EncodeMeshToDracoBuffer(mesh, dracoBuffer);
+            if (encodedLen === 0) {
+                draco.destroy(dracoBuffer);
+                throw new Error(`Draco encoding returned 0 bytes (${numPoints} verts, ${numFaces} faces)`);
+            }
+            // Copy from EncoderBuffer to Uint8Array
+            const result = new Uint8Array(encodedLen);
+            for (let i = 0; i < encodedLen; i++) {
+                result[i] = dracoBuffer.GetValue(i) & 0xff;
+            }
+            draco.destroy(dracoBuffer);
+            return result;
+        }
+        finally {
+            draco.destroy(mesh);
+            draco.destroy(builder);
+            draco.destroy(encoder);
+        }
+    }
+}

package/dist/encoders/fbx-loader.d.ts

@@ -0,0 +1,4 @@
+import type { IMeshImporter, ImportedMesh } from './interfaces.js';
+export declare class NodeFbxImporter implements IMeshImporter {
+    import(data: Uint8Array, _fileName: string): Promise<ImportedMesh>;
+}