// Lançador local da prova de conceito. Não é backend nem painel: só unifica os // comandos de Godot e FFmpeg. Uso: pnpm -- [opções] import fs from "node:fs"; import path from "node:path"; import { parseArgs, stringOption, numberOption, UsageError, type ParsedArgs } from "./lib/args.ts"; import { GODOT_OVERRIDE_FILE, GODOT_PROJECT_DIR, LOCK_FILE, OUTPUT_DIR, displayPath, displayToolPath, resolveFromRoot } from "./lib/paths.ts"; import { runProcess, succeeded, describeFailure } from "./lib/process.ts"; import { ffmpegEncoders, findTool, toolVersion, chooseVideoEncoder, MissingToolError, type ToolName, type Tool } from "./lib/tools.ts"; import { render, PROFILES, type ProfileName } from "./lib/render.ts"; import { evaluateProbe, probeVideo, type Expectation } from "./lib/verify.ts"; const DEFAULT_CONFIG = "config/demo-street.json"; const HELP = `CenaForge — prova de conceito de vídeo com Godot Comandos: pnpm run doctor checa executáveis, versões e diretórios (no pnpm 11, "pnpm doctor" é o diagnóstico do próprio pnpm) pnpm preview [-- --config ] abre a cena na Godot (tempo real) pnpm render -- --config --profile preview|final [--keep-frames] [--debug-frame-index] [--warmup-frames N] pnpm verify -- --file [--width N --height N --fps N --duration S --frames N] pnpm prepare-assets gera as fachadas distantes (headless) pnpm test testes do lançador e da lógica da cena Caminhos relativos partem da raiz do projeto.`; async function main(argv: string[]): Promise { const [command, ...rest] = argv.filter((a, i) => !(i === 0 && a === "--")); const args = parseArgs(rest); switch (command) { case "doctor": return doctor(); case "preview": return preview(args); case "render": return renderCommand(args); case "verify": return verifyCommand(args); case "prepare-assets": return godotHeadlessScript("res://tools/generate_backgrounds.gd"); case "test-godot": return godotHeadlessScript("res://tests/run_tests.gd"); case undefined: case "help": case "--help": console.log(HELP); return 0; default: console.error(`Comando desconhecido: ${command}\n\n${HELP}`); return 64; } } async function doctor(): Promise { let problems = 0; console.log(`Node ${process.version} em ${process.platform}/${process.arch}`); const tools: Partial> = {}; for (const name of ["godot", "ffmpeg", "ffprobe"] as const) { try { const tool = findTool(name); tools[name] = tool; console.log(`ok ${name.padEnd(8)} ${await toolVersion(tool)} [${tool.source}: ${displayToolPath(tool.path)}]`); } catch (error) { problems++; console.log(`FALTA ${name.padEnd(8)} ${(error as Error).message}`); } } if (tools.ffmpeg) { const enc = await ffmpegEncoders(tools.ffmpeg); try { console.log(`ok encoder ${chooseVideoEncoder(enc).name} (libx264=${enc.libx264} h264_nvenc=${enc.h264_nvenc} libopenh264=${enc.libopenh264} aac=${enc.aac})`); } catch (error) { problems++; console.log(`FALTA encoder ${(error as Error).message}`); } } try { fs.mkdirSync(OUTPUT_DIR, { recursive: true }); fs.accessSync(OUTPUT_DIR, fs.constants.W_OK); const stat = fs.statfsSync(OUTPUT_DIR); const freeGB = (stat.bavail * stat.bsize) / 2 ** 30; console.log(`${freeGB < 2 ? "AVISO" : "ok "} saída ${displayPath(OUTPUT_DIR)} gravável, ${freeGB.toFixed(1)} GB livres (prévia usa ~0,3 GB de PNG temporário; final ~1,5 GB)`); } catch (error) { problems++; console.log(`FALTA saída ${(error as Error).message}`); } const graphical = process.platform === "win32" || process.platform === "darwin" || !!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY; console.log(`${graphical ? "ok " : "AVISO"} gráfico ${graphical ? "sessão gráfica presumida (o render abre uma janela)" : "sem DISPLAY/WAYLAND_DISPLAY: o render 3D precisa de backend gráfico"}`); console.log("info GPU o adaptador real é registrado no report.json de cada render"); if (fs.existsSync(GODOT_OVERRIDE_FILE)) console.log(`AVISO override ${displayPath(GODOT_OVERRIDE_FILE)} existe (sobra de render interrompido?)`); if (fs.existsSync(LOCK_FILE)) console.log(`AVISO trava ${displayPath(LOCK_FILE)} existe`); console.log(problems === 0 ? "\nAmbiente pronto." : `\n${problems} problema(s) encontrado(s).`); return problems === 0 ? 0 : 1; } async function preview(args: ParsedArgs): Promise { const config = resolveFromRoot(stringOption(args, "config") ?? DEFAULT_CONFIG); const godot = findTool("godot"); if (fs.existsSync(GODOT_OVERRIDE_FILE) && !fs.existsSync(LOCK_FILE)) { // Sobra de render interrompido: alteraria o tamanho da janela da prévia. fs.rmSync(GODOT_OVERRIDE_FILE); console.warn("Removido override.cfg deixado por um render interrompido."); } console.log(`Prévia de ${displayPath(config)} — Espaço pausa, R reinicia, ←/→ quadro a quadro, L repete, Esc sai.`); const r = await runProcess(godot.path, ["--path", GODOT_PROJECT_DIR, "--", "--config", config], { inheritStdio: true }); if (!succeeded(r)) { console.error(describeFailure("godot", r)); return r.exitCode ?? 1; } return 0; } async function renderCommand(args: ParsedArgs): Promise { const profile = (stringOption(args, "profile") ?? "preview") as ProfileName; if (!(profile in PROFILES)) throw new UsageError(`--profile precisa ser ${Object.keys(PROFILES).join(" ou ")}`); const warmup = numberOption(args, "warmup-frames") ?? 3; if (!Number.isInteger(warmup) || warmup < 0 || warmup > 30) throw new UsageError("--warmup-frames precisa ser inteiro entre 0 e 30"); return render({ configPath: stringOption(args, "config") ?? DEFAULT_CONFIG, profile, keepFrames: args.options.has("keep-frames"), debugFrameIndex: args.options.has("debug-frame-index"), warmupFrames: warmup, }); } async function verifyCommand(args: ParsedArgs): Promise { const fileArg = stringOption(args, "file"); if (!fileArg) throw new UsageError("informe --file "); const file = resolveFromRoot(fileArg); if (!fs.existsSync(file)) { console.error(`Arquivo não encontrado: ${fileArg}`); return 1; } // Expectativas: opções explícitas > scene.json da mesma pasta de execução. const expectation: Expectation = {}; const sceneFile = path.join(path.dirname(file), "scene.json"); if (fs.existsSync(sceneFile)) { const scene = JSON.parse(fs.readFileSync(sceneFile, "utf8")); expectation.width = scene.video?.width; expectation.height = scene.video?.height; expectation.fps = scene.video?.fps; expectation.durationSeconds = scene.video?.durationSeconds; if (expectation.fps && expectation.durationSeconds) expectation.frames = Math.round(expectation.fps * expectation.durationSeconds); expectation.audio = scene.audio?.enabled === true; console.log(`Expectativas lidas de ${displayPath(sceneFile)}`); } expectation.width = numberOption(args, "width") ?? expectation.width; expectation.height = numberOption(args, "height") ?? expectation.height; expectation.fps = numberOption(args, "fps") ?? expectation.fps; expectation.durationSeconds = numberOption(args, "duration") ?? expectation.durationSeconds; expectation.frames = numberOption(args, "frames") ?? expectation.frames; const probe = await probeVideo(findTool("ffprobe"), file); const checks = evaluateProbe(probe, expectation); console.log(`\n${displayPath(file)}`); for (const c of checks) console.log(` ${c.ok ? "ok " : "FALHA"} ${c.name} — ${c.detail}`); const ok = checks.every((c) => c.ok); console.log(ok ? "\nVídeo verificado." : "\nVerificação falhou."); return ok ? 0 : 1; } async function godotHeadlessScript(script: string): Promise { const godot = findTool("godot"); const r = await runProcess(godot.path, ["--headless", "--path", GODOT_PROJECT_DIR, "--script", script], { inheritStdio: true }); if (!succeeded(r)) console.error(describeFailure(`godot ${script}`, r)); return succeeded(r) ? 0 : r.exitCode ?? 1; } main(process.argv.slice(2)).then( (code) => { process.exitCode = code; }, (error: unknown) => { if (error instanceof UsageError || error instanceof MissingToolError) { console.error(`Erro: ${error.message}`); process.exitCode = 64; } else { console.error(error); process.exitCode = 1; } }, );