topview-3d-cli 0.1.0__py3-none-any.whl

topview_3d_cli/_runtime/director-cli/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@topview/3d-director-cli",
+  "private": true,
+  "type": "module",
+  "license": "Apache-2.0"
+}

topview_3d_cli/_runtime/director-cli/playwright.mjs

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+// TOPVIEW3D_NODE_PREFIX is an npm prefix (it holds node_modules/playwright), used when the
+// renderer ships inside the Python package; otherwise playwright resolves from here.
+export function playwrightDir() {
+  const prefix = process.env.TOPVIEW3D_NODE_PREFIX
+  try {
+    if (prefix) {
+      const require = createRequire(path.join(path.resolve(prefix), 'package.json'))
+      return path.dirname(require.resolve('playwright/package.json'))
+    }
+    return path.dirname(fileURLToPath(import.meta.resolve('playwright/package.json')))
+  } catch {
+    throw new Error('PLAYWRIGHT_NOT_INSTALLED')
+  }
+}
+
+export async function loadPlaywright() {
+  const dir = playwrightDir()
+  const manifest = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'))
+  const entry = manifest.exports?.['.']?.import ?? manifest.main ?? 'index.js'
+  return import(pathToFileURL(path.join(dir, entry)).href)
+}

topview_3d_cli/_runtime/director-cli/render.mjs

@@ -0,0 +1,336 @@
+import { createHash } from 'node:crypto'
+import { createReadStream } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import http from 'node:http'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { loadPlaywright } from './playwright.mjs'
+
+const ROOT = path.dirname(fileURLToPath(import.meta.url))
+const RENDERS_DIR_NAME = 'renders'
+const RUN_ID = /^[A-Za-z0-9_-]{1,128}$/
+const THREE_DRACO = path.join(ROOT, 'node_modules/three/examples/jsm/libs/draco')
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json',
+  '.wasm': 'application/wasm',
+}
+
+function resolveServedFile(relative, localFiles) {
+  const local = /^local-assets\/(\d+)\/[^/]+$/.exec(relative)
+  if (local) return localFiles[Number(local[1])] ?? null
+  if (relative === 'draco' || relative.startsWith('draco/')) {
+    const rest = relative === 'draco' ? '' : relative.slice('draco/'.length)
+    const file = path.normalize(path.join(THREE_DRACO, rest))
+    return file.startsWith(THREE_DRACO) ? file : null
+  }
+  const file = path.normalize(path.join(ROOT, relative))
+  return file.startsWith(ROOT) ? file : null
+}
+
+function serveRoot(localFiles = []) {
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || '/', 'http://127.0.0.1')
+      const relative = decodeURIComponent(url.pathname.replace(/^\/+/, '')) || 'static/headless.html'
+      const file = resolveServedFile(relative, localFiles)
+      if (!file) {
+        res.writeHead(403)
+        res.end()
+        return
+      }
+      const stream = createReadStream(file)
+      stream.on('error', () => {
+        res.writeHead(404)
+        res.end()
+      })
+      stream.on('open', () => {
+        res.writeHead(200, { 'Content-Type': MIME[path.extname(file)] || 'application/octet-stream' })
+        stream.pipe(res)
+      })
+    })
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address()
+      resolve({ server, origin: `http://127.0.0.1:${port}` })
+    })
+  })
+}
+
+
+// Requests may only reach the local static server and explicitly configured asset
+// origins; anything else is aborted and reported, so offline renders stay offline.
+export function assetOrigins(body) {
+  const base = publicAssetBase(body)
+  if (!base) return []
+  try { return [new URL(base).origin] } catch { return [] }
+}
+
+// body.localAssets maps asset keys to absolute files; only those files are served.
+export function localAssetFiles(body) {
+  const entries = Object.entries(isPlainObject(body?.localAssets) ? body.localAssets : {})
+  for (const [key, file] of entries) {
+    if (typeof file !== 'string' || !path.isAbsolute(file)) throw new Error(`LOCAL_ASSET_PATH_INVALID:${key}`)
+  }
+  return entries
+}
+
+function localAssetUrls(entries, origin) {
+  return Object.fromEntries(entries.map(([key, file], index) =>
+    [key, `${origin}/local-assets/${index}/${encodeURIComponent(path.basename(file))}`]))
+}
+
+export async function withPage(work, { allowedOrigins = [], localAssets = [] } = {}) {
+  const playwright = await loadPlaywright()
+  const { server, origin } = await serveRoot(localAssets.map(([, file]) => path.resolve(file)))
+  const network = { blocked: [] }
+  let browser
+  try {
+    browser = await playwright.chromium.launch({
+      args: [
+        '--use-angle=swiftshader',
+        '--enable-unsafe-swiftshader',
+        '--ignore-gpu-blocklist',
+        '--disable-dev-shm-usage',
+        '--disable-web-security',
+      ],
+      chromiumSandbox: false,
+    })
+    const page = await browser.newPage()
+    const allowed = new Set([origin, ...allowedOrigins])
+    await page.route('**/*', (route) => {
+      const url = route.request().url()
+      let requestOrigin = 'null'
+      try { requestOrigin = new URL(url).origin } catch { /* data:, blob: */ }
+      if (allowed.has(requestOrigin) || /^(data|blob):/i.test(url)) return route.continue()
+      if (network.blocked.length < 50) {
+        try { const parsed = new URL(url); network.blocked.push(parsed.origin + parsed.pathname) }
+        catch { network.blocked.push('[unparsable URL]') }
+      }
+      return route.abort('blockedbyclient')
+    })
+    const warnings = []
+    page.on('console', (message) => {
+      if (!['warning', 'error'].includes(message.type()) || warnings.length >= 20) return
+      // Preserve asset-load diagnostics without returning signed URL credentials.
+      warnings.push(message.text().replace(/https?:\/\/[^\s]+/g, (value) => {
+        try { const url = new URL(value); return url.origin + url.pathname }
+        catch { return '[asset URL]' }
+      }))
+    })
+    page.on('pageerror', (error) => {
+      process.stderr.write(`headless pageerror: ${error.message}\n${error.stack || ''}\n`)
+    })
+    await page.goto(`${origin}/static/headless.html`, { waitUntil: 'load' })
+    await page.waitForFunction(() => window.__directorReady === true, null, { timeout: 30_000 })
+    return await work(page, origin, warnings, network, localAssetUrls(localAssets, origin))
+  } finally {
+    if (browser) await browser.close()
+    await new Promise((resolve) => server.close(resolve))
+  }
+}
+
+function digest(buffer) {
+  return createHash('sha256').update(buffer).digest('hex')
+}
+
+function publicAssetBase(body) {
+  return body.publicAssetBase
+    || process.env.TOPVIEW3D_DIRECTOR_PUBLIC_ASSET_BASE
+    || ''
+}
+
+// outputDir is `<absolute>/renders/<runId>`: the caller chooses the root (a project's
+// .topview3d/renders), the renderer writes exactly one run directory below it.
+export function resolveOutputDir(outputDir, pathApi = path) {
+  if (typeof outputDir !== 'string' || !outputDir.trim()) {
+    throw new Error('RENDER_OUTPUT_DIR_REQUIRED')
+  }
+  if (!pathApi.isAbsolute(outputDir)) throw new Error('RENDER_OUTPUT_DIR_INVALID')
+  if (outputDir.split(/[\\/]+/).some((segment) => segment === '..' || segment === '.')) {
+    throw new Error('RENDER_OUTPUT_DIR_INVALID')
+  }
+  const resolved = pathApi.resolve(outputDir)
+  const runId = pathApi.basename(resolved)
+  const parent = pathApi.dirname(resolved)
+  if (!RUN_ID.test(runId) || pathApi.basename(parent) !== RENDERS_DIR_NAME || parent === resolved) {
+    throw new Error('RENDER_OUTPUT_DIR_INVALID')
+  }
+  return resolved
+}
+
+export function resolveRenderSize(body) {
+  const requestedWidth = body.width ?? 640
+  const requestedHeight = body.height ?? 360
+  if (![requestedWidth, requestedHeight].every((value) => Number.isInteger(value) && value >= 64)) {
+    throw new Error('render dimensions must be integers >=64')
+  }
+  const ratio = Math.min(1, 1024 / Math.max(requestedWidth, requestedHeight))
+  return {
+    width: Math.max(1, Math.round(requestedWidth * ratio)),
+    height: Math.max(1, Math.round(requestedHeight * ratio)),
+  }
+}
+
+export async function renderFrames(body) {
+  const frames = body.frames ?? [0]
+  if (!frames.length || frames.length > 9) throw new Error('contact sheet requires 1–9 frames')
+  const outputDir = resolveOutputDir(body.outputDir)
+  const { width, height } = resolveRenderSize(body)
+  await mkdir(outputDir, { recursive: true })
+  const localAssets = localAssetFiles(body)
+  return withPage(async (page, origin, warnings, network, localAssetUrls) => {
+    const result = await page.evaluate(async ({
+      document, fcurves, frames, width, height, publicAssetBase, dracoDecoderPath, cameraNodeId, sceneSequence,
+      localAssetUrls,
+    }) => {
+      const renderer = await window.createDirectorRenderer({
+        document,
+        fcurves,
+        width,
+        height,
+        publicAssetBase,
+        dracoDecoderPath,
+        localAssetUrls,
+      })
+      try {
+        const pngs = []
+        for (const frame of frames) {
+          const blob = await renderer.renderFrame(frame, cameraNodeId ? { cameraId: cameraNodeId } : undefined)
+          const buffer = await blob.arrayBuffer()
+          pngs.push({
+            frame,
+            base64: window.bytesToBase64(buffer),
+            bytes: buffer.byteLength,
+          })
+        }
+        const sheet = await window.composeContactSheet(pngs, width, height,
+          cameraNodeId ? `${cameraNodeId} · scene ${sceneSequence ?? '?'}` : '')
+        return { pngs, sheet }
+      } finally {
+        renderer.dispose()
+      }
+    }, {
+      document: body.document,
+      fcurves: body.fcurves ?? null,
+      frames,
+      cameraNodeId: body.cameraNodeId,
+      sceneSequence: body.sceneSequence,
+      width,
+      height,
+      publicAssetBase: publicAssetBase(body),
+      dracoDecoderPath: `${origin}/draco/`,
+      localAssetUrls,
+    })
+    const blank = result.pngs.some((item) => item.bytes < 256)
+    const frameEntries = []
+    for (const item of result.pngs) {
+      const buffer = Buffer.from(item.base64, 'base64')
+      const file = path.join(outputDir, `frame-${item.frame}.png`)
+      await writeFile(file, buffer)
+      frameEntries.push({
+        frame: item.frame,
+        path: file,
+        mimeType: 'image/png',
+        sizeBytes: buffer.byteLength,
+        sha256: digest(buffer),
+      })
+    }
+    const sheetBuffer = Buffer.from(result.sheet, 'base64')
+    const sheetFile = path.join(outputDir, 'contact-sheet.png')
+    await writeFile(sheetFile, sheetBuffer)
+    const cameraNodeId = body.cameraNodeId ?? body.document?.content?.activeShotCameraNodeId
+    const contactSheet = {
+      path: sheetFile,
+      mimeType: 'image/png',
+      sizeBytes: sheetBuffer.byteLength,
+      sha256: digest(sheetBuffer),
+    }
+    const manifestFile = path.join(outputDir, 'render.json')
+    await writeFile(manifestFile, `${JSON.stringify({
+      version: 1,
+      runId: path.basename(outputDir),
+      createdAt: new Date().toISOString(),
+      width,
+      height,
+      cameraNodeId,
+      sceneSequence: body.sceneSequence,
+      frames: frameEntries.map(({ path: file, ...entry }) => ({ ...entry, file: path.basename(file) })),
+      contactSheet: { ...contactSheet, path: undefined, file: path.basename(sheetFile) },
+      blank,
+      blockedRequests: network.blocked,
+      ...(isPlainObject(body.metadata) ? { metadata: body.metadata } : {}),
+    }, null, 2)}\n`)
+    return {
+      outputDir,
+      manifest: manifestFile,
+      cameraNodeId,
+      sceneSequence: body.sceneSequence,
+      frames: frameEntries,
+      contactSheet,
+      blank,
+      blockedRequests: network.blocked,
+      warnings,
+    }
+  }, { allowedOrigins: assetOrigins(body), localAssets })
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export async function inspectNodes(body) {
+  if (!body || typeof body.document !== 'object' || !Array.isArray(body.nodeIds) || !body.nodeIds.length) {
+    throw new Error('document and nodeIds required')
+  }
+  const localAssets = localAssetFiles(body)
+  return withPage(async (page, origin, warnings, network, localAssetUrls) => {
+    const nodes = await page.evaluate(async (input) => window.inspectDirectorNodes(input), {
+      localAssetUrls,
+      document: body.document,
+      fcurves: body.fcurves ?? null,
+      nodeIds: body.nodeIds,
+      frame: body.frames?.[0],
+      publicAssetBase: publicAssetBase(body),
+      dracoDecoderPath: `${origin}/draco/`,
+    })
+    return { ok: nodes.every((node) => node.status === 'measured'), nodes, warnings, blockedRequests: network.blocked }
+  }, { allowedOrigins: assetOrigins(body), localAssets })
+}
+
+export async function applyLibraryPose(body) {
+  if (!body || typeof body.document !== 'object') {
+    throw new Error('document required')
+  }
+  const localAssets = localAssetFiles(body)
+  return withPage(async (page, origin, warnings, network, localAssetUrls) => page.evaluate(
+    (input) => window.compileDirectorPose(input),
+    { ...body, localAssets: undefined, localAssetUrls, publicAssetBase: publicAssetBase(body),
+      dracoDecoderPath: `${origin}/draco/` },
+  ), { allowedOrigins: assetOrigins(body), localAssets })
+}
+
+// Compiles several library poses against one loaded page; the document is not modified.
+export async function applyLibraryPoses(body) {
+  if (!body || typeof body.document !== 'object' || !Array.isArray(body.items) || !body.items.length) {
+    throw new Error('document and items required')
+  }
+  const localAssets = localAssetFiles(body)
+  return withPage(async (page, origin, warnings, network, localAssetUrls) => {
+    const results = []
+    for (const item of body.items) {
+      results.push(await page.evaluate((input) => window.compileDirectorPose(input), {
+        document: body.document,
+        nodeId: item.nodeId,
+        libraryId: item.libraryId,
+        pose: item.pose,
+        localAssetUrls,
+        publicAssetBase: publicAssetBase(body),
+        dracoDecoderPath: `${origin}/draco/`,
+      }))
+    }
+    return { results, warnings, blockedRequests: network.blocked }
+  }, { allowedOrigins: assetOrigins(body), localAssets })
+}

topview_3d_cli/_runtime/director-cli/static/headless.html

@@ -0,0 +1,124 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script type="importmap">
+      {
+        "imports": {
+          "three": "/node_modules/three/build/three.module.js",
+          "three/addons/": "/node_modules/three/examples/jsm/",
+          "zod": "/node_modules/zod/index.js"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <canvas id="stage" width="1280" height="720"></canvas>
+    <script type="module">
+      import { createHeadlessRenderer } from '/node_modules/@topview/3d-builder/dist/headless/index.mjs'
+      import { Stage } from '/node_modules/@topview/3d-builder/dist/engine/index.mjs'
+      import { Box3, Vector3 } from 'three'
+      import { FCurveSet } from '/node_modules/@topview/3d-builder/dist/evaluate/index.mjs'
+      import { resolveHeadlessMediaUrl } from '/mediaUrl.mjs'
+      import { compileLibraryPose } from './pose.mjs'
+      import { supportSurfaces, characterLandmarks } from './measure.mjs'
+      window.compileDirectorPose = compileLibraryPose
+
+      window.createDirectorRenderer = async ({
+        document, fcurves, width, height, publicAssetBase, dracoDecoderPath, localAssetUrls,
+      }) => {
+        const renderer = createHeadlessRenderer({
+          width,
+          height,
+          dracoDecoderPath,
+          resolveMediaUrl: (ref) => resolveHeadlessMediaUrl(ref, publicAssetBase || '', localAssetUrls),
+        })
+        // Evidence renders should not cover faces/contact with Editor name sprites.
+        // This copy keeps the saved draft's label settings unchanged.
+        const renderDocument = structuredClone(document)
+        for (const node of renderDocument.content.nodes) {
+          if (node.character) node.character.label = { ...node.character.label, showLabel: false }
+        }
+        await renderer.load(renderDocument, fcurves)
+        return renderer
+      }
+
+      window.inspectDirectorNodes = async ({
+        document, fcurves, nodeIds, frame, publicAssetBase, dracoDecoderPath, localAssetUrls,
+      }) => {
+        const stage = new Stage(ref => resolveHeadlessMediaUrl(ref, publicAssetBase || '', localAssetUrls), { dracoDecoderPath })
+        try {
+          await stage.load(document)
+          if (fcurves) stage.setFcurves(FCurveSet.parse(fcurves))
+          stage.seek(frame ?? document.content.timeline.frameStart ?? 0)
+          stage.scene.updateMatrixWorld(true)
+          return nodeIds.map(nodeId => {
+            const node = document.content.nodes.find(n => n.id === nodeId)
+            const object = stage.characters.get(nodeId)?.root || stage.props.get(nodeId) || stage.primitives.get(nodeId) || stage.groups.get(nodeId)
+            if (!object) return { nodeId, status: 'geometry-unavailable', type: node?.type }
+            const bounds = new Box3()
+            object.traverse(child => {
+              if (!child.isMesh || !child.geometry) return
+              // Measure meshes only: character label sprites must not inflate size.
+              const box = new Box3().setFromObject(child, true)
+              if (!box.isEmpty()) bounds.union(box)
+            })
+            if (bounds.isEmpty()) return { nodeId, status: 'geometry-unavailable' }
+            const point = value => ({ x: value.x, y: value.y, z: value.z })
+            return { nodeId, name: node.name, type: node.type, status: 'measured',
+              size: point(bounds.getSize(new Vector3())),
+              bounds: { min: point(bounds.min), max: point(bounds.max) },
+              origin: point(object.getWorldPosition(new Vector3())),
+              localForwardAxis: point(new Vector3(0, 0, 1).transformDirection(object.matrixWorld)),
+              ...(node.type === 'character' ? { landmarks: characterLandmarks(object) }
+                : { supportSurfaces: supportSurfaces(object) }),
+              semanticFront: 'unknown; verify in preview', transform: node.transform }
+          })
+        } finally { stage.dispose() }
+      }
+
+      // Chunked encoder: `String.fromCharCode(...bytes)` spreads every byte as a
+      // call argument and overflows the stack for PNGs above ~100 KB, which is
+      // any real-resolution frame. Encode in fixed slices instead.
+      window.bytesToBase64 = (buffer) => {
+        const bytes = new Uint8Array(buffer)
+        const chunk = 0x8000
+        let binary = ''
+        for (let i = 0; i < bytes.length; i += chunk) {
+          binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk))
+        }
+        return btoa(binary)
+      }
+
+      window.composeContactSheet = async (pngs, width, height, label = '') => {
+        const cols = Math.min(3, pngs.length)
+        const rows = Math.ceil(pngs.length / cols)
+        const canvas = document.createElement('canvas')
+        // Cap the sheet at 1024px on the long edge so the file stays cheap to persist.
+        const scale = Math.min(1, 1024 / Math.max(cols * width, rows * height))
+        canvas.width = Math.max(1, Math.round(cols * width * scale))
+        canvas.height = Math.max(1, Math.round(rows * height * scale))
+        const ctx = canvas.getContext('2d')
+        ctx.scale(canvas.width / (cols * width), canvas.height / (rows * height))
+        for (const [index, item] of pngs.entries()) {
+          const image = new Image()
+          image.src = `data:image/png;base64,${item.base64}`
+          await image.decode()
+          const x = (index % cols) * width, y = Math.floor(index / cols) * height
+          ctx.drawImage(image, x, y, width, height)
+          const fontSize = Math.max(14, Math.round(14 / scale))
+          ctx.fillStyle = 'rgba(0,0,0,0.8)'
+          ctx.fillRect(x, y, width, fontSize + 10)
+          ctx.font = `${fontSize}px sans-serif`
+          ctx.fillStyle = '#ffffff'
+          ctx.fillText(`${label ? label + ' · ' : ''}frame ${item.frame}`, x + 6, y + fontSize + 2, width - 12)
+        }
+        const blob = await new Promise((resolve) => canvas.toBlob(resolve, 'image/png'))
+        const buffer = await blob.arrayBuffer()
+        return window.bytesToBase64(buffer)
+      }
+
+      window.__directorReady = true
+    </script>
+  </body>
+</html>

topview_3d_cli/_runtime/director-cli/static/measure.mjs

@@ -0,0 +1,61 @@
+import { Box3, Vector3 } from 'three'
+
+const point = v => ({ x: v.x, y: v.y, z: v.z })
+
+// Geometric candidates only: a chair's seat, armrest and back top can all be
+// horizontal. Consumers must identify the seat from annotations and the image.
+export function supportSurfaces(object) {
+  const groups = new Map()
+  const a = new Vector3(), b = new Vector3(), c = new Vector3()
+  const ab = new Vector3(), ac = new Vector3(), normal = new Vector3()
+  object.traverse(mesh => {
+    const geometry = mesh.geometry
+    if (!mesh.isMesh || mesh.isSkinnedMesh || !geometry?.attributes.position) return
+    const indices = geometry.index
+    const count = indices?.count ?? geometry.attributes.position.count
+    for (let i = 0; i + 2 < count; i += 3) {
+      for (const [offset, v] of [[0, a], [1, b], [2, c]]) {
+        mesh.getVertexPosition(indices ? indices.getX(i + offset) : i + offset, v)
+        v.applyMatrix4(mesh.matrixWorld)
+      }
+      normal.crossVectors(ab.subVectors(b, a), ac.subVectors(c, a))
+      const area = normal.length() / 2
+      if (area < 1e-8 || normal.y / (2 * area) < 0.97) continue
+      const height = (a.y + b.y + c.y) / 3
+      const bucket = Math.round(height / 0.02)
+      const group = groups.get(bucket) || { area: 0, weightedHeight: 0, bounds: new Box3() }
+      group.area += area
+      group.weightedHeight += area * height
+      group.bounds.expandByPoint(a).expandByPoint(b).expandByPoint(c)
+      groups.set(bucket, group)
+    }
+  })
+  return [...groups.values()].filter(g => g.area > 0.005)
+    .sort((a, b) => b.area - a.area).slice(0, 6).map(g => ({
+      height: g.weightedHeight / g.area, area: g.area,
+      worldWidth: g.bounds.max.x - g.bounds.min.x,
+      worldDepth: g.bounds.max.z - g.bounds.min.z,
+      bounds: { min: point(g.bounds.min), max: point(g.bounds.max) },
+    }))
+}
+
+export function characterLandmarks(root) {
+  const names = {
+    hips: ['mixamorighips', 'hips', 'pelvis'],
+    leftKnee: ['mixamorigleftleg', 'leftleg', 'calfl'],
+    rightKnee: ['mixamorigrightleg', 'rightleg', 'calfr'],
+    leftAnkle: ['mixamorigleftfoot', 'leftfoot', 'footl'],
+    rightAnkle: ['mixamorigrightfoot', 'rightfoot', 'footr'],
+    leftHip: ['mixamorigleftupleg', 'leftupleg', 'thighl'],
+    rightHip: ['mixamorigrightupleg', 'rightupleg', 'thighr'],
+  }
+  const result = {}
+  root.traverse(obj => {
+    if (!obj.isBone) return
+    const name = obj.name.toLowerCase().replace(/[^a-z0-9]/g, '')
+    for (const [key, aliases] of Object.entries(names)) {
+      if (aliases.includes(name)) result[key] = point(obj.getWorldPosition(new Vector3()))
+    }
+  })
+  return result
+}

topview_3d_cli/_runtime/director-cli/static/pose.mjs

@@ -0,0 +1,71 @@
+import { Stage, poseRootOffsetScale } from '/node_modules/@topview/3d-builder/dist/engine/index.mjs'
+import { Box3, Quaternion, Vector3 } from 'three'
+import { resolveHeadlessMediaUrl } from '/mediaUrl.mjs'
+
+const normalize = value => value.toLowerCase().replace(/[^a-z0-9]/g, '')
+const ual = { Hips: 'pelvis', Spine: 'spine_01', Spine1: 'spine_02', Spine2: 'spine_03', Neck: 'neck_01', Head: 'Head' }
+for (const [side, suffix] of [['Left', 'l'], ['Right', 'r']]) {
+  for (const [part, target] of Object.entries({ Shoulder: 'clavicle', Arm: 'upperarm', ForeArm: 'lowerarm', Hand: 'hand', UpLeg: 'thigh', Leg: 'calf', Foot: 'foot', ToeBase: 'ball' })) ual[side + part] = `${target}_${suffix}`
+  for (const finger of ['Index', 'Middle', 'Ring', 'Pinky', 'Thumb']) {
+    for (let i = 1; i <= 3; i++) ual[`${side}Hand${finger}${i}`] = `${finger.toLowerCase()}_0${i}_${suffix}`
+  }
+}
+
+// The package's evaluate/headless entrypoints do not expose its dynamic pose
+// bank. Materialize the same world-delta retargeting as supported joint controls,
+// so both the Editor and headless renderer can replay the static pose unaided.
+export async function compileLibraryPose({ document, nodeId, pose, libraryId, publicAssetBase, dracoDecoderPath, localAssetUrls }) {
+  const doc = structuredClone(document)
+  const node = doc.content.nodes.find(n => n.id === nodeId)
+  if (!node?.character) throw new Error('DIRECTOR_POSE_REQUIRES_CHARACTER')
+  if (node.locked) throw new Error('NODE_LOCKED')
+  node.character.animation = { mode: 'pose', controlValues: {} }
+  const stage = new Stage(ref => resolveHeadlessMediaUrl(ref, publicAssetBase || '', localAssetUrls), { dracoDecoderPath })
+  try {
+    await stage.load(doc)
+    const character = stage.characters.get(nodeId)
+    if (!character) throw new Error('DIRECTOR_POSE_CHARACTER_NOT_LOADED')
+    const { root, restPose } = character
+    const savedRoot = root.quaternion.clone()
+    root.quaternion.identity()
+    root.traverse(obj => { if (restPose.has(obj.name)) obj.quaternion.copy(restPose.get(obj.name)) })
+    root.updateMatrixWorld(true)
+    const byName = new Map(), restWorld = new Map(), assigned = new Map()
+    root.traverse(obj => {
+      if (obj.isBone) byName.set(normalize(obj.name), obj)
+      restWorld.set(obj, obj.getWorldQuaternion(new Quaternion()))
+    })
+    for (const [name, value] of Object.entries(pose.bones)) {
+      const mapped = character.rig === 'ual1' ? ual[name.replace(/^mixamorig:?/i, '')] : null
+      const bone = byName.get(normalize(mapped || name))
+      if (bone) assigned.set(bone, value)
+    }
+    if (assigned.size < 10) throw new Error('DIRECTOR_POSE_INCOMPATIBLE_SKELETON')
+    const controls = {}
+    const apply = obj => {
+      const values = assigned.get(obj)
+      if (values) {
+        const desired = new Quaternion(...values).normalize().multiply(restWorld.get(obj))
+        const parent = obj.parent?.getWorldQuaternion(new Quaternion()) || new Quaternion()
+        obj.quaternion.copy(parent.invert().multiply(desired))
+        obj.updateWorldMatrix(true, false)
+      }
+      if (obj.isBone) {
+        for (const axis of ['x', 'y', 'z']) controls[`joint:${obj.name}:${axis}`] = obj.rotation[axis] * 180 / Math.PI
+      }
+      for (const child of obj.children) apply(child)
+    }
+    apply(root)
+    const animation = { mode: 'pose', posePresetId: pose.pose_id || libraryId.replace(/^a3d_pose_/, ''),
+      controlValues: controls, rootPositionOffset: { x: pose.hips[0], y: pose.hips[1], z: pose.hips[2] } }
+    // Return only character pose fields: signed model URLs must not be persisted.
+    // Same root drop as applySnapshot: library hips scale with the character's leg length.
+    character.inner.position.set(...pose.hips.map(value => value * poseRootOffsetScale(character.legLength)))
+    root.quaternion.copy(savedRoot)
+    root.updateMatrixWorld(true)
+    const bounds = new Box3().setFromObject(character.inner, true)
+    const point = value => ({ x: value.x, y: value.y, z: value.z })
+    return { animation, pose: { libraryId, matchedBones: assigned.size,
+      size: point(bounds.getSize(new Vector3())), bounds: { min: point(bounds.min), max: point(bounds.max) } } }
+  } finally { stage.dispose() }
+}