@playcraft/cli 0.0.40 → 0.0.42

package/dist/commands/3d.js

@@ -0,0 +1,363 @@
+import { existsSync, mkdirSync, readFileSync, statSync, } from 'fs';
+import { basename, dirname, extname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PRIMITIVES_DIR = join(__dirname, '../../assets/models/primitives');
+const PRIMITIVES_METADATA = join(PRIMITIVES_DIR, 'metadata.json');
+// ─────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────
+function sizeLabel(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+}
+function handleError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+}
+function ensureOutputDir(outputPath) {
+    const dir = dirname(resolve(outputPath));
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+function loadPrimitivesMetadata() {
+    if (!existsSync(PRIMITIVES_METADATA)) {
+        console.error(`Error: primitives metadata not found at ${PRIMITIVES_METADATA}`);
+        console.error('Run: npx tsx scripts/generate-primitives.ts (from packages/cli)');
+        process.exit(1);
+    }
+    const raw = JSON.parse(readFileSync(PRIMITIVES_METADATA, 'utf-8'));
+    return raw.primitives;
+}
+// ─────────────────────────────────────────────────────────
+// list-models
+// ─────────────────────────────────────────────────────────
+function registerListModelsCmd(parent) {
+    parent
+        .command('list-models')
+        .description('List all bundled white model primitives')
+        .option('--json', 'Output as JSON')
+        .action((opts) => {
+        try {
+            const primitives = loadPrimitivesMetadata();
+            if (opts.json) {
+                console.log(JSON.stringify({ primitives }, null, 2));
+                return;
+            }
+            console.log('\nBundled White Model Primitives:\n');
+            for (const p of primitives) {
+                const filePath = join(PRIMITIVES_DIR, p.file);
+                const size = existsSync(filePath) ? sizeLabel(statSync(filePath).size) : 'missing';
+                const dim = `${p.dimensions.width}×${p.dimensions.height}×${p.dimensions.depth}`;
+                console.log(`  ${p.name.padEnd(12)} ${size.padEnd(8)} UV:${p.uvType.padEnd(14)} ${p.description}`);
+                console.log(`               Best for: ${p.bestFor.join(', ')}`);
+            }
+            console.log(`\nUsage: playcraft 3d apply-texture --model <name> --texture <img> --output <out.glb>`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+// ─────────────────────────────────────────────────────────
+// info
+// ─────────────────────────────────────────────────────────
+function registerInfoCmd(parent) {
+    parent
+        .command('info <model>')
+        .description('Show info about a GLB file or bundled white model')
+        .option('--json', 'Output as JSON')
+        .action(async (model, opts) => {
+        try {
+            const { NodeIO } = await import('@gltf-transform/core');
+            let filePath = model;
+            // Check if it's a bundled primitive name (no extension)
+            if (!extname(model) && !existsSync(model)) {
+                const primitives = loadPrimitivesMetadata();
+                const found = primitives.find((p) => p.name === model);
+                if (found) {
+                    filePath = join(PRIMITIVES_DIR, found.file);
+                }
+                else {
+                    console.error(`Error: model '${model}' not found. Use 'playcraft 3d list-models' to see available models.`);
+                    process.exit(1);
+                }
+            }
+            if (!existsSync(filePath)) {
+                console.error(`Error: file not found: ${filePath}`);
+                process.exit(1);
+            }
+            const io = new NodeIO();
+            const doc = await io.read(filePath);
+            const root = doc.getRoot();
+            const meshes = root.listMeshes();
+            const meshInfo = meshes.map((mesh) => {
+                const primitives = mesh.listPrimitives();
+                return {
+                    name: mesh.getName(),
+                    primitives: primitives.map((prim) => {
+                        const posAttr = prim.getAttribute('POSITION');
+                        const normAttr = prim.getAttribute('NORMAL');
+                        const uvAttr = prim.getAttribute('TEXCOORD_0');
+                        const indices = prim.getIndices();
+                        const vertCount = posAttr?.getCount() ?? 0;
+                        const triCount = indices ? indices.getCount() / 3 : 0;
+                        return {
+                            vertices: vertCount,
+                            triangles: Math.round(triCount),
+                            hasNormals: !!normAttr,
+                            hasUVs: !!uvAttr,
+                        };
+                    }),
+                };
+            });
+            const fileSize = statSync(filePath).size;
+            const info = {
+                file: filePath,
+                size: sizeLabel(fileSize),
+                sizeBytes: fileSize,
+                meshes: meshInfo,
+                totalVertices: meshInfo.reduce((s, m) => s + m.primitives.reduce((ps, p) => ps + p.vertices, 0), 0),
+                totalTriangles: meshInfo.reduce((s, m) => s + m.primitives.reduce((ps, p) => ps + p.triangles, 0), 0),
+            };
+            if (opts.json) {
+                console.log(JSON.stringify(info, null, 2));
+                return;
+            }
+            console.log(`\nGLB Info: ${info.file}`);
+            console.log(`  Size: ${info.size}`);
+            console.log(`  Meshes: ${meshInfo.length}`);
+            console.log(`  Total vertices: ${info.totalVertices}`);
+            console.log(`  Total triangles: ${info.totalTriangles}`);
+            for (const mesh of meshInfo) {
+                for (const prim of mesh.primitives) {
+                    console.log(`    Normals: ${prim.hasNormals ? '✓' : '✗'}  UVs: ${prim.hasUVs ? '✓' : '✗'}`);
+                }
+            }
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+// ─────────────────────────────────────────────────────────
+// apply-texture
+// ─────────────────────────────────────────────────────────
+function registerApplyTextureCmd(parent) {
+    parent
+        .command('apply-texture')
+        .description('Apply an image texture to a white model GLB')
+        .requiredOption('--model <name>', 'Bundled primitive name (sphere, cube, etc.) or path to a GLB file')
+        .requiredOption('--texture <path>', 'Image file path (PNG/JPG/WebP) to use as base color texture')
+        .requiredOption('--output <path>', 'Output GLB file path')
+        .option('--scale <n>', 'Uniform scale factor (default: 1.0)', '1.0')
+        .option('--color <hex>', 'Solid base color instead of texture (e.g. "#FF4400")')
+        .option('--roughness <n>', 'Material roughness 0.0–1.0 (default: 0.8)', '0.8')
+        .option('--metallic <n>', 'Material metalness 0.0–1.0 (default: 0.0)', '0.0')
+        .action(async (opts) => {
+        try {
+            const { NodeIO, TextureChannel } = await import('@gltf-transform/core');
+            const sharp = (await import('sharp')).default;
+            // Resolve source GLB
+            let sourceGlb = opts.model;
+            if (!extname(opts.model) && !existsSync(opts.model)) {
+                const primitives = loadPrimitivesMetadata();
+                const found = primitives.find((p) => p.name === opts.model);
+                if (!found) {
+                    console.error(`Error: model '${opts.model}' not found. Use 'playcraft 3d list-models' to see available models.`);
+                    process.exit(1);
+                }
+                sourceGlb = join(PRIMITIVES_DIR, found.file);
+            }
+            if (!existsSync(sourceGlb)) {
+                console.error(`Error: GLB file not found: ${sourceGlb}`);
+                process.exit(1);
+            }
+            const io = new NodeIO();
+            const doc = await io.read(sourceGlb);
+            // Apply scale
+            const scale = parseFloat(opts.scale);
+            if (scale !== 1.0) {
+                for (const node of doc.getRoot().listNodes()) {
+                    const cur = node.getScale();
+                    node.setScale([cur[0] * scale, cur[1] * scale, cur[2] * scale]);
+                }
+            }
+            // Create/update material
+            for (const mesh of doc.getRoot().listMeshes()) {
+                for (const prim of mesh.listPrimitives()) {
+                    let mat = prim.getMaterial();
+                    if (!mat) {
+                        mat = doc.createMaterial('material');
+                        prim.setMaterial(mat);
+                    }
+                    const roughness = parseFloat(opts.roughness);
+                    const metallic = parseFloat(opts.metallic);
+                    mat.setRoughnessFactor(roughness);
+                    mat.setMetallicFactor(metallic);
+                    if (opts.color) {
+                        // Parse hex color
+                        const hex = opts.color.replace('#', '');
+                        const r = parseInt(hex.substring(0, 2), 16) / 255;
+                        const g = parseInt(hex.substring(2, 4), 16) / 255;
+                        const b = parseInt(hex.substring(4, 6), 16) / 255;
+                        mat.setBaseColorFactor([r, g, b, 1]);
+                        mat.setBaseColorTexture(null);
+                    }
+                    else if (opts.texture) {
+                        // Load texture image
+                        if (!existsSync(opts.texture)) {
+                            console.error(`Error: texture file not found: ${opts.texture}`);
+                            process.exit(1);
+                        }
+                        // Resize to power-of-2 for WebGL compatibility
+                        const imgInfo = await sharp(opts.texture).metadata();
+                        const w = imgInfo.width ?? 512;
+                        const h = imgInfo.height ?? 512;
+                        const pow2w = Math.pow(2, Math.ceil(Math.log2(Math.min(w, 1024))));
+                        const pow2h = Math.pow(2, Math.ceil(Math.log2(Math.min(h, 1024))));
+                        const imgBuffer = await sharp(opts.texture)
+                            .resize(pow2w, pow2h, { fit: 'fill' })
+                            .png()
+                            .toBuffer();
+                        const texture = doc
+                            .createTexture(basename(opts.texture))
+                            .setImage(imgBuffer)
+                            .setMimeType('image/png');
+                        mat.setBaseColorTexture(texture);
+                        mat.setBaseColorFactor([1, 1, 1, 1]);
+                    }
+                }
+            }
+            ensureOutputDir(opts.output);
+            await io.write(opts.output, doc);
+            const outSize = statSync(opts.output).size;
+            console.log(`Texture applied: ${opts.output} (${sizeLabel(outSize)})`);
+            if (opts.texture) {
+                console.log(`  Source model: ${sourceGlb}`);
+                console.log(`  Texture: ${opts.texture}`);
+            }
+            if (opts.color) {
+                console.log(`  Base color: ${opts.color}`);
+            }
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+// ─────────────────────────────────────────────────────────
+// convert
+// ─────────────────────────────────────────────────────────
+function registerConvertCmd(parent) {
+    parent
+        .command('convert')
+        .description('Convert between GLB and OBJ formats')
+        .requiredOption('--input <path>', 'Input file path (GLB)')
+        .requiredOption('--output <path>', 'Output file path (GLB or OBJ)')
+        .action(async (opts) => {
+        try {
+            const { NodeIO } = await import('@gltf-transform/core');
+            if (!existsSync(opts.input)) {
+                console.error(`Error: input file not found: ${opts.input}`);
+                process.exit(1);
+            }
+            const inExt = extname(opts.input).toLowerCase();
+            const outExt = extname(opts.output).toLowerCase();
+            if (!['.glb', '.gltf'].includes(inExt)) {
+                console.error('Error: input must be a .glb or .gltf file');
+                process.exit(1);
+            }
+            if (outExt === '.glb' || outExt === '.gltf') {
+                // GLB ↔ GLTF conversion
+                const io = new NodeIO();
+                const doc = await io.read(opts.input);
+                ensureOutputDir(opts.output);
+                await io.write(opts.output, doc);
+                const outSize = statSync(opts.output).size;
+                console.log(`Converted: ${opts.input} → ${opts.output} (${sizeLabel(outSize)})`);
+            }
+            else {
+                console.error('Error: output must be .glb or .gltf (OBJ export not yet supported)');
+                process.exit(1);
+            }
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+// ─────────────────────────────────────────────────────────
+// optimize
+// ─────────────────────────────────────────────────────────
+function registerOptimizeCmd(parent) {
+    parent
+        .command('optimize')
+        .description('Optimize a GLB to reduce file size (texture resize, dedup)')
+        .requiredOption('--input <path>', 'Input GLB file')
+        .requiredOption('--output <path>', 'Output optimized GLB file')
+        .option('--texture-size <n>', 'Max texture dimension (default: 512)', '512')
+        .option('--target-size <s>', 'Target size hint (e.g. 200KB) — informational only')
+        .action(async (opts) => {
+        try {
+            const { NodeIO, TextureChannel } = await import('@gltf-transform/core');
+            const { dedup, prune } = await import('@gltf-transform/functions');
+            void TextureChannel; // unused but imported for type context
+            if (!existsSync(opts.input)) {
+                console.error(`Error: input file not found: ${opts.input}`);
+                process.exit(1);
+            }
+            const origSize = statSync(opts.input).size;
+            const io = new NodeIO();
+            const doc = await io.read(opts.input);
+            const maxTexSize = parseInt(opts.textureSize, 10);
+            const sharp = (await import('sharp')).default;
+            // Resize textures that exceed maxTexSize using sharp
+            const textures = doc.getRoot().listTextures();
+            for (const tex of textures) {
+                const imgData = tex.getImage();
+                if (!imgData)
+                    continue;
+                const meta = await sharp(Buffer.from(imgData)).metadata();
+                const w = meta.width ?? 0;
+                const h = meta.height ?? 0;
+                if (w > maxTexSize || h > maxTexSize) {
+                    const resized = await sharp(Buffer.from(imgData))
+                        .resize(maxTexSize, maxTexSize, { fit: 'inside', withoutEnlargement: true })
+                        .png()
+                        .toBuffer();
+                    tex.setImage(new Uint8Array(resized)).setMimeType('image/png');
+                }
+            }
+            await doc.transform(dedup(), prune());
+            ensureOutputDir(opts.output);
+            await io.write(opts.output, doc);
+            const outSize = statSync(opts.output).size;
+            const saving = origSize - outSize;
+            const savingPct = ((saving / origSize) * 100).toFixed(1);
+            console.log(`Optimized: ${opts.output}`);
+            console.log(`  ${sizeLabel(origSize)} → ${sizeLabel(outSize)} (saved ${sizeLabel(saving)}, ${savingPct}%)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}
+// ─────────────────────────────────────────────────────────
+// Register all `playcraft 3d` subcommands
+// ─────────────────────────────────────────────────────────
+export function register3DCommands(program) {
+    const threeD = program
+        .command('3d')
+        .description('3D model utilities — white model library, texture application, GLB optimization');
+    registerListModelsCmd(threeD);
+    registerInfoCmd(threeD);
+    registerApplyTextureCmd(threeD);
+    registerConvertCmd(threeD);
+    registerOptimizeCmd(threeD);
+}