three-usd-robot 0.10.0 → 0.11.0

package/dist/{chunk-NFKK5LJK.js → chunk-AXPMXEQC.js}

@@ -1,4 +1,4 @@
-import { Quat, multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, RAD2DEG, AssetPath, UsdMatrix } from './chunk-IYKPVUZ2.js';
+import { Quat, multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, RAD2DEG, AssetPath, UsdMatrix } from './chunk-LDO5FKQS.js';
 import { unzipSync } from 'fflate';
 
 // src/schemas/usdGeom.ts
@@ -282,122 +282,594 @@ function asMatrix(v, where) {
   throw new Error(`${where}: expected a matrix`);
 }
 
+// src/usd/AssetResolver.ts
+var DefaultAssetResolver = class {
+  resolve(assetPath, baseUrl) {
+    try {
+      return new URL(assetPath, baseUrl || void 0).href;
+    } catch {
+      return joinPosix(baseUrl, assetPath);
+    }
+  }
+  async fetchText(url) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return res.text();
+  }
+  async fetchBytes(url) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+};
+function createMemoryResolver(files) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return {
+    resolve(assetPath, baseUrl) {
+      return joinPosix(baseUrl, assetPath);
+    },
+    fetchText(url) {
+      const v = files[url];
+      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
+      return Promise.resolve(typeof v === "string" ? v : decoder.decode(v));
+    },
+    fetchBytes(url) {
+      const v = files[url];
+      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
+      return Promise.resolve(typeof v === "string" ? encoder.encode(v) : v);
+    }
+  };
+}
+function joinPosix(baseUrl, rel) {
+  if (rel.startsWith("/")) return normalizePosix(rel);
+  const dir = baseUrl.slice(0, baseUrl.lastIndexOf("/") + 1);
+  return normalizePosix(dir + rel);
+}
+function normalizePosix(path) {
+  const isAbsolute = path.startsWith("/");
+  const out = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return (isAbsolute ? "/" : "") + out.join("/");
+}
+
+// src/usd/mdl/parseMdl.ts
+function isMdlTexture(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "assetPath" in value;
+}
+function parseMdl(text) {
+  const src = stripNoise(text);
+  const materials = /* @__PURE__ */ new Map();
+  const declRe = /\bexport\s+material\s+([A-Za-z_]\w*)\s*\(/g;
+  let match = declRe.exec(src);
+  while (match) {
+    const open = match.index + match[0].length - 1;
+    const close = matchParen(src, open);
+    if (close === -1) break;
+    const decl = {
+      name: match[1],
+      defaults: parseParamDefaults(src.slice(open + 1, close - 1)),
+      args: /* @__PURE__ */ new Map()
+    };
+    let next = close;
+    let i = close;
+    while (i < src.length && /\s/.test(src[i])) i++;
+    if (src[i] === "=") {
+      const end = statementEnd(src, i + 1);
+      const body = parseWrapperBody(src.slice(i + 1, end));
+      if (body.base) decl.base = body.base;
+      decl.args = body.args;
+      next = end;
+    }
+    materials.set(decl.name, decl);
+    declRe.lastIndex = next;
+    match = declRe.exec(src);
+  }
+  return { materials };
+}
+var NUMBER_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?[fFdD]?$/;
+var CALL_RE = /^(?:::)?([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)\s*\(/;
+var VECTOR_RE = /^(?:color|(?:float|double|int)([234]))$/;
+var IDENTIFIER_RE = /^[A-Za-z_]\w*$/;
+function parseMdlLiteral(src) {
+  const s = src.trim();
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (NUMBER_RE.test(s)) return Number.parseFloat(s.replace(/[fFdD]$/, ""));
+  if (s.startsWith('"')) {
+    if (skipString(s, 0) !== s.length) return void 0;
+    return s.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  const call = CALL_RE.exec(s);
+  if (!call) return void 0;
+  const open = call[0].length - 1;
+  if (matchParen(s, open) !== s.length) return void 0;
+  const name = call[1].split("::").pop();
+  const args = splitTopLevel(s.slice(open + 1, s.length - 1), ",").map((a) => a.trim()).filter((a) => a.length > 0);
+  if (name === "texture_2d") {
+    const path = args[0] === void 0 ? void 0 : parseMdlLiteral(args[0]);
+    if (typeof path !== "string" || path.length === 0) return void 0;
+    const texture = { assetPath: path };
+    const gamma = args.slice(1).join(",");
+    if (gamma.includes("gamma_srgb")) texture.sourceColorSpace = "sRGB";
+    else if (gamma.includes("gamma_linear")) texture.sourceColorSpace = "raw";
+    return texture;
+  }
+  const vector = VECTOR_RE.exec(name);
+  if (vector) {
+    const width = vector[1] ? Number(vector[1]) : 3;
+    const values = args.map((a) => parseMdlLiteral(a));
+    if (values.length === 0 || !values.every((v) => typeof v === "number")) return void 0;
+    if (values.length === 1) return new Array(width).fill(values[0]);
+    return values.length === width ? values : void 0;
+  }
+  return void 0;
+}
+function parseParamDefaults(src) {
+  const defaults = /* @__PURE__ */ new Map();
+  const body = src.trim();
+  if (body === "" || body === "*") return defaults;
+  for (const param of splitTopLevel(src, ",")) {
+    const assign = topLevelAssign(param);
+    if (assign === -1) continue;
+    const name = param.slice(0, assign).trim().split(/\s+/).pop();
+    if (!name || !IDENTIFIER_RE.test(name)) continue;
+    const value = parseMdlLiteral(param.slice(assign + 1));
+    if (value !== void 0) defaults.set(name, value);
+  }
+  return defaults;
+}
+function parseWrapperBody(src) {
+  const args = /* @__PURE__ */ new Map();
+  const body = src.trim();
+  const call = CALL_RE.exec(body);
+  if (!call) return { args };
+  const open = call[0].length - 1;
+  if (matchParen(body, open) !== body.length) return { args };
+  const base = call[1].split("::").pop();
+  if (base === "material") return { args };
+  for (const arg of splitTopLevel(body.slice(open + 1, body.length - 1), ",")) {
+    const colon = topLevelColon(arg);
+    if (colon === -1) continue;
+    const name = arg.slice(0, colon).trim();
+    if (!IDENTIFIER_RE.test(name)) continue;
+    const value = parseMdlLiteral(arg.slice(colon + 1));
+    if (value !== void 0) args.set(name, value);
+  }
+  return { base, args };
+}
+function stripNoise(src) {
+  let out = "";
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      const end = skipString(src, i);
+      out += src.slice(i, end);
+      i = end;
+    } else if (c === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+    } else if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      i = end === -1 ? src.length : end + 2;
+      out += " ";
+    } else if (c === "[" && src[i + 1] === "[") {
+      i = skipAnnotation(src, i);
+      out += " ";
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
+}
+function skipString(src, i) {
+  let j = i + 1;
+  while (j < src.length) {
+    if (src[j] === "\\") j += 2;
+    else if (src[j] === '"') return j + 1;
+    else j++;
+  }
+  return j;
+}
+function skipAnnotation(src, i) {
+  let depth = 0;
+  let j = i;
+  while (j < src.length) {
+    if (src[j] === '"') {
+      j = skipString(src, j);
+    } else if (src[j] === "[" && src[j + 1] === "[") {
+      depth++;
+      j += 2;
+    } else if (src[j] === "]" && src[j + 1] === "]") {
+      depth--;
+      j += 2;
+      if (depth === 0) return j;
+    } else {
+      j++;
+    }
+  }
+  return j;
+}
+function matchParen(src, open) {
+  let depth = 0;
+  let i = open;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+    i++;
+  }
+  return -1;
+}
+function isOpener(c) {
+  return c === "(" || c === "[" || c === "{";
+}
+function isCloser(c) {
+  return c === ")" || c === "]" || c === "}";
+}
+function splitTopLevel(src, separator) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === separator && depth === 0) {
+      parts.push(src.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  parts.push(src.slice(start));
+  return parts;
+}
+function statementEnd(src, from) {
+  let depth = 0;
+  let i = from;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === ";" && depth === 0) return i;
+    i++;
+  }
+  return src.length;
+}
+function topLevelAssign(src) {
+  let depth = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === "=" && depth === 0 && src[i + 1] !== "=" && !"<>!=".includes(src[i - 1] ?? "")) {
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function topLevelColon(src) {
+  let depth = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === ":" && depth === 0) {
+      if (src[i + 1] === ":") {
+        i += 2;
+        continue;
+      }
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+
 // src/three/MaterialBinding.ts
 var DIFFUSE_INPUTS = [
-  "inputs:diffuseColor",
+  "diffuseColor",
   // UsdPreviewSurface
-  "inputs:diffuse_color_constant",
+  "diffuse_color_constant",
   // OmniPBR
-  "inputs:diffuse_tint",
-  "inputs:base_color",
-  "inputs:baseColor"
+  "diffuse_tint",
+  "base_color",
+  "baseColor"
 ];
-var OPACITY_INPUTS = ["inputs:opacity", "inputs:opacity_constant"];
-var OPACITY_THRESHOLD_INPUTS = ["inputs:opacityThreshold", "inputs:opacity_threshold"];
-var METALLIC_INPUTS = ["inputs:metallic", "inputs:metallic_constant"];
-var ROUGHNESS_INPUTS = ["inputs:roughness", "inputs:reflection_roughness_constant"];
-var EMISSIVE_INPUTS = ["inputs:emissiveColor", "inputs:emissive_color"];
+var OPACITY_INPUTS = ["opacity", "opacity_constant"];
+var OPACITY_THRESHOLD_INPUTS = ["opacityThreshold", "opacity_threshold"];
+var METALLIC_INPUTS = ["metallic", "metallic_constant"];
+var ROUGHNESS_INPUTS = ["roughness", "reflection_roughness_constant"];
+var EMISSIVE_INPUTS = ["emissiveColor", "emissive_color"];
 var SURFACE_OUTPUTS = ["outputs:surface", "outputs:mdl:surface"];
 var TEXTURE_LOOKUPS = {
   color: {
-    surface: ["inputs:diffuseColor"],
-    direct: ["inputs:diffuse_texture", "inputs:diffuse_color_texture"]
+    surface: ["diffuseColor"],
+    direct: ["diffuse_texture", "diffuse_color_texture", "glass_color_texture"]
   },
   opacity: {
-    surface: ["inputs:opacity"],
-    direct: ["inputs:opacity_texture", "inputs:opacity_color_texture"]
+    surface: ["opacity"],
+    direct: ["opacity_texture", "opacity_color_texture"]
   },
   normal: {
-    surface: ["inputs:normal"],
-    direct: ["inputs:normalmap_texture", "inputs:normal_texture"]
+    surface: ["normal"],
+    direct: ["normalmap_texture", "normal_texture", "normal_map_texture"]
   },
   roughness: {
-    surface: ["inputs:roughness"],
-    direct: ["inputs:reflectionroughness_texture", "inputs:roughness_texture"]
+    surface: ["roughness"],
+    direct: ["reflectionroughness_texture", "roughness_texture"]
   },
   metalness: {
-    surface: ["inputs:metallic"],
-    direct: ["inputs:metallic_texture"]
+    surface: ["metallic"],
+    direct: ["metallic_texture"]
   },
   occlusion: {
-    surface: ["inputs:occlusion"],
-    direct: ["inputs:ao_texture", "inputs:occlusion_texture"]
+    surface: ["occlusion"],
+    direct: ["ao_texture", "occlusion_texture"]
   },
   emissive: {
-    surface: ["inputs:emissiveColor"],
-    direct: ["inputs:emissive_color_texture", "inputs:emissive_mask_texture"]
+    surface: ["emissiveColor"],
+    direct: ["emissive_color_texture", "emissive_mask_texture"]
   }
 };
-function resolveBoundMaterial(stage, prim) {
+function resolveBoundMaterial(stage, prim, options = {}) {
   const materialPath = findBinding(prim);
   if (!materialPath) return void 0;
   const material = stage.GetPrimAtPath(materialPath);
   if (!material) return void 0;
   const shader = findSurfaceShader(material);
   if (!shader) return void 0;
+  const mdlSource = readMdlShaderSource(shader, options.mdl);
+  if (mdlSource && !mdlSource.family) {
+    options.onWarn?.(
+      `${material.GetPath()}: unknown MDL material "${mdlSource.id}" (${mdlSource.assetPath}); applying the best-effort OmniPBR mapping`
+    );
+  }
+  const sv = { shader };
+  if (mdlSource?.values) sv.mdl = mdlSource.values;
+  if (mdlSource) sv.mdlAssetPath = mdlSource.assetPath;
   const result = { name: material.GetName() };
-  const color = firstColor(shader, DIFFUSE_INPUTS);
+  const color = firstColor(sv, DIFFUSE_INPUTS);
   if (color) result.color = color;
-  const opacity = firstNumber(shader, OPACITY_INPUTS);
+  const opacity = firstNumber(sv, OPACITY_INPUTS);
   if (opacity !== void 0) result.opacity = opacity;
-  const opacityThreshold = firstNumber(shader, OPACITY_THRESHOLD_INPUTS);
+  const opacityThreshold = firstNumber(sv, OPACITY_THRESHOLD_INPUTS);
   if (opacityThreshold !== void 0) result.opacityThreshold = opacityThreshold;
-  const metalness = firstNumber(shader, METALLIC_INPUTS);
+  const metalness = firstNumber(sv, METALLIC_INPUTS);
   if (metalness !== void 0) result.metalness = metalness;
-  const roughness = firstNumber(shader, ROUGHNESS_INPUTS);
+  const roughness = firstNumber(sv, ROUGHNESS_INPUTS);
   if (roughness !== void 0) result.roughness = roughness;
-  const emissive = firstColor(shader, EMISSIVE_INPUTS);
-  if (emissive && shader.GetAttribute("inputs:enable_emission").Get() !== false) {
+  const emissive = firstColor(sv, EMISSIVE_INPUTS);
+  if (emissive && svBoolean(sv, "enable_emission") !== false) {
     result.emissiveColor = emissive;
-    const intensity = firstNumber(shader, ["inputs:emissive_intensity"]);
+    const intensity = svNumber(sv, "emissive_intensity");
     if (intensity !== void 0) result.emissiveIntensity = intensity;
   }
-  const ior = firstNumber(shader, ["inputs:ior"]);
+  const ior = svNumber(sv, "ior");
   if (ior !== void 0) result.ior = ior;
-  const clearcoat = firstNumber(shader, ["inputs:clearcoat"]);
+  const clearcoat = svNumber(sv, "clearcoat");
   if (clearcoat !== void 0) result.clearcoat = clearcoat;
-  const clearcoatRoughness = firstNumber(shader, ["inputs:clearcoatRoughness"]);
+  const clearcoatRoughness = svNumber(sv, "clearcoatRoughness");
   if (clearcoatRoughness !== void 0) result.clearcoatRoughness = clearcoatRoughness;
-  if (shader.GetAttribute("inputs:useSpecularWorkflow").Get() === 1) {
-    const specular = firstColor(shader, ["inputs:specularColor"]);
+  if (svNumber(sv, "useSpecularWorkflow") === 1) {
+    const specular = svColor(sv, "specularColor");
     if (specular) result.specularColor = specular;
   }
-  const colorTex = findTexture(shader, TEXTURE_LOOKUPS.color);
+  const colorTex = findTexture(sv, TEXTURE_LOOKUPS.color);
   if (colorTex !== void 0) result.colorTexture = colorTex;
-  const opacityTex = findTexture(shader, TEXTURE_LOOKUPS.opacity);
+  const opacityTex = findTexture(sv, TEXTURE_LOOKUPS.opacity);
   if (opacityTex !== void 0) result.opacityTexture = opacityTex;
-  const normal = findTexture(shader, TEXTURE_LOOKUPS.normal);
+  const normal = findTexture(sv, TEXTURE_LOOKUPS.normal);
   if (normal !== void 0) result.normalTexture = normal;
-  const roughTex = findTexture(shader, TEXTURE_LOOKUPS.roughness);
+  const roughTex = findTexture(sv, TEXTURE_LOOKUPS.roughness);
   if (roughTex !== void 0) result.roughnessTexture = roughTex;
-  const metalTex = findTexture(shader, TEXTURE_LOOKUPS.metalness);
+  const metalTex = findTexture(sv, TEXTURE_LOOKUPS.metalness);
   if (metalTex !== void 0) result.metalnessTexture = metalTex;
-  const aoTex = findTexture(shader, TEXTURE_LOOKUPS.occlusion);
+  const aoTex = findTexture(sv, TEXTURE_LOOKUPS.occlusion);
   if (aoTex !== void 0) result.occlusionTexture = aoTex;
-  const emissiveTex = findTexture(shader, TEXTURE_LOOKUPS.emissive);
+  const emissiveTex = findTexture(sv, TEXTURE_LOOKUPS.emissive);
   if (emissiveTex !== void 0) result.emissiveTexture = emissiveTex;
-  const ormFile = shader.GetAttribute("inputs:ORM_texture").Get();
-  if (shader.GetAttribute("inputs:enable_ORM_texture").Get() === true && ormFile instanceof AssetPath && ormFile.path) {
-    const transform = mdlTextureTransform(shader);
-    const orm = { path: ormFile.path, ...transform ? { transform } : {} };
+  const orm = directTexture(sv, "ORM_texture") ?? mdlValueTexture(sv, "ORM_texture");
+  if (svBoolean(sv, "enable_ORM_texture") === true && orm) {
     result.occlusionTexture = { ...orm, outputChannel: "r" };
     result.roughnessTexture = { ...orm, outputChannel: "g" };
     result.metalnessTexture = { ...orm, outputChannel: "b" };
   }
+  switch (mdlSource?.family) {
+    case "glass":
+      readOmniGlass(sv, result);
+      break;
+    case "clearcoat":
+      readOmniClearCoat(sv, result);
+      break;
+    case "surface":
+      readOmniSurface(sv, result);
+      break;
+  }
   return result;
 }
-function findTexture(shader, lookup) {
+function classifyOmniMdl(name) {
+  if (!name) return void 0;
+  if (name.startsWith("OmniGlass")) return "glass";
+  if (name.startsWith("OmniPBR_ClearCoat")) return "clearcoat";
+  if (name.startsWith("OmniPBR")) return "pbr";
+  if (name.startsWith("OmniSurface")) return "surface";
+  return void 0;
+}
+function readMdlShaderSource(shader, provider) {
+  const asset = shader.GetAttribute("info:mdl:sourceAsset").Get();
+  if (!(asset instanceof AssetPath) || !asset.path) return void 0;
+  const sub = shader.GetAttribute("info:mdl:sourceAsset:subIdentifier").Get();
+  const stem = (asset.path.split("/").pop() ?? "").replace(/\.mdl$/i, "");
+  const id = typeof sub === "string" && sub.length > 0 ? sub : stem;
+  const decl = provider?.(asset.path)?.materials.get(id);
+  const family = classifyOmniMdl(decl?.base) ?? classifyOmniMdl(id) ?? classifyOmniMdl(stem);
+  const source = { assetPath: asset.path, id };
+  if (family) source.family = family;
+  if (decl && (decl.defaults.size > 0 || decl.args.size > 0)) {
+    source.values = new Map([...decl.defaults, ...decl.args]);
+  }
+  return source;
+}
+function readOmniGlass(sv, result) {
+  result.transmission = 1;
+  result.metalness = 0;
+  result.color = svColor(sv, "glass_color") ?? [1, 1, 1];
+  result.ior = svNumber(sv, "glass_ior") ?? 1.491;
+  result.roughness = svNumber(sv, "frosting_roughness") ?? 0;
+  const depth = svNumber(sv, "depth");
+  if (svBoolean(sv, "thin_walled") !== true && depth !== void 0) result.thickness = depth;
+  const cutout = svNumber(sv, "cutout_opacity");
+  if (cutout !== void 0 && cutout < 1) result.opacity = cutout;
+}
+function readOmniClearCoat(sv, result) {
+  if (svBoolean(sv, "enable_clearcoat") === false) return;
+  result.clearcoat = 1;
+  const roughness = svNumber(sv, "clearcoat_reflection_roughness");
+  if (roughness !== void 0) result.clearcoatRoughness = roughness;
+  const normal = directTexture(sv, "clearcoat_normalmap_texture") ?? mdlValueTexture(sv, "clearcoat_normalmap_texture");
+  if (normal && svBoolean(sv, "enable_clearcoat_normalmap_texture") !== false) {
+    result.clearcoatNormalTexture = normal;
+  }
+}
+function readOmniSurface(sv, result) {
+  const color = svColor(sv, "diffuse_reflection_color");
+  if (color) result.color = color;
+  const metalness = svNumber(sv, "metalness");
+  if (metalness !== void 0) result.metalness = metalness;
+  const roughness = svNumber(sv, "specular_reflection_roughness");
+  if (roughness !== void 0) result.roughness = roughness;
+  const ior = svNumber(sv, "specular_reflection_ior");
+  if (ior !== void 0) result.ior = ior;
+  const coat = svNumber(sv, "coat_weight");
+  if (coat !== void 0 && coat > 0) {
+    result.clearcoat = coat;
+    const coatRoughness = svNumber(sv, "coat_roughness");
+    if (coatRoughness !== void 0) result.clearcoatRoughness = coatRoughness;
+  }
+  const emissionWeight = svNumber(sv, "emission_weight");
+  const emissionColor = svColor(sv, "emission_color");
+  if (emissionWeight !== void 0 && emissionWeight > 0 && emissionColor) {
+    result.emissiveColor = emissionColor;
+    result.emissiveIntensity = emissionWeight;
+  }
+  if (svBoolean(sv, "enable_opacity") === true) {
+    const opacity = svNumber(sv, "geometry_opacity");
+    if (opacity !== void 0) result.opacity = opacity;
+  }
+}
+function authored(sv, name) {
+  return sv.shader.GetAttribute(`inputs:${name}`).Get();
+}
+function asNumber2(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function asVec(v, length) {
+  if (Array.isArray(v) && v.length >= length && v.every((n) => typeof n === "number")) {
+    return v.slice(0, length);
+  }
+  return void 0;
+}
+function svNumber(sv, name) {
+  return asNumber2(authored(sv, name)) ?? asNumber2(sv.mdl?.get(name));
+}
+function svBoolean(sv, name) {
+  return asBoolean(authored(sv, name)) ?? asBoolean(sv.mdl?.get(name));
+}
+function svColor(sv, name) {
+  const v = asVec(authored(sv, name), 3) ?? asVec(sv.mdl?.get(name), 3);
+  return v ? v : void 0;
+}
+function svVec2(sv, name) {
+  const v = asVec(authored(sv, name), 2) ?? asVec(sv.mdl?.get(name), 2);
+  return v ? v : void 0;
+}
+function firstNumber(sv, names) {
+  for (const name of names) {
+    const v = asNumber2(authored(sv, name));
+    if (v !== void 0) return v;
+  }
+  for (const name of names) {
+    const v = asNumber2(sv.mdl?.get(name));
+    if (v !== void 0) return v;
+  }
+  return void 0;
+}
+function firstColor(sv, names) {
+  for (const name of names) {
+    const v = asVec(authored(sv, name), 3);
+    if (v) return v;
+  }
+  for (const name of names) {
+    const v = asVec(sv.mdl?.get(name), 3);
+    if (v) return v;
+  }
+  return void 0;
+}
+function directTexture(sv, name) {
+  const v = authored(sv, name);
+  if (v instanceof AssetPath && v.path) return withMdlTransform(sv, { path: v.path });
+  return void 0;
+}
+function mdlValueTexture(sv, name) {
+  const v = sv.mdl?.get(name);
+  if (!isMdlTexture(v)) return void 0;
+  const texture = { path: resolveMdlRelative(sv.mdlAssetPath, v.assetPath) };
+  if (v.sourceColorSpace) texture.sourceColorSpace = v.sourceColorSpace;
+  return withMdlTransform(sv, texture);
+}
+function resolveMdlRelative(modulePath, path) {
+  if (!modulePath || path.startsWith("/") || /^[a-z][a-z0-9+.-]*:/i.test(path)) return path;
+  return joinPosix(modulePath, path);
+}
+function withMdlTransform(sv, texture) {
+  const transform = mdlTextureTransform(sv);
+  return transform ? { ...texture, transform } : texture;
+}
+function findTexture(sv, lookup) {
   for (const name of lookup.direct) {
-    const v = shader.GetAttribute(name).Get();
-    if (v instanceof AssetPath && v.path) {
-      const transform = mdlTextureTransform(shader);
-      return { path: v.path, ...transform ? { transform } : {} };
-    }
+    const texture = directTexture(sv, name);
+    if (texture) return texture;
   }
   for (const name of lookup.surface) {
-    const conn = shader.GetAttribute(name).GetConnections()[0];
+    const conn = sv.shader.GetAttribute(`inputs:${name}`).GetConnections()[0];
     if (!conn) continue;
-    const texPrim = shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
+    const texPrim = sv.shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
     if (!texPrim) continue;
     const file = texPrim.GetAttribute("inputs:file").Get();
     if (file instanceof AssetPath && file.path) {
@@ -407,6 +879,10 @@ function findTexture(shader, lookup) {
       return tex;
     }
   }
+  for (const name of lookup.direct) {
+    const texture = mdlValueTexture(sv, name);
+    if (texture) return texture;
+  }
   return void 0;
 }
 function outputChannelOf(connection) {
@@ -424,14 +900,14 @@ function outputChannelOf(connection) {
       return void 0;
   }
 }
-function mdlTextureTransform(shader) {
+function mdlTextureTransform(sv) {
   const transform = {};
-  const translation = numArray(shader, "inputs:texture_translate", 2);
+  const translation = svVec2(sv, "texture_translate");
   if (translation) transform.translation = translation;
-  const scale = numArray(shader, "inputs:texture_scale", 2);
+  const scale = svVec2(sv, "texture_scale");
   if (scale) transform.scale = scale;
-  const rotation = shader.GetAttribute("inputs:texture_rotate").Get();
-  if (typeof rotation === "number") transform.rotation = rotation;
+  const rotation = svNumber(sv, "texture_rotate");
+  if (rotation !== void 0) transform.rotation = rotation;
   return Object.keys(transform).length > 0 ? transform : void 0;
 }
 var WRAP_VALUES = /* @__PURE__ */ new Set(["repeat", "clamp", "mirror", "black"]);
@@ -480,11 +956,7 @@ function readStChain(texPrim) {
   return out;
 }
 function numArray(prim, name, length) {
-  const v = prim.GetAttribute(name).Get();
-  if (Array.isArray(v) && v.length >= length && v.every((n) => typeof n === "number")) {
-    return v.slice(0, length);
-  }
-  return void 0;
+  return asVec(prim.GetAttribute(name).Get(), length);
 }
 function findBinding(prim) {
   let chosen;
@@ -513,22 +985,6 @@ function findSurfaceShader(material) {
   }
   return material.GetChildren().find((c) => c.GetTypeName() === "Shader") ?? void 0;
 }
-function firstColor(shader, names) {
-  for (const name of names) {
-    const v = shader.GetAttribute(name).Get();
-    if (Array.isArray(v) && v.length >= 3 && v.every((n) => typeof n === "number")) {
-      return [v[0], v[1], v[2]];
-    }
-  }
-  return void 0;
-}
-function firstNumber(shader, names) {
-  for (const name of names) {
-    const v = shader.GetAttribute(name).Get();
-    if (typeof v === "number") return v;
-  }
-  return void 0;
-}
 
 // src/robot/buildKinematicTree.ts
 var WORLD = "";
@@ -810,61 +1266,6 @@ function leafName(path) {
   return parts[parts.length - 1] ?? path;
 }
 
-// src/usd/AssetResolver.ts
-var DefaultAssetResolver = class {
-  resolve(assetPath, baseUrl) {
-    try {
-      return new URL(assetPath, baseUrl || void 0).href;
-    } catch {
-      return joinPosix(baseUrl, assetPath);
-    }
-  }
-  async fetchText(url) {
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
-    return res.text();
-  }
-  async fetchBytes(url) {
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
-    return new Uint8Array(await res.arrayBuffer());
-  }
-};
-function createMemoryResolver(files) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return {
-    resolve(assetPath, baseUrl) {
-      return joinPosix(baseUrl, assetPath);
-    },
-    fetchText(url) {
-      const v = files[url];
-      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
-      return Promise.resolve(typeof v === "string" ? v : decoder.decode(v));
-    },
-    fetchBytes(url) {
-      const v = files[url];
-      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
-      return Promise.resolve(typeof v === "string" ? encoder.encode(v) : v);
-    }
-  };
-}
-function joinPosix(baseUrl, rel) {
-  if (rel.startsWith("/")) return normalizePosix(rel);
-  const dir = baseUrl.slice(0, baseUrl.lastIndexOf("/") + 1);
-  return normalizePosix(dir + rel);
-}
-function normalizePosix(path) {
-  const isAbsolute = path.startsWith("/");
-  const out = [];
-  for (const part of path.split("/")) {
-    if (part === "" || part === ".") continue;
-    if (part === "..") out.pop();
-    else out.push(part);
-  }
-  return (isAbsolute ? "/" : "") + out.join("/");
-}
-
 // src/parser/reader.ts
 var ParseError = class extends Error {
   constructor(message, line, col) {
@@ -951,7 +1352,7 @@ var TokenizeError = class extends Error {
 };
 var IDENT_START = /[A-Za-z_]/;
 var IDENT_CONT = /[A-Za-z0-9_:]/;
-var NUMBER_RE = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/;
+var NUMBER_RE2 = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/;
 var INF_NAN_RE = /^[-+]?(?:inf|nan)\b/i;
 function tokenize(src) {
   const tokens = [];
@@ -1023,7 +1424,7 @@ function tokenize(src) {
       continue;
     }
     if (/[0-9]/.test(c) || (c === "-" || c === "+" || c === ".") && /[0-9.]/.test(src[i + 1] ?? "")) {
-      const m = NUMBER_RE.exec(src.slice(i));
+      const m = NUMBER_RE2.exec(src.slice(i));
       if (m) {
         const text = m[0];
         push("number", text, startCol, Number(text));
@@ -3124,7 +3525,7 @@ function crateToUsdaFile(crate) {
     if (spec.specType !== SPEC_PRIM) continue;
     const fm = fieldsOf(spec.fieldSetIndex);
     primByPath.set(path, {
-      specifier: SPECIFIERS2[asNumber2(crate, fm.get("specifier")) ?? 0] ?? "def",
+      specifier: SPECIFIERS2[asNumber3(crate, fm.get("specifier")) ?? 0] ?? "def",
       typeName: asString(crate, fm.get("typeName")) ?? "",
       name: leaf(path),
       metadata: buildPrimMetadata(crate, fm),
@@ -3178,7 +3579,7 @@ function buildAttribute(crate, name, fm) {
     name,
     typeName: isArrayType ? rawType.slice(0, -2) : rawType,
     isArray: isArrayType || (defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false),
-    variability: asNumber2(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
+    variability: asNumber3(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
     custom: customRep !== void 0 && crate.getValue(customRep) === true,
     metadata: {},
     line: 0
@@ -3250,10 +3651,10 @@ function buildLayerMetadata(crate, fm) {
   if (upAxis !== void 0) meta.upAxis = upAxis;
   const defaultPrim2 = asString(crate, fm.get("defaultPrim"));
   if (defaultPrim2 !== void 0) meta.defaultPrim = defaultPrim2;
-  const metersPerUnit = asNumber2(crate, fm.get("metersPerUnit"));
+  const metersPerUnit = asNumber3(crate, fm.get("metersPerUnit"));
   if (metersPerUnit !== void 0) meta.metersPerUnit = metersPerUnit;
   for (const key of ["startTimeCode", "endTimeCode", "timeCodesPerSecond", "framesPerSecond"]) {
-    const value = asNumber2(crate, fm.get(key));
+    const value = asNumber3(crate, fm.get(key));
     if (value !== void 0) meta[key] = value;
   }
   const customLayerData = fm.has("customLayerData") ? crate.getValue(fm.get("customLayerData")) : void 0;
@@ -3267,7 +3668,7 @@ function asString(crate, rep) {
   const v = crate.getValue(rep);
   return typeof v === "string" ? v : void 0;
 }
-function asNumber2(crate, rep) {
+function asNumber3(crate, rep) {
   if (rep === void 0) return void 0;
   const v = crate.getValue(rep);
   return typeof v === "number" ? v : void 0;
@@ -3584,6 +3985,33 @@ function stripKeys(meta, keys) {
   }
   return out;
 }
+
+// src/usd/mdl/loadMdlModules.ts
+function collectMdlAssetPaths(stage) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const prim of stage.Traverse()) {
+    if (prim.GetTypeName() !== "Shader") continue;
+    const asset = prim.GetAttribute("info:mdl:sourceAsset").Get();
+    if (asset instanceof AssetPath && asset.path) paths.add(asset.path);
+  }
+  return [...paths];
+}
+async function loadMdlModules(stage, resolver, baseUrl) {
+  const paths = collectMdlAssetPaths(stage);
+  if (paths.length === 0) return void 0;
+  const modules = /* @__PURE__ */ new Map();
+  await Promise.all(
+    paths.map(async (path) => {
+      try {
+        const module = parseMdl(await resolver.fetchText(resolver.resolve(path, baseUrl)));
+        if (module.materials.size > 0) modules.set(path, module);
+      } catch {
+      }
+    })
+  );
+  if (modules.size === 0) return void 0;
+  return (assetPath) => modules.get(assetPath);
+}
 var USD_ENTRY = /\.(usda|usdc|usd)$/i;
 function isZip(bytes) {
   if (bytes.length < 4 || bytes[0] !== 80 || bytes[1] !== 75) return false;
@@ -3620,6 +4048,6 @@ function openUsdz(bytes) {
   return { rootEntry, resolver };
 }
 
-export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
-//# sourceMappingURL=chunk-NFKK5LJK.js.map
-//# sourceMappingURL=chunk-NFKK5LJK.js.map
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, collectMdlAssetPaths, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMdlTexture, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, loadMdlModules, normalizeJointLimits, openUsdz, parseMdl, parseMdlLiteral, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
+//# sourceMappingURL=chunk-AXPMXEQC.js.map
+//# sourceMappingURL=chunk-AXPMXEQC.js.map