three-usd-robot 0.9.0 → 0.11.0

package/dist/chunk-5SVRTKS4.js

@@ -0,0 +1,966 @@
+import { getMaterialSubsets, resolveBoundMaterial, isRenderableGprim, COLLISION_API, isNonVisualPurpose, computeLocalTransform, DefaultAssetResolver, toBytes, extractRobotDescription, isZip, CrateReader, openUsdz, buildKinematicTree, loadMdlModules, isUnsupportedGprim, Stage, composeLayer, composeFile, crateToUsdaFile } from './chunk-AXPMXEQC.js';
+import { ThreeUsdRobot } from './chunk-ENWFOYHU.js';
+import { identity4, multiply } from './chunk-LDO5FKQS.js';
+import * as THREE from 'three';
+
+var DEFAULT_COLOR = 10132122;
+function readPrimvar(meshPrim, attrName, isTuple, lens) {
+  const attr = meshPrim.GetAttribute(attrName);
+  const raw = attr.Get();
+  if (!isTuple(raw) || raw.length === 0) return null;
+  const base = raw;
+  let values = base;
+  const idx = meshPrim.GetAttribute(`${attrName}:indices`).Get();
+  if (isNumberArray(idx)) values = idx.map((i) => base[i] ?? base[0]);
+  const authored = attr.GetMetadata("interpolation");
+  let interpolation;
+  if (authored === "varying")
+    interpolation = "vertex";
+  else if (authored === "constant" || authored === "uniform" || authored === "vertex" || authored === "faceVarying") {
+    interpolation = authored;
+  } else if (values.length === lens.points && lens.points > 0) interpolation = "vertex";
+  else if (values.length === lens.faceVertices && lens.faceVertices > 0)
+    interpolation = "faceVarying";
+  else if (values.length === lens.faces && lens.faces > 0) interpolation = "uniform";
+  else interpolation = "constant";
+  const needed = interpolation === "vertex" ? lens.points : interpolation === "faceVarying" ? lens.faceVertices : interpolation === "uniform" ? lens.faces : 1;
+  if (values.length < needed) interpolation = "constant";
+  return { values, interpolation };
+}
+var UV_TYPE_NAMES = /* @__PURE__ */ new Set(["texcoord2f", "float2"]);
+function meshUvSetNames(meshPrim) {
+  const sets = [];
+  for (const attr of meshPrim.GetAttributes()) {
+    const name = attr.GetName();
+    if (!name.startsWith("primvars:") || name.endsWith(":indices")) continue;
+    if (!attr.IsArray()) continue;
+    if (!UV_TYPE_NAMES.has(attr.GetTypeName().toLowerCase())) continue;
+    sets.push(name.slice("primvars:".length));
+  }
+  sets.sort((a, b) => a === "st" ? -1 : b === "st" ? 1 : a < b ? -1 : 1);
+  return sets;
+}
+function uvAttrName(index) {
+  return index === 0 ? "uv" : `uv${index}`;
+}
+function meshLens(meshPrim) {
+  const points = meshPrim.GetAttribute("points").Get();
+  const counts = meshPrim.GetAttribute("faceVertexCounts").Get();
+  const indices = meshPrim.GetAttribute("faceVertexIndices").Get();
+  const hasTopology = isNumberArray(counts) && isNumberArray(indices);
+  return {
+    points: isVec3Array(points) ? points.length : 0,
+    faceVertices: hasTopology ? indices.length : 0,
+    faces: hasTopology ? counts.length : 0
+  };
+}
+function displayColorPrimvar(meshPrim) {
+  return readPrimvar(meshPrim, "primvars:displayColor", isVec3Array, meshLens(meshPrim));
+}
+function buildMeshGeometry(meshPrim) {
+  const points = meshPrim.GetAttribute("points").Get();
+  if (!isVec3Array(points) || points.length === 0) return null;
+  const countsRaw = meshPrim.GetAttribute("faceVertexCounts").Get();
+  const indicesRaw = meshPrim.GetAttribute("faceVertexIndices").Get();
+  const counts = isNumberArray(countsRaw) ? countsRaw : null;
+  const indices = isNumberArray(indicesRaw) ? indicesRaw : null;
+  const lens = {
+    points: points.length,
+    faceVertices: counts && indices ? indices.length : 0,
+    faces: counts && indices ? counts.length : 0
+  };
+  const uvSets = meshUvSetNames(meshPrim).map(
+    (set) => readPrimvar(meshPrim, `primvars:${set}`, isVec2Array, lens)
+  );
+  const normals = readPrimvar(meshPrim, "primvars:normals", isVec3Array, lens) ?? readPrimvar(meshPrim, "normals", isVec3Array, lens);
+  const color = displayColorPrimvar(meshPrim);
+  const expand = counts !== null && indices !== null && ([...uvSets, normals].some((p) => p?.interpolation === "faceVarying") || color?.interpolation === "faceVarying" || color?.interpolation === "uniform");
+  return expand ? buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normals, color) : buildIndexedGeometry(meshPrim, points, counts, indices, uvSets, normals, color);
+}
+function buildIndexedGeometry(meshPrim, points, counts, indices, uvSets, normals, color) {
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(flat3(points), 3));
+  if (counts && indices) {
+    const subsets = getMaterialSubsets(meshPrim);
+    if (subsets.length > 0) {
+      geometry.setIndex(triangulateBySubset(geometry, counts, indices, subsets));
+    } else {
+      geometry.setIndex(triangulate(counts, indices));
+    }
+  } else if (indices) {
+    geometry.setIndex(indices.slice());
+  }
+  if (normals?.interpolation === "vertex") {
+    geometry.setAttribute(
+      "normal",
+      new THREE.Float32BufferAttribute(flat3(normals.values.slice(0, points.length)), 3)
+    );
+  } else {
+    geometry.computeVertexNormals();
+  }
+  for (const [i, uv] of uvSets.entries()) {
+    if (uv?.interpolation !== "vertex") continue;
+    geometry.setAttribute(
+      uvAttrName(i),
+      new THREE.Float32BufferAttribute(flat2(uv.values.slice(0, points.length)), 2)
+    );
+  }
+  if (color?.interpolation === "vertex") {
+    geometry.setAttribute(
+      "color",
+      new THREE.Float32BufferAttribute(flat3(color.values.slice(0, points.length)), 3)
+    );
+  }
+  return geometry;
+}
+function buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normals, color) {
+  const { slots, faces, groups } = triangulateToSlots(counts, getMaterialSubsets(meshPrim));
+  const sample = (p, corner) => {
+    switch (p.interpolation) {
+      case "faceVarying":
+        return p.values[slots[corner]] ?? p.values[0];
+      case "vertex":
+        return p.values[indices[slots[corner]]] ?? p.values[0];
+      case "uniform":
+        return p.values[faces[corner]] ?? p.values[0];
+      default:
+        return p.values[0];
+    }
+  };
+  const geometry = new THREE.BufferGeometry();
+  const position = new Array(slots.length * 3);
+  for (let c = 0; c < slots.length; c++) {
+    const v = points[indices[slots[c]]] ?? [0, 0, 0];
+    position[c * 3] = v[0];
+    position[c * 3 + 1] = v[1];
+    position[c * 3 + 2] = v[2];
+  }
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+  for (const [i, uv] of uvSets.entries()) {
+    if (!uv || uv.interpolation === "constant") continue;
+    const out = new Array(slots.length * 2);
+    for (let c = 0; c < slots.length; c++) {
+      const t = sample(uv, c);
+      out[c * 2] = t[0] ?? 0;
+      out[c * 2 + 1] = t[1] ?? 0;
+    }
+    geometry.setAttribute(uvAttrName(i), new THREE.Float32BufferAttribute(out, 2));
+  }
+  const emitVec3 = (p, name) => {
+    const out = new Array(slots.length * 3);
+    for (let c = 0; c < slots.length; c++) {
+      const t = sample(p, c);
+      out[c * 3] = t[0] ?? 0;
+      out[c * 3 + 1] = t[1] ?? 0;
+      out[c * 3 + 2] = t[2] ?? 0;
+    }
+    geometry.setAttribute(name, new THREE.Float32BufferAttribute(out, 3));
+  };
+  if (normals && normals.interpolation !== "constant") emitVec3(normals, "normal");
+  else geometry.computeVertexNormals();
+  if (color && color.interpolation !== "constant") emitVec3(color, "color");
+  for (const g of groups) geometry.addGroup(g.start, g.count, g.materialIndex);
+  return geometry;
+}
+function triangulateToSlots(faceVertexCounts, subsets) {
+  const faceStart = [];
+  let offset = 0;
+  for (const count of faceVertexCounts) {
+    faceStart.push(offset);
+    offset += count;
+  }
+  const slots = [];
+  const faces = [];
+  const emit = (face) => {
+    const start = faceStart[face];
+    const count = faceVertexCounts[face];
+    for (let k = 2; k < count; k++) {
+      slots.push(start, start + k - 1, start + k);
+      faces.push(face, face, face);
+    }
+  };
+  const groups = [];
+  if (subsets.length === 0) {
+    for (let face = 0; face < faceVertexCounts.length; face++) emit(face);
+    return { slots, faces, groups };
+  }
+  const claimed = new Uint8Array(faceVertexCounts.length);
+  for (const [index, subset] of subsets.entries()) {
+    const begin2 = slots.length;
+    for (const face of subset.faces) {
+      if (face < 0 || face >= faceVertexCounts.length || claimed[face]) continue;
+      claimed[face] = 1;
+      emit(face);
+    }
+    if (slots.length > begin2) {
+      groups.push({ start: begin2, count: slots.length - begin2, materialIndex: index });
+    }
+  }
+  const begin = slots.length;
+  for (let face = 0; face < faceVertexCounts.length; face++) {
+    if (!claimed[face]) emit(face);
+  }
+  if (slots.length > begin) {
+    groups.push({ start: begin, count: slots.length - begin, materialIndex: subsets.length });
+  }
+  return { slots, faces, groups };
+}
+function buildGprimGeometry(prim) {
+  switch (prim.GetTypeName()) {
+    case "Mesh":
+      return buildMeshGeometry(prim);
+    case "Cube": {
+      const size = getNumber(prim, "size") ?? 2;
+      return new THREE.BoxGeometry(size, size, size);
+    }
+    case "Sphere":
+      return new THREE.SphereGeometry(getNumber(prim, "radius") ?? 1, 32, 16);
+    case "Cylinder": {
+      const radius = getNumber(prim, "radius") ?? 1;
+      const height = getNumber(prim, "height") ?? 2;
+      return orientSpine(new THREE.CylinderGeometry(radius, radius, height, 32), prim);
+    }
+    case "Capsule": {
+      const radius = getNumber(prim, "radius") ?? 0.5;
+      const height = getNumber(prim, "height") ?? 1;
+      return orientSpine(new THREE.CapsuleGeometry(radius, height, 8, 32), prim);
+    }
+    case "Cone": {
+      const radius = getNumber(prim, "radius") ?? 1;
+      const height = getNumber(prim, "height") ?? 2;
+      return orientSpine(new THREE.ConeGeometry(radius, height, 32), prim);
+    }
+    default:
+      return null;
+  }
+}
+function buildGprimObject(prim, stage, options = {}) {
+  switch (prim.GetTypeName()) {
+    case "Points":
+      return buildPointsObject(prim, stage, options.mdl);
+    case "BasisCurves":
+      return buildBasisCurvesObject(prim, stage, options.curveTubes ?? false, options.mdl);
+    default: {
+      const geometry = buildGprimGeometry(prim);
+      if (!geometry) return null;
+      return new THREE.Mesh(
+        geometry,
+        buildMeshMaterials(prim, stage, options.textureProvider, options.onWarn, options.mdl)
+      );
+    }
+  }
+}
+function resolveFlatColor(prim, stage, mdl) {
+  const color = new THREE.Color(DEFAULT_COLOR);
+  const bound = stage ? resolveBoundMaterial(stage, prim, mdl ? { mdl } : {}) : void 0;
+  if (bound?.color) {
+    color.setRGB(bound.color[0], bound.color[1], bound.color[2]);
+  } else {
+    const displayColor = prim.GetAttribute("primvars:displayColor").Get();
+    if (isVec3Array(displayColor) && displayColor[0]) {
+      color.setRGB(displayColor[0][0], displayColor[0][1], displayColor[0][2]);
+    }
+  }
+  const result = {
+    color,
+    opacity: bound?.opacity ?? 1
+  };
+  if (bound?.name) result.name = bound.name;
+  return result;
+}
+function meanWidth(prim) {
+  const widths = prim.GetAttribute("widths").Get();
+  if (!isNumberArray(widths) || widths.length === 0) return void 0;
+  return widths.reduce((a, b) => a + b, 0) / widths.length;
+}
+function buildPointsObject(prim, stage, mdl) {
+  const points = prim.GetAttribute("points").Get();
+  if (!isVec3Array(points) || points.length === 0) return null;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(flat3(points), 3));
+  const flat = resolveFlatColor(prim, stage, mdl);
+  const material = new THREE.PointsMaterial({ color: flat.color });
+  if (flat.opacity < 1) {
+    material.transparent = true;
+    material.opacity = flat.opacity;
+  }
+  if (flat.name) material.name = flat.name;
+  const displayColor = prim.GetAttribute("primvars:displayColor").Get();
+  if (isVec3Array(displayColor) && displayColor.length === points.length && points.length > 1) {
+    geometry.setAttribute("color", new THREE.Float32BufferAttribute(flat3(displayColor), 3));
+    material.vertexColors = true;
+    material.color.set(16777215);
+  }
+  const width = meanWidth(prim);
+  if (width !== void 0 && width > 0) {
+    material.size = width;
+    material.sizeAttenuation = true;
+  } else {
+    material.size = 3;
+    material.sizeAttenuation = false;
+  }
+  return new THREE.Points(geometry, material);
+}
+var CURVE_DIVISIONS = 8;
+var CUBIC_BASES = {
+  // biome-ignore format: keep matrix layout readable
+  bezier: {
+    m: [
+      [-1, 3, -3, 1],
+      [3, -6, 3, 0],
+      [-3, 3, 0, 0],
+      [1, 0, 0, 0]
+    ],
+    vstep: 3
+  },
+  // biome-ignore format: keep matrix layout readable
+  bspline: {
+    m: [
+      [-1 / 6, 3 / 6, -3 / 6, 1 / 6],
+      [3 / 6, -6 / 6, 3 / 6, 0],
+      [-3 / 6, 0, 3 / 6, 0],
+      [1 / 6, 4 / 6, 1 / 6, 0]
+    ],
+    vstep: 1
+  },
+  // biome-ignore format: keep matrix layout readable
+  catmullRom: {
+    m: [
+      [-1 / 2, 3 / 2, -3 / 2, 1 / 2],
+      [2 / 2, -5 / 2, 4 / 2, -1 / 2],
+      [-1 / 2, 0, 1 / 2, 0],
+      [0, 2 / 2, 0, 0]
+    ],
+    vstep: 1
+  }
+};
+function sampleCubicCurve(cvs, basisName, periodic) {
+  const basis = CUBIC_BASES[basisName] ?? CUBIC_BASES.bezier;
+  const n = cvs.length;
+  const nseg = periodic ? Math.floor(n / basis.vstep) : Math.floor((n - 4) / basis.vstep) + 1;
+  if (n < 4 || nseg < 1) return null;
+  const out = [];
+  for (let s = 0; s < nseg; s++) {
+    const i0 = s * basis.vstep;
+    const P = [cvs[i0 % n], cvs[(i0 + 1) % n], cvs[(i0 + 2) % n], cvs[(i0 + 3) % n]];
+    const last = !periodic && s === nseg - 1 ? CURVE_DIVISIONS : CURVE_DIVISIONS - 1;
+    for (let k = 0; k <= last; k++) {
+      const t = k / CURVE_DIVISIONS;
+      const w = [t * t * t, t * t, t, 1];
+      const point = [0, 0, 0];
+      for (let i = 0; i < 4; i++) {
+        let b = 0;
+        for (let j = 0; j < 4; j++) b += w[j] * basis.m[j][i];
+        point[0] += b * P[i][0];
+        point[1] += b * P[i][1];
+        point[2] += b * P[i][2];
+      }
+      out.push(point);
+    }
+  }
+  return out;
+}
+function polylinePath(samples, closed) {
+  const path = new THREE.CurvePath();
+  const vecs = samples.map(([x, y, z]) => new THREE.Vector3(x, y, z));
+  for (let i = 0; i < vecs.length - 1; i++) path.add(new THREE.LineCurve3(vecs[i], vecs[i + 1]));
+  if (closed) path.add(new THREE.LineCurve3(vecs[vecs.length - 1], vecs[0]));
+  return path;
+}
+function buildBasisCurvesObject(prim, stage, curveTubes, mdl) {
+  const points = prim.GetAttribute("points").Get();
+  const counts = prim.GetAttribute("curveVertexCounts").Get();
+  if (!isVec3Array(points) || !isNumberArray(counts) || counts.length === 0) return null;
+  const curveType = prim.GetAttribute("type").Get() ?? "cubic";
+  const basisName = prim.GetAttribute("basis").Get() ?? "bezier";
+  const periodic = prim.GetAttribute("wrap").Get() === "periodic";
+  const flat = resolveFlatColor(prim, stage, mdl);
+  const width = meanWidth(prim);
+  const asTubes = curveTubes && width !== void 0 && width > 0;
+  const material = asTubes ? new THREE.MeshStandardMaterial({ color: flat.color, roughness: 0.8, metalness: 0.1 }) : new THREE.LineBasicMaterial({ color: flat.color });
+  if (flat.opacity < 1) {
+    material.transparent = true;
+    material.opacity = flat.opacity;
+  }
+  if (flat.name) material.name = flat.name;
+  const group = new THREE.Group();
+  let offset = 0;
+  for (const count of counts) {
+    const cvs = points.slice(offset, offset + count);
+    offset += count;
+    const samples = curveType === "linear" ? cvs.length >= 2 ? cvs : null : sampleCubicCurve(cvs, typeof basisName === "string" ? basisName : "bezier", periodic);
+    if (!samples || samples.length < 2) continue;
+    if (asTubes) {
+      const path = polylinePath(samples, periodic);
+      const geometry = new THREE.TubeGeometry(
+        path,
+        Math.max(samples.length, 2),
+        width / 2,
+        8,
+        periodic
+      );
+      group.add(new THREE.Mesh(geometry, material));
+    } else {
+      const geometry = new THREE.BufferGeometry();
+      geometry.setAttribute("position", new THREE.Float32BufferAttribute(flat3(samples), 3));
+      group.add(
+        periodic ? new THREE.LineLoop(geometry, material) : new THREE.Line(geometry, material)
+      );
+    }
+  }
+  return group.children.length > 0 ? group : null;
+}
+function getNumber(prim, name) {
+  const v = prim.GetAttribute(name).Get();
+  return typeof v === "number" ? v : void 0;
+}
+function orientSpine(geometry, prim) {
+  const axis = prim.GetAttribute("axis").Get();
+  if (axis === "Y") return geometry;
+  if (axis === "X") return geometry.rotateZ(-Math.PI / 2);
+  return geometry.rotateX(Math.PI / 2);
+}
+function buildMeshMaterial(meshPrim, stage, textures, bindingPrim, onWarn, mdl) {
+  const color = new THREE.Color(DEFAULT_COLOR);
+  let opacity = 1;
+  let vertexColors = false;
+  const resolveOptions = {
+    ...mdl ? { mdl } : {},
+    ...onWarn ? { onWarn } : {}
+  };
+  const bound = stage ? resolveBoundMaterial(stage, bindingPrim ?? meshPrim, resolveOptions) : void 0;
+  if (bound?.color) {
+    color.setRGB(bound.color[0], bound.color[1], bound.color[2]);
+  } else {
+    const displayColor = displayColorPrimvar(meshPrim);
+    if (displayColor && displayColor.interpolation !== "constant") {
+      vertexColors = true;
+      color.setRGB(1, 1, 1);
+    } else if (displayColor?.values[0]) {
+      const [r, g, b] = displayColor.values[0];
+      color.setRGB(r ?? 0, g ?? 0, b ?? 0);
+    }
+  }
+  if (bound?.opacity !== void 0) opacity = bound.opacity;
+  const uvSetNames = meshUvSetNames(meshPrim);
+  const tex = (rt, cs) => {
+    if (!rt || !textures) return null;
+    const channel = rt.uvSet ? Math.max(uvSetNames.indexOf(rt.uvSet), 0) : 0;
+    const colorSpace = rt.sourceColorSpace === "raw" ? "linear" : rt.sourceColorSpace === "sRGB" ? "srgb" : cs;
+    return textures(rt.path, {
+      colorSpace,
+      ...rt.wrapS ? { wrapS: rt.wrapS } : {},
+      ...rt.wrapT ? { wrapT: rt.wrapT } : {},
+      ...rt.transform ? { transform: rt.transform } : {},
+      ...channel > 0 ? { channel } : {}
+    });
+  };
+  if (onWarn) {
+    const packed = [
+      [bound?.roughnessTexture, "g", "roughness"],
+      [bound?.metalnessTexture, "b", "metalness"],
+      [bound?.occlusionTexture, "r", "occlusion"]
+    ];
+    for (const [rt, expected, label] of packed) {
+      const channel = rt?.outputChannel;
+      if (channel && channel !== "rgb" && channel !== expected) {
+        onWarn(
+          `${meshPrim.GetPath()}: ${label} reads outputs:${channel}, but three.js samples the "${expected}" channel of the map \u2014 repack the texture to the glTF ORM layout`
+        );
+      }
+    }
+  }
+  const map = tex(bound?.colorTexture, "srgb");
+  if (map) {
+    const s = bound?.colorTexture?.scale;
+    if (s) color.setRGB(s[0], s[1], s[2]);
+    else color.setRGB(1, 1, 1);
+  }
+  const normalMap = tex(bound?.normalTexture, "linear");
+  const roughnessMap = tex(bound?.roughnessTexture, "linear");
+  const metalnessMap = tex(bound?.metalnessTexture, "linear");
+  const aoMap = tex(bound?.occlusionTexture, "linear");
+  const emissiveMap = tex(bound?.emissiveTexture, "srgb");
+  const metalness = bound?.metalness ?? bound?.metalnessTexture?.scale?.[0] ?? (metalnessMap ? 1 : 0.1);
+  const roughness = bound?.roughness ?? bound?.roughnessTexture?.scale?.[0] ?? (roughnessMap ? 1 : 0.8);
+  const emissive = new THREE.Color(0);
+  if (bound?.emissiveColor) {
+    emissive.setRGB(bound.emissiveColor[0], bound.emissiveColor[1], bound.emissiveColor[2]);
+  } else if (emissiveMap) {
+    emissive.setRGB(1, 1, 1);
+  }
+  const opacityTex = bound?.opacityTexture;
+  const sharesColorMap = !!(opacityTex && opacityTex.path === bound?.colorTexture?.path);
+  const alphaMap = sharesColorMap ? null : tex(opacityTex, "linear");
+  const hasAlphaSource = opacity < 1 || sharesColorMap || !!alphaMap;
+  const threshold = bound?.opacityThreshold;
+  const alphaTest = threshold !== void 0 && threshold > 0 ? threshold : 0;
+  const transparent = alphaTest === 0 && hasAlphaSource;
+  const doubleSided = meshPrim.GetAttribute("doubleSided").Get() === true;
+  const params = {
+    color,
+    metalness,
+    roughness,
+    emissive,
+    transparent,
+    opacity,
+    ...vertexColors ? { vertexColors: true } : {},
+    ...alphaTest > 0 ? { alphaTest } : {},
+    side: doubleSided ? THREE.DoubleSide : THREE.FrontSide,
+    ...map ? { map } : {},
+    ...alphaMap ? { alphaMap } : {},
+    ...normalMap ? { normalMap } : {},
+    ...roughnessMap ? { roughnessMap } : {},
+    ...metalnessMap ? { metalnessMap } : {},
+    ...aoMap ? { aoMap } : {},
+    ...emissiveMap ? { emissiveMap } : {}
+  };
+  const physical = bound !== void 0 && (bound.ior !== void 0 || bound.clearcoat !== void 0 || bound.clearcoatRoughness !== void 0 || bound.specularColor !== void 0 || bound.transmission !== void 0 || bound.clearcoatNormalTexture !== void 0);
+  const material = physical ? new THREE.MeshPhysicalMaterial(params) : new THREE.MeshStandardMaterial(params);
+  if (material instanceof THREE.MeshPhysicalMaterial && bound) {
+    if (bound.ior !== void 0) material.ior = bound.ior;
+    if (bound.clearcoat !== void 0) material.clearcoat = bound.clearcoat;
+    if (bound.clearcoatRoughness !== void 0)
+      material.clearcoatRoughness = bound.clearcoatRoughness;
+    if (bound.specularColor) {
+      material.specularColor.setRGB(
+        bound.specularColor[0],
+        bound.specularColor[1],
+        bound.specularColor[2]
+      );
+    }
+    if (bound.transmission !== void 0) material.transmission = bound.transmission;
+    if (bound.thickness !== void 0) material.thickness = bound.thickness;
+    const clearcoatNormalMap = tex(bound.clearcoatNormalTexture, "linear");
+    if (clearcoatNormalMap) material.clearcoatNormalMap = clearcoatNormalMap;
+  }
+  if (bound?.emissiveIntensity !== void 0) material.emissiveIntensity = bound.emissiveIntensity;
+  if (normalMap && bound?.normalTexture?.scale) {
+    material.normalScale.set(bound.normalTexture.scale[0] / 2, bound.normalTexture.scale[1] / 2);
+  }
+  if (bound?.name) material.name = bound.name;
+  return material;
+}
+function bindRobotMeshes(stage, robot3d, desc, options = {}) {
+  const loadVisuals = options.loadVisuals ?? true;
+  const loadCollisions = options.loadCollisions ?? false;
+  const gprimOptions = {
+    ...options.textureProvider ? { textureProvider: options.textureProvider } : {},
+    ...options.curveTubes ? { curveTubes: true } : {},
+    ...options.onWarn ? { onWarn: options.onWarn } : {},
+    ...options.mdl ? { mdl: options.mdl } : {}
+  };
+  for (const [key, link] of Object.entries(desc.links)) {
+    const linkObj = robot3d.getLinkObject(key);
+    const linkPrim = stage.GetPrimAtPath(link.primPath);
+    if (!linkObj || !linkPrim) continue;
+    const visualSet = new Set(link.visualPrims);
+    if (loadVisuals) {
+      for (const meshPath of link.visualPrims) {
+        attachGprim(stage, linkPrim, meshPath, linkObj, "visual", gprimOptions);
+      }
+    }
+    if (loadCollisions) {
+      for (const meshPath of link.collisionPrims ?? []) {
+        if (loadVisuals && visualSet.has(meshPath)) continue;
+        attachGprim(stage, linkPrim, meshPath, linkObj, "collision", gprimOptions);
+      }
+    }
+  }
+}
+function bindSceneMeshes(stage, robot3d, desc, options = {}) {
+  const owned = /* @__PURE__ */ new Set();
+  for (const link of Object.values(desc.links)) {
+    for (const path of link.visualPrims) owned.add(path);
+    for (const path of link.collisionPrims ?? []) owned.add(path);
+    owned.add(link.primPath);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const containerFor = (prim) => {
+    const parent = prim.GetParent();
+    if (!parent || parent.IsPseudoRoot()) return robot3d;
+    let node = nodes.get(parent.GetPath());
+    if (!node) {
+      node = new THREE.Group();
+      node.name = parent.GetName();
+      node.userData.kind = "scene";
+      node.userData.primPath = parent.GetPath();
+      placeAtLocal(node, parent);
+      containerFor(parent).add(node);
+      nodes.set(parent.GetPath(), node);
+    }
+    return node;
+  };
+  const gprimOptions = {
+    ...options.textureProvider ? { textureProvider: options.textureProvider } : {},
+    ...options.curveTubes ? { curveTubes: true } : {},
+    ...options.onWarn ? { onWarn: options.onWarn } : {},
+    ...options.mdl ? { mdl: options.mdl } : {}
+  };
+  let attached = 0;
+  for (const prim of stage.Traverse()) {
+    if (!isRenderableGprim(prim) || owned.has(prim.GetPath())) continue;
+    if (prim.HasAPI(COLLISION_API) || isNonVisualPurpose(prim)) continue;
+    if ([...owned].some((path) => prim.GetPath().startsWith(`${path}/`))) continue;
+    const object = buildGprimObject(prim, stage, gprimOptions);
+    if (!object) continue;
+    object.name = prim.GetName();
+    object.userData.kind = "scene";
+    object.userData.primPath = prim.GetPath();
+    placeAtLocal(object, prim);
+    containerFor(prim).add(object);
+    nodes.set(prim.GetPath(), object);
+    attached++;
+  }
+  return attached;
+}
+function placeAtLocal(object, prim) {
+  object.matrixAutoUpdate = false;
+  object.matrix.fromArray(computeLocalTransform(prim).matrix);
+  object.matrixWorldNeedsUpdate = true;
+}
+function buildMeshMaterials(meshPrim, stage, textures, onWarn, mdl) {
+  const subsets = stage ? getMaterialSubsets(meshPrim) : [];
+  if (subsets.length === 0)
+    return buildMeshMaterial(meshPrim, stage, textures, void 0, onWarn, mdl);
+  return [
+    ...subsets.map((s) => buildMeshMaterial(meshPrim, stage, textures, s.prim, onWarn, mdl)),
+    buildMeshMaterial(meshPrim, stage, textures, void 0, onWarn, mdl)
+  ];
+}
+function attachGprim(stage, linkPrim, meshPath, parent, kind, options) {
+  const meshPrim = stage.GetPrimAtPath(meshPath);
+  if (!meshPrim) return;
+  const object = buildGprimObject(meshPrim, stage, options);
+  if (!object) return;
+  object.name = meshPrim.GetName();
+  object.userData.kind = kind;
+  object.userData.primPath = meshPath;
+  if (kind === "collision") object.visible = false;
+  object.matrixAutoUpdate = false;
+  object.matrix.fromArray(relativeTransform(linkPrim, meshPrim));
+  object.matrixWorldNeedsUpdate = true;
+  parent.add(object);
+}
+function relativeTransform(linkPrim, meshPrim) {
+  const chain = [];
+  let p = meshPrim;
+  const stop = linkPrim.GetPath();
+  while (p && p.GetPath() !== stop) {
+    chain.push(p);
+    p = p.GetParent();
+  }
+  chain.reverse();
+  let m = identity4();
+  for (const prim of chain) {
+    m = multiply(m, computeLocalTransform(prim).matrix);
+  }
+  return m;
+}
+function triangulate(faceVertexCounts, faceVertexIndices) {
+  const tris = [];
+  let offset = 0;
+  for (const count of faceVertexCounts) {
+    for (let k = 2; k < count; k++) {
+      tris.push(
+        faceVertexIndices[offset],
+        faceVertexIndices[offset + k - 1],
+        faceVertexIndices[offset + k]
+      );
+    }
+    offset += count;
+  }
+  return tris;
+}
+function triangulateBySubset(geometry, faceVertexCounts, faceVertexIndices, subsets) {
+  const faceStart = [];
+  let offset = 0;
+  for (const count of faceVertexCounts) {
+    faceStart.push(offset);
+    offset += count;
+  }
+  const tris = [];
+  const emit = (face) => {
+    const start = faceStart[face];
+    const count = faceVertexCounts[face];
+    for (let k = 2; k < count; k++) {
+      tris.push(
+        faceVertexIndices[start],
+        faceVertexIndices[start + k - 1],
+        faceVertexIndices[start + k]
+      );
+    }
+  };
+  const claimed = new Uint8Array(faceVertexCounts.length);
+  subsets.forEach((subset, index) => {
+    const begin2 = tris.length;
+    for (const face of subset.faces) {
+      if (face < 0 || face >= faceVertexCounts.length || claimed[face]) continue;
+      claimed[face] = 1;
+      emit(face);
+    }
+    if (tris.length > begin2) geometry.addGroup(begin2, tris.length - begin2, index);
+  });
+  const begin = tris.length;
+  for (let face = 0; face < faceVertexCounts.length; face++) {
+    if (!claimed[face]) emit(face);
+  }
+  if (tris.length > begin) geometry.addGroup(begin, tris.length - begin, subsets.length);
+  return tris;
+}
+function flat3(v) {
+  const out = new Array(v.length * 3);
+  for (let i = 0; i < v.length; i++) {
+    out[i * 3] = v[i][0];
+    out[i * 3 + 1] = v[i][1];
+    out[i * 3 + 2] = v[i][2];
+  }
+  return out;
+}
+function flat2(v) {
+  const out = new Array(v.length * 2);
+  for (let i = 0; i < v.length; i++) {
+    out[i * 2] = v[i][0];
+    out[i * 2 + 1] = v[i][1];
+  }
+  return out;
+}
+function isNumberArray(v) {
+  return Array.isArray(v) && v.every((n) => typeof n === "number");
+}
+function isVec3Array(v) {
+  return Array.isArray(v) && v.every((e) => Array.isArray(e) && e.length === 3);
+}
+function isVec2Array(v) {
+  return Array.isArray(v) && v.every((e) => Array.isArray(e) && e.length === 2);
+}
+var DEG2RAD = Math.PI / 180;
+function createTextureProvider(resolver, baseUrl) {
+  const images = /* @__PURE__ */ new Map();
+  const imageFor = (url) => {
+    let p = images.get(url);
+    if (!p) {
+      p = loadImage(resolver, url);
+      images.set(url, p);
+    }
+    return p;
+  };
+  return (assetPath, options = {}) => {
+    let url;
+    try {
+      url = resolver.resolve(assetPath, baseUrl);
+    } catch {
+      return null;
+    }
+    const texture = new THREE.Texture();
+    texture.colorSpace = options.colorSpace === "linear" ? THREE.NoColorSpace : THREE.SRGBColorSpace;
+    texture.wrapS = toThreeWrap(options.wrapS);
+    texture.wrapT = toThreeWrap(options.wrapT);
+    if (options.channel !== void 0) texture.channel = options.channel;
+    applyTransform(texture, options.transform);
+    imageFor(url).then((image) => {
+      texture.image = image;
+      texture.needsUpdate = true;
+    }).catch(() => {
+    });
+    return texture;
+  };
+}
+async function loadImage(resolver, url) {
+  const bytes = resolver.fetchBytes ? await resolver.fetchBytes(url) : new TextEncoder().encode(await resolver.fetchText(url));
+  const blob = new Blob([bytes], { type: mimeOf(url) });
+  const objectUrl = URL.createObjectURL(blob);
+  try {
+    return await new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => resolve(img);
+      img.onerror = () => reject(new Error(`failed to decode texture: ${url}`));
+      img.src = objectUrl;
+    });
+  } finally {
+    URL.revokeObjectURL(objectUrl);
+  }
+}
+function toThreeWrap(wrap) {
+  switch (wrap) {
+    case "clamp":
+    case "black":
+      return THREE.ClampToEdgeWrapping;
+    case "mirror":
+      return THREE.MirroredRepeatWrapping;
+    default:
+      return THREE.RepeatWrapping;
+  }
+}
+function applyTransform(texture, t) {
+  if (!t) return;
+  if (t.scale) texture.repeat.set(t.scale[0], t.scale[1]);
+  if (t.translation) texture.offset.set(t.translation[0], t.translation[1]);
+  if (t.rotation !== void 0) {
+    texture.rotation = t.rotation * DEG2RAD;
+    texture.center.set(0, 0);
+  }
+}
+function mimeOf(url) {
+  if (/\.jpe?g$/i.test(url)) return "image/jpeg";
+  if (/\.webp$/i.test(url)) return "image/webp";
+  return "image/png";
+}
+
+// src/three/ThreeUsdRobotLoader.ts
+var ThreeUsdRobotLoader = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  get resolver() {
+    return this.options.assetResolver ?? new DefaultAssetResolver();
+  }
+  /**
+   * Fetch an asset by URL and build the robot. `.usdz` packages are unzipped and
+   * composed from their entries; everything else is sniffed for the zip / crate
+   * magic and parsed as USDZ, binary USDC, or USDA text.
+   */
+  async loadAsync(url) {
+    const bytes = await this.fetchRootBytes(url);
+    if (/\.usdz$/i.test(url)) return this.parseUsdz(bytes);
+    return this.parse(bytes, url);
+  }
+  async fetchRootBytes(url) {
+    const resolver = this.resolver;
+    if (resolver.fetchBytes) return resolver.fetchBytes(url);
+    return new TextEncoder().encode(await resolver.fetchText(url));
+  }
+  /**
+   * Build a robot from in-memory content — no fetch involved. Accepts USDA
+   * source text, or an `ArrayBuffer` / typed array / `Blob` (e.g. a dropped
+   * `File`) holding USDA text, a binary crate, or a `.usdz` package; binary
+   * input is sniffed for the zip / crate magic. `baseUrl` anchors relative
+   * references, payloads, and texture paths of non-package input.
+   */
+  async parse(data, baseUrl = "") {
+    return this.buildFromStage(await this.openSource(data, baseUrl));
+  }
+  /** Build a robot from a `.usdz` package (bytes, `ArrayBuffer`, or `Blob`). */
+  async parseUsdz(data) {
+    return this.buildFromStage(await this.openUsdzStage(await toBytes(data)));
+  }
+  /** Build a robot from a binary crate (`.usdc` / binary `.usd`). */
+  async parseCrate(data, baseUrl = "") {
+    const stage = await this.composeStageFromBytes(await toBytes(data), baseUrl, this.resolver);
+    return this.buildFromStage({ stage, baseUrl, resolver: this.resolver });
+  }
+  /**
+   * Parse + compose in-memory content (same formats as {@link parse}) into the
+   * Three.js-independent robot IR.
+   */
+  async parseRobotDescription(data, baseUrl = "") {
+    const { stage } = await this.openSource(data, baseUrl);
+    return extractRobotDescription(stage, this.extractOptions());
+  }
+  /** Sniff in-memory content (text / zip / crate) and compose it into a stage. */
+  async openSource(data, baseUrl) {
+    const resolver = this.resolver;
+    if (typeof data === "string") {
+      return { stage: await this.composeStage(data, baseUrl, resolver), baseUrl, resolver };
+    }
+    const bytes = await toBytes(data);
+    if (isZip(bytes)) return this.openUsdzStage(bytes);
+    const stage = CrateReader.isCrate(bytes) ? await this.composeStageFromBytes(bytes, baseUrl, resolver) : await this.composeStage(new TextDecoder().decode(bytes), baseUrl, resolver);
+    return { stage, baseUrl, resolver };
+  }
+  async openUsdzStage(bytes) {
+    const pkg = openUsdz(bytes);
+    const rootBytes = await pkg.resolver.fetchBytes(pkg.rootEntry);
+    const stage = await this.composeStageFromBytes(rootBytes, pkg.rootEntry, pkg.resolver);
+    return { stage, baseUrl: pkg.rootEntry, resolver: pkg.resolver };
+  }
+  async buildFromStage({ stage, baseUrl, resolver }) {
+    const robot = extractRobotDescription(stage, this.extractOptions());
+    const tree = buildKinematicTree(robot);
+    const robot3d = new ThreeUsdRobot(robot, tree, this.robotOptions());
+    robot3d.stage = stage;
+    const loadVisuals = this.options.loadVisuals ?? true;
+    const loadCollisions = this.options.loadCollisions ?? false;
+    const isStaticScene = Object.keys(robot.links).length === 0 && Object.keys(robot.joints).length === 0;
+    if (isStaticScene && this.options.loadSceneGeometry === void 0) {
+      this.options.onWarn?.(
+        "no articulation found (0 links / 0 joints); rendering the stage as static scene geometry"
+      );
+    }
+    const loadScene = this.options.loadSceneGeometry ?? isStaticScene;
+    if (loadVisuals || loadCollisions || loadScene) {
+      const textureProvider = this.options.loadTextures ?? true ? createTextureProvider(resolver, baseUrl) : void 0;
+      const curveTubes = this.options.curveTubes ?? false;
+      const onWarn = this.options.onWarn;
+      const mdl = await loadMdlModules(stage, resolver, baseUrl);
+      if (loadVisuals || loadCollisions) {
+        bindRobotMeshes(stage, robot3d, robot, {
+          loadVisuals,
+          loadCollisions,
+          ...textureProvider ? { textureProvider } : {},
+          ...curveTubes ? { curveTubes } : {},
+          ...onWarn ? { onWarn } : {},
+          ...mdl ? { mdl } : {}
+        });
+      }
+      if (loadScene) {
+        bindSceneMeshes(stage, robot3d, robot, {
+          ...textureProvider ? { textureProvider } : {},
+          ...curveTubes ? { curveTubes } : {},
+          ...onWarn ? { onWarn } : {},
+          ...mdl ? { mdl } : {}
+        });
+      }
+      this.warnUnsupportedGprims(stage);
+    }
+    return robot3d;
+  }
+  /** Surface recognized-but-unrenderable gprim schemas instead of silence (M18). */
+  warnUnsupportedGprims(stage) {
+    const firstByType = /* @__PURE__ */ new Map();
+    for (const prim of stage.Traverse()) {
+      const type = prim.GetTypeName();
+      if (isUnsupportedGprim(prim) && !firstByType.has(type)) {
+        firstByType.set(type, prim.GetPath());
+      }
+    }
+    for (const [type, path] of firstByType) {
+      this.options.onWarn?.(`${type} gprims are not supported yet; skipping (e.g. ${path})`);
+    }
+  }
+  async composeStage(text, baseUrl, resolver) {
+    const composeOptions = this.options.onWarn ? { onWarn: this.options.onWarn } : {};
+    return Stage.OpenFromFile(await composeLayer(text, baseUrl, resolver, composeOptions));
+  }
+  /** Compose a layer from raw bytes, sniffing binary crate vs USDA text. */
+  async composeStageFromBytes(bytes, baseUrl, resolver) {
+    const composeOptions = this.options.onWarn ? { onWarn: this.options.onWarn } : {};
+    const composed = CrateReader.isCrate(bytes) ? await composeFile(
+      crateToUsdaFile(new CrateReader(bytes)),
+      baseUrl,
+      resolver,
+      composeOptions
+    ) : await composeLayer(new TextDecoder().decode(bytes), baseUrl, resolver, composeOptions);
+    return Stage.OpenFromFile(composed);
+  }
+  robotOptions() {
+    return {
+      ...this.options.worldUp ? { worldUp: this.options.worldUp } : { upAxisConversion: this.options.upAxisConversion ?? "auto" },
+      ...this.options.clampJointLimits !== void 0 ? { clampJointLimits: this.options.clampJointLimits } : {},
+      ...this.options.unitScale !== void 0 ? { unitScale: this.options.unitScale } : {},
+      ...this.options.applyDriveTargetsAsInitialPose !== void 0 ? { applyInitialPose: this.options.applyDriveTargetsAsInitialPose } : {},
+      ...this.options.debugBakedTransforms !== void 0 ? { debugBakedTransforms: this.options.debugBakedTransforms } : {}
+    };
+  }
+  extractOptions() {
+    return {
+      ...this.options.robotName !== void 0 ? { robotName: this.options.robotName } : {},
+      ...this.options.onWarn !== void 0 ? { onWarn: this.options.onWarn } : {}
+    };
+  }
+};
+
+export { ThreeUsdRobotLoader, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildGprimObject, buildMeshGeometry, buildMeshMaterial, createTextureProvider };
+//# sourceMappingURL=chunk-5SVRTKS4.js.map
+//# sourceMappingURL=chunk-5SVRTKS4.js.map