暮归江南 · 步骤8：集市货物改用 NVIDIA SimReady Central（Palatial NV Asset Library，CC-BY-4.0）的 18 件扫描模型，USD→GLB 转换器、目录检索脚本、实例化加载与程序化回退（GLB 文件经 Hub API 以 LFS 上传）

.gitattributes

@@ -95,3 +95,4 @@ public/mvfonts/neon.woff2 filter=lfs diff=lfs merge=lfs -text
 public/mvfonts/lyric.woff2 filter=lfs diff=lfs merge=lfs -text
 src/jiangnan/assets/fonts/title.woff2 filter=lfs diff=lfs merge=lfs -text
 src/jiangnan/assets/fonts/wenkai.woff2 filter=lfs diff=lfs merge=lfs -text
+public/jiangnan/models/*.glb filter=lfs diff=lfs merge=lfs -text

README.md

@@ -243,6 +243,13 @@ tools/jiangnan/                     # 旁白生成、字体子集化、实况图
   - **自愈渲染分级**（`Film.heal`）：0 完整渲染 → 1 关闭体积光 → 2 再关闭辉光 → 3 再关闭水面反射通道 → 4 再隐藏人物与鸟群 → 5 关闭全部后期、直接前向渲染。抓帧在「降级 + 重置上下文」四次都黑之后，逐级尝试，哪一级能出画面就**从该帧起固定使用**，并在面板写明「第 X 秒起改用『…』才能渲染出画面」——这句话同时就是诊断结论（哪一级生效，问题就在哪个效果里）。
   - 错误信息新增当前渲染模式与着色器错误摘要。
   - 验证：类型检查与构建通过；本轮的无头浏览器分级渲染测试因沙盒临时目录再次被回收未能运行（如实记录）。
+- **步骤 8（按要求用 NVIDIA SimReady Central 的模型替换画面中的模型）** ✅
+  - **先摸清库里有什么**（`tools/jiangnan/simready_search.py`，直接调用站点的 `search_hybrid` 接口）：把 SimReady Central 的全部 **3588** 个资产拉成清单（`--catalog`），按类别统计：prop 2531（仓库 / 工业 / 医院道具）、kitchenware 191、container 143、food 78、vegetable 43、appliance 42……作者为 NVIDIA 2536、Palatial Platforms 957、ForgeCAD 45、LG、Vertiv、机器人厂商等。**库里没有房屋、石桥、水车、船、树木、灯笼、人物、牛车**（「stone arch bridge」的第一个结果是餐巾架，「large old tree」是马克杯架）——它是面向机器人仿真的仓库 / 厨房 / 工业资产库，不是场景库。
+  - **能用的部分**：集市摊位上的货物。从 Palatial NV Asset Library（CC-BY-4.0，扫描 / 实拍重建，含 4K PBR 贴图）选了 18 件与江南集市相称的：竹篮、提篮、果篮、蛋篮、木碗、茶壶、茶杯、铁锅、木箱、木盒、陶瓶、大白菜、茄子、米缸、陶罐、面粉袋、馒头。
+  - **USD → 网页**：浏览器不能直接加载 USD，写了 `tools/jiangnan/usd2glb.py`（usd-core 读 UsdPreviewSurface 材质与网格 → 三角化、烘焙世界变换、Z-up 转 Y-up → pymeshlab 保留贴图坐标的二次误差简化到 1 200–6 000 面 → 贴图缩到 512、金属度 / 粗糙度打包成 glTF 规范 → 写 GLB）。原始资产每件 30–90 MB（27 万三角形、4K 贴图），转换后每件 45–435 KB，18 件共 4.3 MB，放在 `public/jiangnan/models/`。
+  - **接入**（`engine/assets.ts`）：GLTFLoader 加载后换成本项目带高度雾的材质；每个摊位随机 3–4 种台面货物 + 1–2 种地面货物，按资产真实尺寸（米）落在桌面网格上，同种模型用 InstancedMesh 一次绘制；原来的程序化「多面体果子 + 圆柱篮子 + 车削陶罐」在模型加载成功后隐藏，加载失败（离线 / 被拦截）时自动保留，画面不会空。加载进度显示为「摆上竹篮、陶罐与瓜菜（SimReady 扫描模型）」。
+  - 版权：Palatial NV Asset Library，CC-BY-4.0，页脚已署名。
+  - 验证：类型检查与构建通过，18 个 GLB 由本地静态服务器正常返回；无头浏览器截图见下方（若本步日志末尾没有截图结论，说明沙盒再次回收了临时目录，未能完成）。
 
 ---
 

src/jiangnan/JiangnanApp.tsx

@@ -408,7 +408,7 @@ export default function JiangnanApp() {
         </section>
 
         <footer className="jn-foot">
-          《暮归江南》全部画面在浏览器中实时生成：程序化地形与民居、平面反射水面、高度雾、体积光、辉光与胶片调色；配乐为程序合成的五声音阶原创曲（古筝物理建模、竹箫、弦乐、编钟），环境音效同样为程序合成；旁白为原创文案的中文语音合成。字体：马善政楷书、霞鹜文楷（SIL OFL）。
+          《暮归江南》全部画面在浏览器中实时生成：程序化地形与民居、平面反射水面、高度雾、体积光、辉光与胶片调色；配乐为程序合成的五声音阶原创曲（古筝物理建模、竹箫、弦乐、编钟），环境音效同样为程序合成；旁白为原创文案的中文语音合成。字体：马善政楷书、霞鹜文楷（SIL OFL）。集市货物模型（竹篮、木碗、茶具、瓜菜、米缸等 18 件）来自 NVIDIA SimReady Central · Palatial NV Asset Library（CC-BY-4.0），由 USD 转换为网页用 GLB。
         </footer>
       </div>
       {toast && <div className="jn-toast">{toast}</div>}

src/jiangnan/engine/Film.ts

@@ -1,5 +1,6 @@
 // The film: builds the world once and renders any time t deterministically.
 import * as THREE from 'three'
+import { AssetsOut, createAssets } from './assets'
 import { applyPose, cameraAt } from './camera'
 import { TERRACE, TREE_POS } from './layout'
 import { createLanterns, createLife, LanternSet, LifeOut } from './life'
@@ -33,6 +34,7 @@ export class Film {
   lanterns!: LanternSet
   life!: LifeOut
   props!: PropsOut
+  assets: AssetsOut | null = null
   village!: VillageOut
   pmrem: THREE.PMREMGenerator
   envScene = new THREE.Scene()
@@ -232,6 +234,17 @@ export class Film {
     await tick()
     this.props = createProps()
     s.add(this.props.group)
+    progress(0.66, '摆上竹篮、陶罐与瓜菜（SimReady 扫描模型）')
+    await tick()
+    try {
+      this.assets = await createAssets(this.props.stalls, (p) => progress(0.66 + p * 0.06, '摆上竹篮、陶罐与瓜菜（SimReady 扫描模型）'))
+      if (this.assets.loaded.length) {
+        s.add(this.assets.group)
+        // the scanned goods replace the procedural ones
+        for (const m of this.props.proceduralGoods) m.visible = false
+      }
+      if (this.assets.failed.length) console.warn('[暮归江南] 未能加载的模型：', this.assets.failed.join(', '))
+    } catch (e) { console.warn('[暮归江南] 扫描模型加载失败，使用程序化货物', e) }
     progress(0.72, '种下古樟与竹林')
     await tick()
     const trees = createTrees(this.quality)

src/jiangnan/engine/assets.ts

@@ -0,0 +1,144 @@
+// Scanned / artist-made props from NVIDIA SimReady Central (Palatial NV Asset Library, CC-BY-4.0),
+// converted offline from USD to small GLBs (tools/jiangnan/usd2glb.py) and dressed onto the
+// market stalls and quay as instanced meshes. The procedural goods stay as a fallback when the
+// files cannot be loaded (offline / blocked), so the film never shows an empty stall.
+import * as THREE from 'three'
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js'
+import { patch } from './materials'
+import { mulberry32 } from './rng'
+import type { StallSpot } from './props'
+
+export interface AssetDef {
+  id: string
+  name: string
+  /** where this prop may be placed */
+  slot: 'table' | 'ground' | 'shelf'
+  /** uniform scale applied to the real-world metres of the asset (1 = true size) */
+  scale?: number
+  /** how many of them per stall slot (random in [min,max]) */
+  count: [number, number]
+}
+
+/** Palatial NV Asset Library IDs (https://huggingface.co/datasets/PalatialSim/palatial-nv-asset-library), CC-BY-4.0 */
+export const ASSETS: AssetDef[] = [
+  { id: 'D00006', name: '竹篮', slot: 'table', count: [1, 2] },
+  { id: 'D00016', name: '提篮', slot: 'table', count: [1, 2] },
+  { id: 'D00323', name: '果篮', slot: 'table', count: [1, 1] },
+  { id: 'D00395', name: '蛋篮', slot: 'table', count: [0, 1] },
+  { id: 'D00952', name: '木碗', slot: 'table', count: [1, 3] },
+  { id: 'D00854', name: '茶壶', slot: 'table', count: [0, 1] },
+  { id: 'D00855', name: '茶杯', slot: 'table', count: [1, 3] },
+  { id: 'D00945', name: '铁锅', slot: 'table', count: [0, 1] },
+  { id: 'D00953', name: '木箱', slot: 'ground', count: [1, 2] },
+  { id: 'D00954', name: '木盒', slot: 'table', count: [0, 1] },
+  { id: 'D00902', name: '陶瓶', slot: 'table', count: [1, 2] },
+  { id: 'D00645', name: '大白菜', slot: 'table', count: [2, 4] },
+  { id: 'D00638', name: '茄子', slot: 'table', count: [2, 5] },
+  { id: 'D00668', name: '米缸', slot: 'ground', count: [1, 2] },
+  { id: 'D00839', name: '陶罐', slot: 'table', count: [1, 2] },
+  { id: 'D00930', name: '面粉袋', slot: 'ground', count: [1, 2] },
+  { id: 'D00479', name: '馒头', slot: 'table', count: [3, 6] },
+]
+
+export interface AssetsOut {
+  group: THREE.Group
+  loaded: string[]
+  failed: string[]
+  triangles: number
+}
+
+const base = () => new URL('models/', document.baseURI).href
+
+async function loadGlb(loader: GLTFLoader, id: string) {
+  const g = await loader.loadAsync(`${base()}${id}.glb`)
+  const meshes: THREE.Mesh[] = []
+  g.scene.traverse((o) => { if ((o as THREE.Mesh).isMesh) meshes.push(o as THREE.Mesh) })
+  if (!meshes.length) throw new Error('empty')
+  // merge into one geometry (all our conversions bake transforms, so geometries are already world-space)
+  const geo = meshes.length === 1 ? meshes[0].geometry : meshes[0].geometry
+  const src = meshes[0].material as THREE.MeshStandardMaterial
+  const mat = patch(new THREE.MeshStandardMaterial({
+    map: src.map, normalMap: src.normalMap, roughnessMap: src.roughnessMap, metalnessMap: src.metalnessMap,
+    color: src.color, roughness: src.roughness, metalness: Math.min(src.metalness, 0.6),
+  }), { key: 'asset-' + id })
+  if (mat.map) mat.map.colorSpace = THREE.SRGBColorSpace
+  geo.computeBoundingBox()
+  return { geo, mat, box: geo.boundingBox! }
+}
+
+/**
+ * Load the catalogue and scatter the props over the stall spots. Resolves even when some
+ * (or all) files fail; the caller hides the procedural goods only for stalls that got assets.
+ */
+export async function createAssets(stalls: StallSpot[], onProgress?: (p: number) => void): Promise<AssetsOut> {
+  const group = new THREE.Group()
+  const out: AssetsOut = { group, loaded: [], failed: [], triangles: 0 }
+  const loader = new GLTFLoader()
+  const rng = mulberry32(2026)
+  const models = new Map<string, Awaited<ReturnType<typeof loadGlb>>>()
+  let done = 0
+  await Promise.all(ASSETS.map(async (a) => {
+    try { models.set(a.id, await loadGlb(loader, a.id)); out.loaded.push(a.id) } catch { out.failed.push(a.id) }
+    onProgress?.(++done / ASSETS.length)
+  }))
+  if (!models.size) return out
+
+  // plan instances: per stall, a handful of table props and ground props, never overlapping badly
+  const placements = new Map<string, THREE.Matrix4[]>()
+  const tmp = new THREE.Matrix4(), rot = new THREE.Matrix4(), scl = new THREE.Matrix4(), tr = new THREE.Matrix4()
+  const put = (id: string, stallM: THREE.Matrix4, x: number, y: number, z: number, yaw: number, s: number) => {
+    const m = models.get(id)!
+    // sit the asset on its bounding-box floor, centred on x/z
+    const cx = (m.box.min.x + m.box.max.x) / 2, cz = (m.box.min.z + m.box.max.z) / 2
+    tr.makeTranslation(x, y, z)
+    rot.makeRotationY(yaw)
+    scl.makeScale(s, s, s)
+    tmp.copy(stallM).multiply(tr).multiply(rot).multiply(scl).multiply(new THREE.Matrix4().makeTranslation(-cx, -m.box.min.y, -cz))
+    if (!placements.has(id)) placements.set(id, [])
+    placements.get(id)!.push(tmp.clone())
+  }
+  for (const st of stalls) {
+    st.dressed = true
+    const table = ASSETS.filter((a) => a.slot === 'table' && models.has(a.id))
+    const ground = ASSETS.filter((a) => a.slot === 'ground' && models.has(a.id))
+    // table top is 2.2 × 1.0 m at y = 0.82 (see props.ts)
+    const cells: [number, number][] = []
+    for (let i = -2; i <= 2; i++) for (let j = -1; j <= 1; j++) cells.push([i * 0.42, j * 0.3])
+    for (let k = cells.length - 1; k > 0; k--) { const r = Math.floor(rng() * (k + 1)); [cells[k], cells[r]] = [cells[r], cells[k]] }
+    // 3–4 kinds per stall, so each stall reads differently
+    const kinds = [...table].sort(() => rng() - 0.5).slice(0, 3 + Math.floor(rng() * 2))
+    let c = 0
+    for (const a of kinds) {
+      const n = a.count[0] + Math.floor(rng() * (a.count[1] - a.count[0] + 1))
+      for (let i = 0; i < n && c < cells.length; i++) {
+        const [x, z] = cells[c++]
+        put(a.id, st.m, x + (rng() - 0.5) * 0.08, 0.82, z + (rng() - 0.5) * 0.08, rng() * Math.PI * 2, (a.scale ?? 1) * (0.95 + rng() * 0.1))
+      }
+    }
+    // ground: beside / under the table, toward the street
+    const gk = [...ground].sort(() => rng() - 0.5).slice(0, 2)
+    let gx = -1.15
+    for (const a of gk) {
+      const n = a.count[0] + Math.floor(rng() * (a.count[1] - a.count[0] + 1))
+      for (let i = 0; i < n; i++) {
+        put(a.id, st.m, gx + rng() * 0.2, 0, 0.75 + rng() * 0.25, rng() * Math.PI * 2, (a.scale ?? 1) * (0.95 + rng() * 0.1))
+        gx += 0.55
+        if (gx > 1.2) break
+      }
+    }
+  }
+  for (const [id, ms] of placements) {
+    const m = models.get(id)!
+    const inst = new THREE.InstancedMesh(m.geo, m.mat, ms.length)
+    ms.forEach((mat, i) => inst.setMatrixAt(i, mat))
+    inst.instanceMatrix.needsUpdate = true
+    inst.castShadow = true
+    inst.receiveShadow = true
+    inst.layers.set(1) // main view only (too small to matter in the water reflection)
+    inst.frustumCulled = true
+    inst.computeBoundingSphere()
+    group.add(inst)
+    out.triangles += (m.geo.index ? m.geo.index.count / 3 : m.geo.attributes.position.count / 3) * ms.length
+  }
+  return out
+}

src/jiangnan/engine/props.ts

@@ -27,8 +27,14 @@ function projectUV(geo: THREE.BufferGeometry, scale: number) {
   return g
 }
 
+export interface StallSpot { m: THREE.Matrix4; kind: number; dressed: boolean }
+
 export interface PropsOut {
   group: THREE.Group
+  /** market stall tables (local frame: table top 2.2 × 1.0 m at y = 0.82, street toward +z) */
+  stalls: StallSpot[]
+  /** procedural goods (hidden when scanned assets are dressed onto the stalls) */
+  proceduralGoods: THREE.Mesh[]
   wheel: THREE.Group
   wheelInfo: { center: THREE.Vector3; axis: THREE.Vector3; radius: number; tangent: THREE.Vector3 }
   bridgeInfo: { center: THREE.Vector3; across: THREE.Vector3; along: THREE.Vector3; crestY: number; halfLen: number; deckY: (x: number) => number }
@@ -262,6 +268,7 @@ export function createProps(): PropsOut {
   const jarGeos = [jarProfile(0.28, 0.7), jarProfile(0.4, 0.9), jarProfile(0.2, 0.45)]
   const basketGeo = new THREE.CylinderGeometry(0.42, 0.32, 0.35, 16, 1, true)
   const fruitGeo = new THREE.IcosahedronGeometry(0.075, 0)
+  const stalls: StallSpot[] = []
   for (let s = MARKET_S0; s < MARKET_S1; s += rrange(rng, 5.5, 8)) {
     if (Math.abs(s - BRIDGE_S) < 12) continue
     const p = riverPoint(s, -9.6)
@@ -271,6 +278,7 @@ export function createProps(): PropsOut {
     wood.box(0, 0.78, 0, 2.2, 0.08, 1.0)
     for (const [lx, lz] of [[-1, -0.42], [1, -0.42], [-1, 0.42], [1, 0.42]]) wood.box(lx, 0.39, lz, 0.07, 0.78, 0.07)
     const kind = Math.floor(rng() * 4)
+    stalls.push({ m: m.clone(), kind, dressed: false })
     if (kind === 0 || kind === 3) {
       // baskets of produce
       for (let k = 0; k < 3; k++) {
@@ -462,6 +470,7 @@ export function createProps(): PropsOut {
     mesh.receiveShadow = true
     if (!reflect) mesh.layers.set(1)
     group.add(mesh)
+    return mesh
   }
   add(stone, stoneMat)
   add(wood, woodMat)
@@ -469,14 +478,12 @@ export function createProps(): PropsOut {
   add(red, redMat)
   add(roof, roofMat)
   // market goods: small, main view only
-  add(goods, fruitMat, false, false)
-  add(basket, basketMat, false, false)
-  add(jars, jarMat, false, false)
+  const proceduralGoods = [add(goods, fruitMat, false, false), add(basket, basketMat, false, false), add(jars, jarMat, false, false)].filter((m) => !!m) as THREE.Mesh[]
   add(meat, meatMat, true, false)
   add(awning, awningMat, true, false)
 
   return {
-    group, wheel,
+    group, wheel, stalls, proceduralGoods,
     wheelInfo: { center: wheelC, axis: wheelAxis, radius: wheelR, tangent: wheelTan },
     bridgeInfo: { center: V3(bp.x, 0, bp.z), across, along, crestY: crest, halfLen, deckY },
     lanternSpots, boats, movingBoat, cloths, pavilion: pv,

tools/jiangnan/simready_search.py

@@ -0,0 +1,27 @@
+# Query NVIDIA SimReady Central (https://nvidia-simready-central.hf.space/) and list the catalogue.
+# usage: simready_search.py "<text query>" [limit]     |   simready_search.py --catalog  (dump every asset to catalog.json)
+import json, sys, urllib.request, collections
+API = "https://nvidia-simready-central.hf.space/search_hybrid"
+def call(body):
+    req = urllib.request.Request(API, data=json.dumps(body).encode(), headers={"Content-Type": "application/json", "x-usdsearch-storage-backend": "simready-assets"})
+    return json.load(urllib.request.urlopen(req, timeout=120))
+def props(h):
+    return {x["name"]: x.get("value") for x in h["source"].get("usd_properties", [])}
+if sys.argv[1] == "--catalog":
+    items, cursor = [], None
+    while True:
+        body = {"description": "object", "limit": 500, "return_usd_properties": True, "filter_by_properties": "simready_metadata_asset_name="}
+        if cursor: body["cursor"] = cursor
+        r = call(body)
+        for h in r["hits"]:
+            p = props(h)
+            items.append({"name": p.get("simready_metadata_asset_name"), "cat": p.get("simready_metadata_category"), "ext": p.get("simready_metadata_asset_extents"), "lic": p.get("simready_metadata_asset_license"), "author": p.get("simready_metadata_author"), "path": h["source"]["path"]})
+        cursor = r.get("next_cursor")
+        if not r.get("has_more") or not cursor: break
+    json.dump(items, open("catalog.json", "w"), ensure_ascii=False, indent=1)
+    print(len(items), "assets;", collections.Counter(i["cat"] for i in items).most_common(25))
+else:
+    r = call({"description": sys.argv[1], "limit": int(sys.argv[2]) if len(sys.argv) > 2 else 10, "return_usd_properties": True})
+    for h in r["hits"]:
+        p = props(h)
+        print(f'{h["score"]:.3f}  {p.get("simready_metadata_asset_name")!s:40s} {p.get("simready_metadata_category")!s:14s} {p.get("simready_metadata_asset_license")!s:10s} {h["source"]["path"]}')

tools/jiangnan/usd2glb.py

@@ -0,0 +1,180 @@
+# Minimal USD (UsdPreviewSurface) → GLB converter for SimReady assets: triangulates render meshes,
+# bakes world transforms, Z-up → Y-up, downsizes textures, packs metallic/roughness for glTF.
+import sys, json, struct, io, os
+import numpy as np
+from PIL import Image
+from pxr import Usd, UsdGeom, UsdShade, Gf
+
+src, dst, texsize = sys.argv[1], sys.argv[2], int(sys.argv[3]) if len(sys.argv) > 3 else 512
+st = Usd.Stage.Open(src)
+zup = UsdGeom.GetStageUpAxis(st) == 'Z'
+mpu = UsdGeom.GetStageMetersPerUnit(st) or 1.0
+cache = UsdGeom.XformCache(Usd.TimeCode.Default())
+
+def tex_path(shader_prim, inp):
+    """follow a UsdPreviewSurface input to the file of a UsdUVTexture, if any"""
+    i = UsdShade.Shader(shader_prim).GetInput(inp)
+    if not i: return None
+    srcs = i.GetConnectedSources()[0] if hasattr(i, 'GetConnectedSources') else []
+    for s in srcs:
+        sh = UsdShade.Shader(s.source.GetPrim())
+        if sh.GetIdAttr().Get() == 'UsdUVTexture':
+            f = sh.GetInput('file').Get()
+            if f: return f.resolvedPath or f.path
+    return None
+
+materials = {}  # mat path -> dict
+def material_for(prim):
+    b = UsdShade.MaterialBindingAPI(prim).ComputeBoundMaterial()[0]
+    if not b: return None
+    key = str(b.GetPath())
+    if key in materials: return key
+    surf = b.ComputeSurfaceSource()[0] if hasattr(b, 'ComputeSurfaceSource') else None
+    info = {'base': None, 'normal': None, 'rough': None, 'metal': None, 'color': [1, 1, 1], 'roughness': 0.6, 'metallic': 0.0}
+    if surf:
+        p = surf.GetPrim()
+        info['base'] = tex_path(p, 'diffuseColor'); info['normal'] = tex_path(p, 'normal')
+        info['rough'] = tex_path(p, 'roughness'); info['metal'] = tex_path(p, 'metallic')
+        s = UsdShade.Shader(p)
+        c = s.GetInput('diffuseColor').Get() if s.GetInput('diffuseColor') else None
+        if c and not info['base']: info['color'] = [float(c[0]), float(c[1]), float(c[2])]
+        r = s.GetInput('roughness').Get() if s.GetInput('roughness') else None
+        if isinstance(r, float): info['roughness'] = r
+        m = s.GetInput('metallic').Get() if s.GetInput('metallic') else None
+        if isinstance(m, float): info['metallic'] = m
+    materials[key] = info
+    return key
+
+meshes = []
+for prim in st.Traverse():
+    if prim.GetTypeName() != 'Mesh': continue
+    img = UsdGeom.Imageable(prim)
+    if img.ComputePurpose() not in ('default', 'render'): continue
+    if img.ComputeVisibility() == 'invisible': continue
+    path = str(prim.GetPath()).lower()
+    if 'collision' in path or 'physics' in path or 'proxy' in path: continue
+    m = UsdGeom.Mesh(prim)
+    pts = np.array(m.GetPointsAttr().Get(), dtype=np.float64)
+    if len(pts) == 0: continue
+    fvc = np.array(m.GetFaceVertexCountsAttr().Get(), dtype=np.int64)
+    fvi = np.array(m.GetFaceVertexIndicesAttr().Get(), dtype=np.int64)
+    uvp = UsdGeom.PrimvarsAPI(prim).GetPrimvar('st')
+    uv = None; uvInterp = None; uvIdx = None
+    if uvp and uvp.HasValue():
+        uv = np.array(uvp.Get(), dtype=np.float64); uvInterp = uvp.GetInterpolation()
+        if uvp.IsIndexed(): uvIdx = np.array(uvp.GetIndices(), dtype=np.int64)
+    nrm = m.GetNormalsAttr().Get(); nInterp = m.GetNormalsInterpolation() if nrm else None
+    nrm = np.array(nrm, dtype=np.float64) if nrm else None
+    xf = cache.GetLocalToWorldTransform(prim)
+    M = np.array([[xf[r][c] for c in range(4)] for r in range(4)])  # row-major, row vectors
+    # triangulate (fan), expand to flat vertex list
+    P, N, T = [], [], []
+    fi = 0
+    for f, cnt in enumerate(fvc):
+        idx = fvi[fi:fi + cnt]
+        for k in range(1, cnt - 1):
+            for corner in (0, k, k + 1):
+                vi = idx[corner]; ci = fi + corner
+                P.append(pts[vi])
+                if uv is not None:
+                    if uvInterp == 'faceVarying': u = uv[uvIdx[ci]] if uvIdx is not None else uv[ci]
+                    elif uvInterp == 'vertex' or uvInterp == 'varying': u = uv[uvIdx[vi]] if uvIdx is not None else uv[vi]
+                    else: u = [0, 0]
+                    T.append(u)
+                if nrm is not None:
+                    if nInterp == 'faceVarying': N.append(nrm[ci])
+                    elif nInterp in ('vertex', 'varying'): N.append(nrm[vi])
+                    elif nInterp == 'uniform': N.append(nrm[f])
+        fi += cnt
+    P = np.array(P); P1 = np.c_[P, np.ones(len(P))] @ M; P = P1[:, :3] * mpu
+    if nrm is not None and len(N) == len(P):
+        N = np.array(N) @ np.linalg.inv(M[:3, :3]).T
+    else:
+        N = np.zeros_like(P)
+        for i in range(0, len(P), 3):
+            n = np.cross(P[i + 1] - P[i], P[i + 2] - P[i]); N[i:i + 3] = n
+    N /= np.maximum(np.linalg.norm(N, axis=1, keepdims=True), 1e-9)
+    if zup:
+        P = P[:, [0, 2, 1]] * [1, 1, -1]; N = N[:, [0, 2, 1]] * [1, 1, -1]
+    # flip winding? Z->Y mapping (x,y,z)->(x,z,-y) is a proper rotation, so no.
+    T = np.array(T) if len(T) == len(P) else np.zeros((len(P), 2))
+    T[:, 1] = 1 - T[:, 1]
+    # decimate (texture-preserving quadric edge collapse) when the mesh is far heavier than a web prop needs
+    target = int(os.environ.get('TARGET_TRIS', '6000'))
+    if len(P) // 3 > target * 1.3:
+        import pymeshlab
+        ms = pymeshlab.MeshSet()
+        faces = np.arange(len(P)).reshape(-1, 3)
+        ms.add_mesh(pymeshlab.Mesh(vertex_matrix=P.astype(np.float64), face_matrix=faces, v_normals_matrix=N.astype(np.float64), v_tex_coords_matrix=T.astype(np.float64)))
+        ms.apply_filter('compute_texcoord_transfer_vertex_to_wedge')
+        ms.apply_filter('meshing_remove_duplicate_vertices')
+        ms.apply_filter('meshing_decimation_quadric_edge_collapse_with_texture', targetfacenum=target, qualitythr=0.4, preserveboundary=True, planarquadric=True)
+        ms.apply_filter('compute_normal_per_vertex')
+        mm = ms.current_mesh()
+        V, F = mm.vertex_matrix(), mm.face_matrix()
+        VN = mm.vertex_normal_matrix()
+        WT = mm.wedge_tex_coord_matrix()  # per-corner uv (3 per face)
+        P = V[F.reshape(-1)]; N = VN[F.reshape(-1)]; T = WT.reshape(-1, 2)
+    # weld
+    key = np.round(np.c_[P, N, T], 5)
+    _, first, inv = np.unique(key, axis=0, return_index=True, return_inverse=True)
+    order = np.argsort(first); remap = np.empty_like(order); remap[order] = np.arange(len(order))
+    inv = remap[inv.reshape(-1)]
+    Pw, Nw, Tw = P[first[order]], N[first[order]], T[first[order]]
+    meshes.append((material_for(prim), Pw.astype(np.float32), Nw.astype(np.float32), Tw.astype(np.float32), inv.astype(np.uint32)))
+
+# --- textures
+def load(p, mode):
+    if not p or not os.path.exists(p): return None
+    im = Image.open(p).convert(mode); im.thumbnail((texsize, texsize), Image.LANCZOS); return im
+images, imgbytes = [], []
+def add_image(im, fmt):
+    b = io.BytesIO(); im.save(b, fmt, quality=88) if fmt == 'JPEG' else im.save(b, fmt, optimize=True)
+    images.append({'mimeType': 'image/jpeg' if fmt == 'JPEG' else 'image/png'}); imgbytes.append(b.getvalue()); return len(images) - 1
+mat_index = {}; gmats = []
+for key, info in materials.items():
+    gm = {'name': key.split('/')[-1], 'pbrMetallicRoughness': {'baseColorFactor': info['color'] + [1], 'metallicFactor': info['metallic'] if not info['metal'] else 1.0, 'roughnessFactor': info['roughness'] if not info['rough'] else 1.0}}
+    base = load(info['base'], 'RGB')
+    if base: gm['pbrMetallicRoughness']['baseColorTexture'] = {'index': add_image(base, 'JPEG')}; gm['pbrMetallicRoughness']['baseColorFactor'] = [1, 1, 1, 1]
+    rough, metal = load(info['rough'], 'L'), load(info['metal'], 'L')
+    if rough or metal:
+        sz = (rough or metal).size
+        mr = Image.merge('RGB', [Image.new('L', sz, 255), rough or Image.new('L', sz, int(info['roughness'] * 255)), metal or Image.new('L', sz, int(info['metallic'] * 255))])
+        gm['pbrMetallicRoughness']['metallicRoughnessTexture'] = {'index': add_image(mr, 'JPEG')}
+    normal = load(info['normal'], 'RGB')
+    if normal: gm['normalTexture'] = {'index': add_image(normal, 'JPEG')}
+    mat_index[key] = len(gmats); gmats.append(gm)
+
+# --- buffers
+bin_parts = []; views = []; accessors = []; gmeshes = []; nodes = []
+def push(data, target=None):
+    off = sum(len(p) for p in bin_parts)
+    while off % 4: bin_parts.append(b'\0'); off += 1
+    bin_parts.append(data); v = {'buffer': 0, 'byteOffset': off, 'byteLength': len(data)}
+    if target: v['target'] = target
+    views.append(v); return len(views) - 1
+for mi, (mk, P, N, T, I) in enumerate(meshes):
+    pv = push(P.tobytes(), 34962); nv = push(N.tobytes(), 34962); tv = push(T.tobytes(), 34962); iv = push(I.tobytes(), 34963)
+    accessors += [
+        {'bufferView': pv, 'componentType': 5126, 'count': len(P), 'type': 'VEC3', 'min': P.min(0).tolist(), 'max': P.max(0).tolist()},
+        {'bufferView': nv, 'componentType': 5126, 'count': len(N), 'type': 'VEC3'},
+        {'bufferView': tv, 'componentType': 5126, 'count': len(T), 'type': 'VEC2'},
+        {'bufferView': iv, 'componentType': 5125, 'count': len(I), 'type': 'SCALAR'}]
+    a = len(accessors) - 4
+    prim = {'attributes': {'POSITION': a, 'NORMAL': a + 1, 'TEXCOORD_0': a + 2}, 'indices': a + 3}
+    if mk in mat_index: prim['material'] = mat_index[mk]
+    gmeshes.append({'primitives': [prim]}); nodes.append({'mesh': mi})
+for i, b in enumerate(imgbytes):
+    images[i]['bufferView'] = push(b)
+binblob = b''.join(bin_parts)
+while len(binblob) % 4: binblob += b'\0'
+gltf = {'asset': {'version': '2.0', 'generator': 'usd2glb (暮归江南)'}, 'scene': 0, 'scenes': [{'nodes': list(range(len(nodes)))}], 'nodes': nodes, 'meshes': gmeshes,
+        'materials': gmats, 'images': images, 'textures': [{'source': i, 'sampler': 0} for i in range(len(images))], 'samplers': [{'magFilter': 9729, 'minFilter': 9987, 'wrapS': 10497, 'wrapT': 10497}],
+        'accessors': accessors, 'bufferViews': views, 'buffers': [{'byteLength': len(binblob)}]}
+if not images: gltf.pop('images'); gltf.pop('textures'); gltf.pop('samplers')
+js = json.dumps(gltf, separators=(',', ':')).encode()
+while len(js) % 4: js += b' '
+out = b'glTF' + struct.pack('<II', 2, 12 + 8 + len(js) + 8 + len(binblob)) + struct.pack('<II', len(js), 0x4E4F534A) + js + struct.pack('<II', len(binblob), 0x004E4942) + binblob
+open(dst, 'wb').write(out)
+allP = np.concatenate([m[1] for m in meshes]); tris = sum(len(m[4]) // 3 for m in meshes)
+print(f'{os.path.basename(dst)}: meshes={len(meshes)} tris={tris} verts={len(allP)} size={len(out)//1024}KB bbox_min={allP.min(0).round(3).tolist()} bbox_max={allP.max(0).round(3).tolist()} mats={len(gmats)} imgs={len(images)}')