three-usd-robot 0.11.0 → 0.13.0

package/dist/chunk-PPPRB6KE.js

@@ -0,0 +1,963 @@
+import { AssetPath } from './chunk-JGIVJXBU.js';
+
+// 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/MaterialXBinding.ts
+var MTLX_STANDARD_SURFACE = "ND_standard_surface_surfaceshader";
+var MTLX_USD_PREVIEW_SURFACE = "ND_UsdPreviewSurface_surfaceshader";
+var DEFAULT_BASE_COLOR = [0.8, 0.8, 0.8];
+function readStandardSurface(shader, result, onWarn) {
+  const input = (name) => resolveMtlxInput(shader, name, onWarn);
+  const base = numberOf(input("base"));
+  const baseColor = input("base_color");
+  if (baseColor?.kind === "texture") {
+    result.colorTexture = baseColor.texture;
+    if (base !== void 0) result.color = [base, base, base];
+  } else {
+    const color = colorOf(baseColor) ?? (base !== void 0 ? DEFAULT_BASE_COLOR : void 0);
+    if (color) {
+      const weight = base ?? 1;
+      result.color = [color[0] * weight, color[1] * weight, color[2] * weight];
+    }
+  }
+  const metalness = input("metalness");
+  if (metalness?.kind === "texture") result.metalnessTexture = metalness.texture;
+  const metalnessValue = numberOf(metalness);
+  if (metalnessValue !== void 0) result.metalness = metalnessValue;
+  const roughness = input("specular_roughness");
+  if (roughness?.kind === "texture") result.roughnessTexture = roughness.texture;
+  const roughnessValue = numberOf(roughness);
+  if (roughnessValue !== void 0) result.roughness = roughnessValue;
+  const ior = numberOf(input("specular_IOR"));
+  if (ior !== void 0) result.ior = ior;
+  const transmission = numberOf(input("transmission"));
+  if (transmission !== void 0) result.transmission = transmission;
+  const coat = numberOf(input("coat"));
+  if (coat !== void 0) {
+    result.clearcoat = coat;
+    const coatRoughness = numberOf(input("coat_roughness"));
+    if (coatRoughness !== void 0) result.clearcoatRoughness = coatRoughness;
+  }
+  const emission = numberOf(input("emission"));
+  if (emission !== void 0 && emission > 0) {
+    const emissionColor = input("emission_color");
+    if (emissionColor?.kind === "texture") result.emissiveTexture = emissionColor.texture;
+    result.emissiveColor = colorOf(emissionColor) ?? [1, 1, 1];
+    result.emissiveIntensity = emission;
+  }
+  const opacity = input("opacity");
+  if (opacity?.kind === "texture") result.opacityTexture = opacity.texture;
+  const opacityValue = numberOf(opacity) ?? mean3(colorOf(opacity));
+  if (opacityValue !== void 0) result.opacity = opacityValue;
+  const normal = input("normal");
+  if (normal?.kind === "texture") result.normalTexture = normal.texture;
+}
+function resolveMtlxInput(shader, name, onWarn) {
+  return followMtlxInput(shader, name, name, onWarn, 0);
+}
+function followMtlxInput(prim, name, channel, onWarn, depth) {
+  const attr = prim.GetAttribute(`inputs:${name}`);
+  const connection = attr.GetConnections()[0];
+  if (connection) {
+    const source = prim.GetStage().GetPrimAtPath(connection.split(".")[0]);
+    return source ? resolveMtlxNode(source, channel, onWarn, depth + 1) : void 0;
+  }
+  const value = attr.Get();
+  return value === void 0 ? void 0 : { kind: "value", value };
+}
+var MAX_NODE_DEPTH = 8;
+function resolveMtlxNode(node, channel, onWarn, depth) {
+  const id = node.GetAttribute("info:id").Get();
+  if (typeof id !== "string" || depth > MAX_NODE_DEPTH) {
+    onWarn?.(`${node.GetPath()}: unresolvable MaterialX node; skipping the "${channel}" channel`);
+    return void 0;
+  }
+  if (id.startsWith("ND_image_") || id.startsWith("ND_tiledimage_")) {
+    const texture = readMtlxImage(node, id.startsWith("ND_tiledimage_"));
+    return texture ? { kind: "texture", texture } : void 0;
+  }
+  if (id.startsWith("ND_normalmap")) {
+    const resolved = followMtlxInput(node, "in", channel, onWarn, depth);
+    if (resolved?.kind !== "texture") return resolved;
+    const scale = node.GetAttribute("inputs:scale").Get();
+    if (typeof scale === "number") {
+      resolved.texture.scale = [2 * scale, 2 * scale, 2 * scale, 1];
+    }
+    return resolved;
+  }
+  if (id.startsWith("ND_constant_")) {
+    const value = node.GetAttribute("inputs:value").Get();
+    return value === void 0 ? void 0 : { kind: "value", value };
+  }
+  if (id.startsWith("ND_dot_")) {
+    return followMtlxInput(node, "in", channel, onWarn, depth);
+  }
+  if (id.startsWith("ND_convert_")) {
+    const resolved = followMtlxInput(node, "in", channel, onWarn, depth);
+    if (resolved?.kind !== "value") return resolved;
+    return { kind: "value", value: convertMtlxValue(resolved.value, id) };
+  }
+  if (id.startsWith("ND_multiply_")) {
+    const in1 = operand(node, "in1", void 0, channel, onWarn, depth);
+    const in2 = operand(node, "in2", [1], channel, onWarn, depth);
+    const value = in1 && in2 ? broadcast([in1, in2], ([a, b]) => a * b) : void 0;
+    return value ? { kind: "value", value: scalarize(value) } : void 0;
+  }
+  if (id.startsWith("ND_mix_")) {
+    const bg = operand(node, "bg", [0], channel, onWarn, depth);
+    const fg = operand(node, "fg", [0], channel, onWarn, depth);
+    const mix = operand(node, "mix", [0], channel, onWarn, depth);
+    const value = bg && fg && mix ? broadcast([fg, bg, mix], ([f, b, m]) => f * m + b * (1 - m)) : void 0;
+    return value ? { kind: "value", value: scalarize(value) } : void 0;
+  }
+  onWarn?.(
+    `${node.GetPath()}: MaterialX node "${id}" needs graph execution; skipping the "${channel}" channel`
+  );
+  return void 0;
+}
+var MTLX_WRAP = {
+  periodic: "repeat",
+  clamp: "clamp",
+  mirror: "mirror",
+  constant: "black"
+  // no border-color sampling in three — clamp-to-black is closest
+};
+function readMtlxImage(node, tiled) {
+  const file = node.GetAttribute("inputs:file").Get();
+  if (!(file instanceof AssetPath) || !file.path) return void 0;
+  const texture = { path: file.path };
+  if (tiled) {
+    texture.wrapS = "repeat";
+    texture.wrapT = "repeat";
+    const transform = {};
+    const tiling = vec2Of(node.GetAttribute("inputs:uvtiling").Get());
+    if (tiling) transform.scale = tiling;
+    const offset = vec2Of(node.GetAttribute("inputs:uvoffset").Get());
+    if (offset) transform.translation = offset;
+    if (transform.scale || transform.translation) texture.transform = transform;
+  } else {
+    const uaddress = node.GetAttribute("inputs:uaddressmode").Get();
+    const wrapS = typeof uaddress === "string" ? MTLX_WRAP[uaddress] : void 0;
+    if (wrapS) texture.wrapS = wrapS;
+    const vaddress = node.GetAttribute("inputs:vaddressmode").Get();
+    const wrapT = typeof vaddress === "string" ? MTLX_WRAP[vaddress] : void 0;
+    if (wrapT) texture.wrapT = wrapT;
+  }
+  readMtlxTexcoord(node, texture);
+  return texture;
+}
+function readMtlxTexcoord(node, texture) {
+  const connection = node.GetAttribute("inputs:texcoord").GetConnections()[0];
+  if (!connection) return;
+  const source = node.GetStage().GetPrimAtPath(connection.split(".")[0]);
+  const id = source?.GetAttribute("info:id").Get();
+  if (!source || typeof id !== "string") return;
+  if (id.startsWith("ND_texcoord_")) {
+    const index = source.GetAttribute("inputs:index").Get();
+    if (typeof index === "number" && index > 0) texture.uvChannel = index;
+  } else if (id.startsWith("ND_geompropvalue_")) {
+    const geomprop = source.GetAttribute("inputs:geomprop").Get();
+    if (typeof geomprop === "string" && geomprop.length > 0) texture.uvSet = geomprop;
+  }
+}
+function operand(node, name, fallback, channel, onWarn, depth) {
+  const attr = node.GetAttribute(`inputs:${name}`);
+  if (!attr.GetConnections()[0]) {
+    const value = attr.Get();
+    return value === void 0 ? fallback : numsOf(value);
+  }
+  const resolved = followMtlxInput(node, name, channel, onWarn, depth);
+  if (resolved?.kind === "value") return numsOf(resolved.value);
+  if (resolved?.kind === "texture") {
+    onWarn?.(
+      `${node.GetPath()}: constant folding cannot take a textured "${name}"; skipping the "${channel}" channel`
+    );
+  }
+  return void 0;
+}
+var MTLX_TYPE_SIZE = {
+  float: 1,
+  integer: 1,
+  boolean: 1,
+  vector2: 2,
+  color3: 3,
+  vector3: 3,
+  color4: 4,
+  vector4: 4
+};
+function convertMtlxValue(value, id) {
+  const target = id.split("_").pop() ?? "";
+  const size = MTLX_TYPE_SIZE[target];
+  const nums = numsOf(value);
+  if (!size || !nums) return value;
+  if (size === 1) return nums[0];
+  return Array.from(
+    { length: size },
+    (_, i) => i < nums.length ? nums[i] : nums.length === 1 ? nums[0] : target === "color4" && i === 3 ? 1 : 0
+  );
+}
+function broadcast(operands, op) {
+  const length = Math.max(...operands.map((o) => o.length));
+  if (operands.some((o) => o.length !== 1 && o.length !== length)) return void 0;
+  return Array.from({ length }, (_, i) => op(operands.map((o) => o.length === 1 ? o[0] : o[i])));
+}
+function scalarize(value) {
+  return value.length === 1 ? value[0] : value;
+}
+function numsOf(value) {
+  if (typeof value === "number") return [value];
+  if (Array.isArray(value) && value.length > 0 && value.every((n) => typeof n === "number")) {
+    return value;
+  }
+  return void 0;
+}
+function numberOf(resolved) {
+  if (resolved?.kind !== "value") return void 0;
+  const v = resolved.value;
+  if (typeof v === "number") return v;
+  if (Array.isArray(v) && v.length === 1 && typeof v[0] === "number") return v[0];
+  return void 0;
+}
+function colorOf(resolved) {
+  if (resolved?.kind !== "value") return void 0;
+  const v = resolved.value;
+  if (typeof v === "number") return [v, v, v];
+  if (Array.isArray(v) && v.length >= 3 && v.every((n) => typeof n === "number")) {
+    return [v[0], v[1], v[2]];
+  }
+  return void 0;
+}
+function mean3(v) {
+  return v ? (v[0] + v[1] + v[2]) / 3 : void 0;
+}
+function vec2Of(value) {
+  return Array.isArray(value) && value.length >= 2 && typeof value[0] === "number" && typeof value[1] === "number" ? [value[0], value[1]] : void 0;
+}
+
+// src/three/MaterialBinding.ts
+var DIFFUSE_INPUTS = [
+  "diffuseColor",
+  // UsdPreviewSurface
+  "diffuse_color_constant",
+  // OmniPBR
+  "diffuse_tint",
+  "base_color",
+  "baseColor"
+];
+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", "outputs:mtlx:surface"];
+var TEXTURE_LOOKUPS = {
+  color: {
+    surface: ["diffuseColor"],
+    direct: ["diffuse_texture", "diffuse_color_texture", "glass_color_texture"]
+  },
+  opacity: {
+    surface: ["opacity"],
+    direct: ["opacity_texture", "opacity_color_texture"]
+  },
+  normal: {
+    surface: ["normal"],
+    direct: ["normalmap_texture", "normal_texture", "normal_map_texture"]
+  },
+  roughness: {
+    surface: ["roughness"],
+    direct: ["reflectionroughness_texture", "roughness_texture"]
+  },
+  metalness: {
+    surface: ["metallic"],
+    direct: ["metallic_texture"]
+  },
+  occlusion: {
+    surface: ["occlusion"],
+    direct: ["ao_texture", "occlusion_texture"]
+  },
+  emissive: {
+    surface: ["emissiveColor"],
+    direct: ["emissive_color_texture", "emissive_mask_texture"]
+  }
+};
+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 infoId = shader.GetAttribute("info:id").Get();
+  if (typeof infoId === "string" && infoId.startsWith("ND_")) {
+    if (infoId === MTLX_STANDARD_SURFACE) {
+      const result2 = { name: material.GetName() };
+      readStandardSurface(shader, result2, options.onWarn);
+      return result2;
+    }
+    if (infoId !== MTLX_USD_PREVIEW_SURFACE) {
+      options.onWarn?.(
+        `${material.GetPath()}: unknown MaterialX surface shader "${infoId}"; applying the best-effort UsdPreviewSurface mapping`
+      );
+    }
+  }
+  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(sv, DIFFUSE_INPUTS);
+  if (color) result.color = color;
+  const opacity = firstNumber(sv, OPACITY_INPUTS);
+  if (opacity !== void 0) result.opacity = opacity;
+  const opacityThreshold = firstNumber(sv, OPACITY_THRESHOLD_INPUTS);
+  if (opacityThreshold !== void 0) result.opacityThreshold = opacityThreshold;
+  const metalness = firstNumber(sv, METALLIC_INPUTS);
+  if (metalness !== void 0) result.metalness = metalness;
+  const roughness = firstNumber(sv, ROUGHNESS_INPUTS);
+  if (roughness !== void 0) result.roughness = roughness;
+  const emissive = firstColor(sv, EMISSIVE_INPUTS);
+  if (emissive && svBoolean(sv, "enable_emission") !== false) {
+    result.emissiveColor = emissive;
+    const intensity = svNumber(sv, "emissive_intensity");
+    if (intensity !== void 0) result.emissiveIntensity = intensity;
+  }
+  const ior = svNumber(sv, "ior");
+  if (ior !== void 0) result.ior = ior;
+  const clearcoat = svNumber(sv, "clearcoat");
+  if (clearcoat !== void 0) result.clearcoat = clearcoat;
+  const clearcoatRoughness = svNumber(sv, "clearcoatRoughness");
+  if (clearcoatRoughness !== void 0) result.clearcoatRoughness = clearcoatRoughness;
+  if (svNumber(sv, "useSpecularWorkflow") === 1) {
+    const specular = svColor(sv, "specularColor");
+    if (specular) result.specularColor = specular;
+  }
+  const colorTex = findTexture(sv, TEXTURE_LOOKUPS.color);
+  if (colorTex !== void 0) result.colorTexture = colorTex;
+  const opacityTex = findTexture(sv, TEXTURE_LOOKUPS.opacity);
+  if (opacityTex !== void 0) result.opacityTexture = opacityTex;
+  const normal = findTexture(sv, TEXTURE_LOOKUPS.normal);
+  if (normal !== void 0) result.normalTexture = normal;
+  const roughTex = findTexture(sv, TEXTURE_LOOKUPS.roughness);
+  if (roughTex !== void 0) result.roughnessTexture = roughTex;
+  const metalTex = findTexture(sv, TEXTURE_LOOKUPS.metalness);
+  if (metalTex !== void 0) result.metalnessTexture = metalTex;
+  const aoTex = findTexture(sv, TEXTURE_LOOKUPS.occlusion);
+  if (aoTex !== void 0) result.occlusionTexture = aoTex;
+  const emissiveTex = findTexture(sv, TEXTURE_LOOKUPS.emissive);
+  if (emissiveTex !== void 0) result.emissiveTexture = emissiveTex;
+  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 findBoundSurfaceShader(stage, prim) {
+  const materialPath = findBinding(prim);
+  if (!materialPath) return void 0;
+  const material = stage.GetPrimAtPath(materialPath);
+  if (!material) return void 0;
+  return findSurfaceShader(material);
+}
+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 asNumber(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 asNumber(authored(sv, name)) ?? asNumber(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 = asNumber(authored(sv, name));
+    if (v !== void 0) return v;
+  }
+  for (const name of names) {
+    const v = asNumber(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 texture = directTexture(sv, name);
+    if (texture) return texture;
+  }
+  for (const name of lookup.surface) {
+    const conn = sv.shader.GetAttribute(`inputs:${name}`).GetConnections()[0];
+    if (!conn) continue;
+    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) {
+      const tex = readUvTexture(texPrim, file.path);
+      const channel = outputChannelOf(conn);
+      if (channel) tex.outputChannel = channel;
+      return tex;
+    }
+  }
+  for (const name of lookup.direct) {
+    const texture = mdlValueTexture(sv, name);
+    if (texture) return texture;
+  }
+  return void 0;
+}
+function outputChannelOf(connection) {
+  const m = /\.outputs:(\w+)$/.exec(connection);
+  switch (m?.[1]) {
+    case "r":
+    case "g":
+    case "b":
+    case "a":
+      return m[1];
+    case "rgb":
+    case "rgba":
+      return "rgb";
+    default:
+      return void 0;
+  }
+}
+function mdlTextureTransform(sv) {
+  const transform = {};
+  const translation = svVec2(sv, "texture_translate");
+  if (translation) transform.translation = translation;
+  const scale = svVec2(sv, "texture_scale");
+  if (scale) transform.scale = scale;
+  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"]);
+function readUvTexture(texPrim, path) {
+  const tex = { path };
+  const wrapS = texPrim.GetAttribute("inputs:wrapS").Get();
+  if (typeof wrapS === "string" && WRAP_VALUES.has(wrapS)) tex.wrapS = wrapS;
+  const wrapT = texPrim.GetAttribute("inputs:wrapT").Get();
+  if (typeof wrapT === "string" && WRAP_VALUES.has(wrapT)) tex.wrapT = wrapT;
+  const scale = numArray(texPrim, "inputs:scale", 4);
+  if (scale) tex.scale = scale;
+  const bias = numArray(texPrim, "inputs:bias", 4);
+  if (bias) tex.bias = bias;
+  const sourceColorSpace = texPrim.GetAttribute("inputs:sourceColorSpace").Get();
+  if (sourceColorSpace === "raw" || sourceColorSpace === "sRGB" || sourceColorSpace === "auto") {
+    tex.sourceColorSpace = sourceColorSpace;
+  }
+  const st = readStChain(texPrim);
+  if (st.transform) tex.transform = st.transform;
+  if (st.uvSet) tex.uvSet = st.uvSet;
+  return tex;
+}
+function connectedPrim(prim, input) {
+  const conn = prim.GetAttribute(input).GetConnections()[0];
+  if (!conn) return null;
+  return prim.GetStage().GetPrimAtPath(conn.split(".")[0]);
+}
+var TRANSFORM2D_IDS = /* @__PURE__ */ new Set(["UsdTransform2d", "ND_UsdTransform2d"]);
+var PRIMVAR_READER_IDS = /* @__PURE__ */ new Set(["UsdPrimvarReader_float2", "ND_UsdPrimvarReader_vector2"]);
+function readStChain(texPrim) {
+  const out = {};
+  let node = connectedPrim(texPrim, "inputs:st");
+  if (node && TRANSFORM2D_IDS.has(node.GetAttribute("info:id").Get())) {
+    const transform = {};
+    const translation = numArray(node, "inputs:translation", 2);
+    if (translation) transform.translation = translation;
+    const scale = numArray(node, "inputs:scale", 2);
+    if (scale) transform.scale = scale;
+    const rotation = node.GetAttribute("inputs:rotation").Get();
+    if (typeof rotation === "number") transform.rotation = rotation;
+    if (Object.keys(transform).length > 0) out.transform = transform;
+    node = connectedPrim(node, "inputs:in");
+  }
+  if (node && PRIMVAR_READER_IDS.has(node.GetAttribute("info:id").Get())) {
+    const varname = node.GetAttribute("inputs:varname").Get();
+    if (typeof varname === "string" && varname.length > 0) out.uvSet = varname;
+  }
+  return out;
+}
+function numArray(prim, name, length) {
+  return asVec(prim.GetAttribute(name).Get(), length);
+}
+function findBinding(prim) {
+  let chosen;
+  let p = prim;
+  while (p) {
+    for (const name of ["material:binding:preview", "material:binding"]) {
+      const rel = p.GetRelationship(name);
+      const target = rel.GetTargets()[0];
+      if (!target) continue;
+      const stronger = rel.GetMetadata("bindMaterialAs") === "strongerThanDescendants";
+      if (chosen === void 0 || stronger) chosen = target;
+      break;
+    }
+    p = p.GetParent();
+  }
+  return chosen;
+}
+function findSurfaceShader(material) {
+  for (const out of SURFACE_OUTPUTS) {
+    const conn = material.GetAttribute(out).GetConnections()[0];
+    if (conn) {
+      const shaderPath = conn.split(".")[0];
+      const shader = material.GetStage().GetPrimAtPath(shaderPath);
+      if (shader) return shader;
+    }
+  }
+  return material.GetChildren().find((c) => c.GetTypeName() === "Shader") ?? void 0;
+}
+
+export { DefaultAssetResolver, MTLX_STANDARD_SURFACE, createMemoryResolver, findBoundSurfaceShader, isMdlTexture, joinPosix, parseMdl, parseMdlLiteral, readMtlxImage, resolveBoundMaterial };
+//# sourceMappingURL=chunk-PPPRB6KE.js.map
+//# sourceMappingURL=chunk-PPPRB6KE.js.map