Skip to content

Official Codebase of 3DCodeVerse

Python
6.3 KB
Raw Blame
#!/usr/bin/env node
// Render a GLB from fixed views with headless Chrome (GPU when available).
//
//   node runtime_js/render_glb.mjs --glb <path> --out <dir> --views '<json [{name,azimuth,elevation}]>'
//        [--mode shaded|wire|normals|silhouette|clay] [--width 768] [--height 768]
//        [--isolate Name1,Name2] [--explode 0.3] [--background studio|white|transparent]
//        [--anim-time t] [--gpu auto|on|off] [--shadow 1|0] [--timeout-s 240]
//
// Writes <out>/view_<name>.png for every view + <out>/views.json, and prints one JSON
// line last on stdout: {ok, renderer, gpu, views:[{name,path,camera_position,look_at,fov,...}],
// warnings, timing_ms}.  Exit 1 (with {ok:false,error}) on any failure.
//
// Thin driver: arg parsing / JSON-last-line protocol come from lib/cli.mjs, the
// browser + static server from lib/host_env.mjs, the browser release dance from
// lib/host_page.mjs, and everything visual from lib/browser/render_rig.js.

import fs from 'node:fs';
import path from 'node:path';

import { ensureDir, finish, parseCli, writeJson } from './lib/cli.mjs';
import { launchBrowser, importMapHtml, RUNTIME_MOUNT, serveDirs } from './lib/host_env.mjs';
import { bounded } from './lib/host_page.mjs';

const MODES = ['shaded', 'wire', 'normals', 'silhouette', 'clay'];

function config() {
  const values = parseCli({
    glb: {}, out: {}, views: {},
    mode: { default: 'shaded' }, width: { default: '768' }, height: { default: '768' },
    isolate: { default: '' }, explode: { default: '0' }, background: { default: 'studio' },
    'anim-time': {}, gpu: { default: 'auto' }, shadow: { default: '1' },
    'timeout-s': { default: '240' },
  });
  if (!values.glb || !values.out || !values.views) throw new Error('--glb, --out and --views are required');
  if (!MODES.includes(values.mode)) throw new Error(`--mode must be one of ${MODES.join('|')}`);
  const views = JSON.parse(values.views);
  if (!Array.isArray(views) || views.length === 0) throw new Error('--views must be a non-empty JSON list');
  for (const v of views) {
    if (typeof v.name !== 'string' || !/^[A-Za-z0-9_\-]+$/.test(v.name)) throw new Error(`bad view name: ${JSON.stringify(v.name)}`);
    if (typeof v.azimuth !== 'number' || typeof v.elevation !== 'number') throw new Error(`view ${v.name}: azimuth/elevation must be numbers`);
  }
  return {
    glb: path.resolve(values.glb),
    out: path.resolve(values.out),
    views,
    mode: values.mode,
    width: Number(values.width),
    height: Number(values.height),
    isolate: values.isolate ? values.isolate.split(',').map((s) => s.trim()).filter(Boolean) : [],
    explode: Number(values.explode) || 0,
    background: values.background,
    animTime: values['anim-time'] != null ? Number(values['anim-time']) : null,
    gpu: values.gpu,
    shadow: values.shadow !== '0',
    timeoutMs: Number(values['timeout-s']) * 1000,
  };
}

function pageHtml(cfg) {
  const config_ = { ...cfg, glbUrl: '/' + path.basename(cfg.glb) };
  delete config_.glb;
  delete config_.out;
  return `<!doctype html><html><head><meta charset="utf-8">${importMapHtml()}
<style>html,body{margin:0;background:#000}canvas{display:block}</style></head>
<body><canvas id="c" width="${cfg.width}" height="${cfg.height}"></canvas>
<script type="module">
import { renderGlbViews } from '${RUNTIME_MOUNT}lib/browser/render_rig.js';
window.__c3v_result = null;
renderGlbViews(${JSON.stringify(config_)}).then(
  (r) => { window.__c3v_result = r; },
  (e) => { window.__c3v_result = { ok: false, error: String(e && e.message || e), stack: String(e && e.stack || '') }; },
);
</script></body></html>`;
}

async function main() {
  const t0 = Date.now();
  const step = (name) => process.stderr.write(`[render_glb] ${name} +${Date.now() - t0}ms\n`);
  const cfg = config();
  if (!fs.existsSync(cfg.glb)) throw new Error(`GLB not found: ${cfg.glb}`);
  ensureDir(cfg.out);

  const srv = await serveDirs({ root: path.dirname(cfg.glb), routes: { '/__render.html': { body: pageHtml(cfg) } } });
  const consoleErrors = [];
  let launched = null;
  let page = null;
  let record = null;
  try {
    step('connect');
    launched = await launchBrowser({ gpu: cfg.gpu });
    const timing = { launch_ms: Date.now() - t0 };

    step('newPage');
    page = await launched.browser.newPage();
    await page.setViewport({ width: cfg.width, height: cfg.height, deviceScaleFactor: 1 });
    page.on('console', (msg) => {
      if (msg.type() === 'error' || msg.type() === 'warning') consoleErrors.push(`${msg.type()}: ${msg.text()}`);
    });
    page.on('pageerror', (e) => consoleErrors.push(`pageerror: ${e.message}`));
    step('goto');
    await page.goto(srv.url('/__render.html'), { waitUntil: 'load', timeout: cfg.timeoutMs });
    step('waitResult');
    await page.waitForFunction('window.__c3v_result !== null', { timeout: cfg.timeoutMs, polling: 100 });
    const result = await page.evaluate(() => window.__c3v_result);
    if (!result || !result.ok) {
      const err = new Error(result ? result.error : 'render produced no result');
      err.details = { stack: result && result.stack, console: consoleErrors };
      throw err;
    }
    const views = [];
    for (const v of result.views) {
      const file = path.join(cfg.out, `view_${v.name}.png`);
      fs.writeFileSync(file, Buffer.from(v.b64, 'base64'));
      const { b64: _b64, ...meta } = v;
      views.push({ ...meta, path: file, mode: cfg.mode });
    }
    record = {
      ok: true,
      renderer: result.renderer || launched.renderer,
      gpu: launched.gpu,
      mode: cfg.mode,
      rig_version: result.rig_version ?? null,
      bbox: result.bbox,
      views,
      warnings: result.warnings || [],
      console_errors: consoleErrors,
      timing_ms: { ...timing, ...result.timing, total_ms: Date.now() - t0 },
    };
    writeJson(path.join(cfg.out, 'views.json'), record);
  } finally {
    // page first, then release: a shared browser is disconnected, never closed
    step('cleanup');
    if (page) await bounded(page.close(), 3000);
    step('page.closed');
    if (launched?.browser) await bounded(launched.release(), 3000);
    step('released');
    await bounded(srv.close(), 2000);
    step('srv.closed');
  }
  return finish(record, 0);
}

main().catch((err) => {
  finish({ ok: false, error: err.message, details: err.details || null, stack: String(err.stack || '').split('\n').slice(0, 8) }, 1);
});