three-usd-robot 0.13.0 → 0.14.0

package/dist/{chunk-GRJGPHLW.js → chunk-WQRP5IDJ.js}

@@ -1,9 +1,286 @@
-import { getMaterialSubsets, isRenderableGprim, COLLISION_API, isNonVisualPurpose, computeLocalTransform, toBytes, extractRobotDescription, isZip, CrateReader, openUsdz, buildKinematicTree, loadMdlModules, isUnsupportedGprim, Stage, composeLayer, composeFile, crateToUsdaFile } from './chunk-FUVHAORT.js';
-import { ThreeUsdRobot } from './chunk-JN2QPDB3.js';
-import { identity4, multiply } from './chunk-YGJ23CG3.js';
+import { isNonVisualPurpose, isUnsupportedLight, getLightKind, readLightDescription, getMaterialSubsets, isRenderableGprim, COLLISION_API, toBytes, extractRobotDescription, isZip, CrateReader, openUsdz, buildKinematicTree, loadMdlModules, isUnsupportedGprim, Stage, composeLayer, composeFile, crateToUsdaFile } from './chunk-KRT4NL3H.js';
+import { ThreeUsdRobot } from './chunk-HDZGWL6P.js';
 import { resolveBoundMaterial, DefaultAssetResolver } from './chunk-PPPRB6KE.js';
-import * as THREE from 'three';
+import { isCamera, readCameraDescription, computeWorldTransform, computeLocalTransform } from './chunk-ZQXYVBQI.js';
+import { identity4, multiply } from './chunk-IAOPNN6V.js';
+import * as THREE3 from 'three';
 
+// src/three/stageAnchors.ts
+function collectAnchors(robot3d) {
+  const anchors = /* @__PURE__ */ new Map();
+  robot3d.traverse((object) => {
+    const path = object.userData.primPath;
+    if (typeof path === "string" && !anchors.has(path)) anchors.set(path, object);
+  });
+  for (const [path, link] of robot3d.getLinkObjectsByPath()) anchors.set(path, link);
+  return anchors;
+}
+function findAnchor(prim, anchors) {
+  for (let p = prim.GetParent(); p && !p.IsPseudoRoot(); p = p.GetParent()) {
+    const object = anchors.get(p.GetPath());
+    if (object) return { object, prim: p };
+  }
+  return null;
+}
+function transformFrom(anchorPrim, prim) {
+  const stop = anchorPrim?.GetPath();
+  const chain = [];
+  for (let p = prim; p && !p.IsPseudoRoot() && p.GetPath() !== stop; p = p.GetParent()) {
+    chain.push(p);
+  }
+  chain.reverse();
+  let m = identity4();
+  for (const link of chain) m = multiply(m, computeLocalTransform(link).matrix);
+  return m;
+}
+function worldScaleOf(prim, rootScale) {
+  const m = computeWorldTransform(prim);
+  const sx = Math.hypot(m[0], m[1], m[2]);
+  const sy = Math.hypot(m[4], m[5], m[6]);
+  const sz = Math.hypot(m[8], m[9], m[10]);
+  return rootScale * ((sx + sy + sz) / 3);
+}
+function attachAtPrim(object, prim, anchors, robot3d) {
+  const anchor = findAnchor(prim, anchors);
+  object.matrixAutoUpdate = false;
+  object.matrix.fromArray(transformFrom(anchor?.prim ?? null, prim));
+  object.matrixWorldNeedsUpdate = true;
+  (anchor?.object ?? robot3d).add(object);
+}
+
+// src/three/CameraBinding.ts
+function bindCameras(stage, robot3d, options = {}) {
+  const cameras = [];
+  const anchors = collectAnchors(robot3d);
+  const rootScale = robot3d.scale.x || 1;
+  for (const prim of stage.Traverse()) {
+    if (!isCamera(prim)) continue;
+    if (prim.GetAttribute("visibility").Get() === "invisible") continue;
+    if (isNonVisualPurpose(prim)) continue;
+    const desc = readCameraDescription(prim);
+    if (!desc) continue;
+    const worldScale = worldScaleOf(prim, rootScale);
+    const camera = createThreeCamera(desc, worldScale, options.onWarn);
+    camera.name = desc.name;
+    camera.userData.kind = "camera";
+    camera.userData.primPath = desc.primPath;
+    camera.userData.usdCamera = desc;
+    camera.userData.usdCameraWorldScale = worldScale;
+    attachAtPrim(camera, prim, anchors, robot3d);
+    cameras.push(camera);
+  }
+  return cameras;
+}
+function createThreeCamera(desc, worldScale, onWarn) {
+  const near = Math.max(desc.clippingRange[0] * worldScale, 1e-5);
+  const far = Math.max(desc.clippingRange[1] * worldScale, near + 1e-5);
+  if (desc.projection === "orthographic") {
+    const halfWidth = desc.horizontalAperture / 10 / 2 * worldScale;
+    const halfHeight = desc.verticalAperture / 10 / 2 * worldScale;
+    return new THREE3.OrthographicCamera(-halfWidth, halfWidth, halfHeight, -halfHeight, near, far);
+  }
+  const camera = new THREE3.PerspectiveCamera(
+    THREE3.MathUtils.radToDeg(2 * Math.atan(desc.verticalAperture / (2 * desc.focalLength))),
+    desc.horizontalAperture / desc.verticalAperture,
+    near,
+    far
+  );
+  camera.filmGauge = desc.horizontalAperture;
+  camera.filmOffset = desc.horizontalApertureOffset;
+  if (desc.verticalApertureOffset !== 0) {
+    onWarn?.(
+      `Camera ${desc.primPath} authors a verticalApertureOffset; Three.js has no vertical film offset \u2014 ignored`
+    );
+  }
+  if (desc.focusDistance > 0) camera.focus = desc.focusDistance * worldScale;
+  camera.updateProjectionMatrix();
+  return camera;
+}
+function conformCameraAspect(camera, viewportAspect, policy = "expandAperture") {
+  const desc = camera.userData.usdCamera;
+  if (camera.isOrthographicCamera) {
+    const ortho = camera;
+    const worldScale = camera.userData.usdCameraWorldScale ?? 1;
+    const halfWidth = desc ? desc.horizontalAperture / 10 / 2 * worldScale : ortho.right;
+    const halfHeight = desc ? desc.verticalAperture / 10 / 2 * worldScale : ortho.top;
+    if (widthFollows(policy, viewportAspect, halfWidth / halfHeight)) {
+      ortho.top = halfHeight;
+      ortho.bottom = -halfHeight;
+      ortho.right = halfHeight * viewportAspect;
+      ortho.left = -ortho.right;
+    } else {
+      ortho.right = halfWidth;
+      ortho.left = -halfWidth;
+      ortho.top = halfWidth / viewportAspect;
+      ortho.bottom = -ortho.top;
+    }
+    ortho.updateProjectionMatrix();
+    return;
+  }
+  const persp = camera;
+  persp.aspect = viewportAspect;
+  if (desc) {
+    const vFov = 2 * Math.atan(desc.verticalAperture / (2 * desc.focalLength));
+    const hFov = 2 * Math.atan(desc.horizontalAperture / (2 * desc.focalLength));
+    const apertureAspect = desc.horizontalAperture / desc.verticalAperture;
+    persp.fov = THREE3.MathUtils.radToDeg(
+      widthFollows(policy, viewportAspect, apertureAspect) ? vFov : 2 * Math.atan(Math.tan(hFov / 2) / viewportAspect)
+      // keep the horizontal view
+    );
+  }
+  persp.updateProjectionMatrix();
+}
+function widthFollows(policy, viewportAspect, apertureAspect) {
+  switch (policy) {
+    case "adjustApertureWidth":
+      return true;
+    case "adjustApertureHeight":
+      return false;
+    case "expandAperture":
+      return viewportAspect >= apertureAspect;
+    case "cropAperture":
+      return viewportAspect < apertureAspect;
+  }
+}
+function bindLights(stage, robot3d, options = {}) {
+  const intensityScale = options.lightIntensityScale ?? 1;
+  const shadows = options.shadows ?? false;
+  const lights = [];
+  const domes = [];
+  const warned = /* @__PURE__ */ new Set();
+  const warnOnce = (key, message) => {
+    if (warned.has(key)) return;
+    warned.add(key);
+    options.onWarn?.(message);
+  };
+  const anchors = collectAnchors(robot3d);
+  const rootScale = robot3d.scale.x || 1;
+  let metrics = null;
+  const sceneMetrics = () => {
+    if (!metrics) {
+      const box = new THREE3.Box3().setFromObject(robot3d);
+      const sphere = new THREE3.Sphere();
+      if (!box.isEmpty()) box.getBoundingSphere(sphere);
+      metrics = { center: sphere.center.clone(), radius: Math.max(sphere.radius, 0.5) };
+    }
+    return metrics;
+  };
+  for (const prim of stage.Traverse()) {
+    if (isUnsupportedLight(prim)) {
+      warnOnce(
+        prim.GetTypeName(),
+        `${prim.GetTypeName()} lights are not supported yet; skipping (e.g. ${prim.GetPath()})`
+      );
+      continue;
+    }
+    if (!getLightKind(prim)) continue;
+    if (prim.GetAttribute("visibility").Get() === "invisible") continue;
+    if (isNonVisualPurpose(prim)) continue;
+    const desc = readLightDescription(prim);
+    if (!desc) continue;
+    if (desc.kind === "dome") {
+      domes.push(desc);
+      warnOnce(
+        "DomeLight",
+        `DomeLight ${desc.primPath} is surfaced on robot.domeLights \u2014 apply it as the scene environment with applyUsdEnvironment from three-usd-robot/rendering`
+      );
+      continue;
+    }
+    const light = createThreeLight(desc, worldScaleOf(prim, rootScale), intensityScale, warnOnce);
+    if (!light) continue;
+    light.name = desc.name;
+    light.userData.kind = "light";
+    light.userData.primPath = desc.primPath;
+    light.userData.usdLight = desc;
+    attachAtPrim(light, prim, anchors, robot3d);
+    if (shadows) configureShadow(light, desc, prim, rootScale, robot3d, sceneMetrics);
+    lights.push(light);
+  }
+  return { lights, domes };
+}
+function aimAlongMinusZ(light) {
+  const target = new THREE3.Object3D();
+  target.name = "target";
+  target.position.set(0, 0, -1);
+  light.add(target);
+  light.target = target;
+}
+function createThreeLight(desc, worldScale, intensityScale, warnOnce) {
+  const color = new THREE3.Color(desc.color[0], desc.color[1], desc.color[2]);
+  const intensity = desc.intensity * intensityScale;
+  switch (desc.kind) {
+    case "distant": {
+      const light = new THREE3.DirectionalLight(color, intensity);
+      aimAlongMinusZ(light);
+      return light;
+    }
+    case "sphere": {
+      if (desc.cone) {
+        const angle = THREE3.MathUtils.degToRad(Math.min(desc.cone.angleDeg, 89.9));
+        const penumbra = Math.min(Math.max(desc.cone.softness, 0), 1);
+        const light = new THREE3.SpotLight(color, intensity, 0, angle, penumbra);
+        aimAlongMinusZ(light);
+        return light;
+      }
+      return new THREE3.PointLight(color, intensity);
+    }
+    case "rect": {
+      const width = (desc.width ?? 1) * worldScale;
+      const height = (desc.height ?? 1) * worldScale;
+      return new THREE3.RectAreaLight(color, intensity, width, height);
+    }
+    case "disk": {
+      const side = 2 * (desc.radius ?? 0.5) * worldScale;
+      return new THREE3.RectAreaLight(color, intensity * (Math.PI / 4), side, side);
+    }
+    case "cylinder":
+      warnOnce(
+        "CylinderLight",
+        `CylinderLight has no Three.js equivalent; approximating as a point light (e.g. ${desc.primPath})`
+      );
+      return new THREE3.PointLight(color, intensity);
+    case "dome":
+      return null;
+  }
+}
+function configureShadow(light, desc, prim, rootScale, robot3d, sceneMetrics) {
+  const directionalOrSpot = light.isDirectionalLight || light.isSpotLight;
+  const cast = directionalOrSpot ? desc.shadowEnabled : light.isPointLight && desc.shadowAuthored && desc.shadowEnabled;
+  if (!cast) return;
+  const { center, radius } = sceneMetrics();
+  const m = computeWorldTransform(prim);
+  const position = new THREE3.Vector3(m[12], m[13], m[14]).multiplyScalar(rootScale).applyQuaternion(robot3d.quaternion);
+  const distance = position.distanceTo(center);
+  light.castShadow = true;
+  if (light.isDirectionalLight) {
+    const shadow = light.shadow;
+    shadow.normalBias = 0.02 * radius;
+    const camera = shadow.camera;
+    const extent = radius * 1.5;
+    camera.left = -extent;
+    camera.right = extent;
+    camera.top = extent;
+    camera.bottom = -extent;
+    camera.near = distance - 2.5 * radius;
+    camera.far = distance + 2.5 * radius;
+    camera.updateProjectionMatrix();
+    shadow.mapSize.set(2048, 2048);
+  } else if (light.isSpotLight) {
+    const shadow = light.shadow;
+    shadow.normalBias = 0.02 * radius;
+    shadow.camera.near = radius / 100;
+    shadow.camera.far = distance + 2.5 * radius;
+    shadow.camera.updateProjectionMatrix();
+    shadow.mapSize.set(1024, 1024);
+  } else {
+    const shadow = light.shadow;
+    shadow.normalBias = 0.02 * radius;
+    shadow.camera.near = radius / 100;
+    shadow.camera.far = Math.max(4 * radius, distance + 2 * radius);
+    shadow.camera.updateProjectionMatrix();
+    shadow.mapSize.set(512, 512);
+  }
+}
 var DEFAULT_COLOR = 10132122;
 function readPrimvar(meshPrim, attrName, isTuple, lens) {
   const attr = meshPrim.GetAttribute(attrName);
@@ -79,8 +356,8 @@ function buildMeshGeometry(meshPrim) {
   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));
+  const geometry = new THREE3.BufferGeometry();
+  geometry.setAttribute("position", new THREE3.Float32BufferAttribute(flat3(points), 3));
   if (counts && indices) {
     const subsets = getMaterialSubsets(meshPrim);
     if (subsets.length > 0) {
@@ -94,7 +371,7 @@ function buildIndexedGeometry(meshPrim, points, counts, indices, uvSets, normals
   if (normals?.interpolation === "vertex") {
     geometry.setAttribute(
       "normal",
-      new THREE.Float32BufferAttribute(flat3(normals.values.slice(0, points.length)), 3)
+      new THREE3.Float32BufferAttribute(flat3(normals.values.slice(0, points.length)), 3)
     );
   } else {
     geometry.computeVertexNormals();
@@ -103,13 +380,13 @@ function buildIndexedGeometry(meshPrim, points, counts, indices, uvSets, normals
     if (uv?.interpolation !== "vertex") continue;
     geometry.setAttribute(
       uvAttrName(i),
-      new THREE.Float32BufferAttribute(flat2(uv.values.slice(0, points.length)), 2)
+      new THREE3.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)
+      new THREE3.Float32BufferAttribute(flat3(color.values.slice(0, points.length)), 3)
     );
   }
   return geometry;
@@ -128,7 +405,7 @@ function buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normal
         return p.values[0];
     }
   };
-  const geometry = new THREE.BufferGeometry();
+  const geometry = new THREE3.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];
@@ -136,7 +413,7 @@ function buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normal
     position[c * 3 + 1] = v[1];
     position[c * 3 + 2] = v[2];
   }
-  geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+  geometry.setAttribute("position", new THREE3.Float32BufferAttribute(position, 3));
   for (const [i, uv] of uvSets.entries()) {
     if (!uv || uv.interpolation === "constant") continue;
     const out = new Array(slots.length * 2);
@@ -145,7 +422,7 @@ function buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normal
       out[c * 2] = t[0] ?? 0;
       out[c * 2 + 1] = t[1] ?? 0;
     }
-    geometry.setAttribute(uvAttrName(i), new THREE.Float32BufferAttribute(out, 2));
+    geometry.setAttribute(uvAttrName(i), new THREE3.Float32BufferAttribute(out, 2));
   }
   const emitVec3 = (p, name) => {
     const out = new Array(slots.length * 3);
@@ -155,7 +432,7 @@ function buildExpandedGeometry(meshPrim, points, counts, indices, uvSets, normal
       out[c * 3 + 1] = t[1] ?? 0;
       out[c * 3 + 2] = t[2] ?? 0;
     }
-    geometry.setAttribute(name, new THREE.Float32BufferAttribute(out, 3));
+    geometry.setAttribute(name, new THREE3.Float32BufferAttribute(out, 3));
   };
   if (normals && normals.interpolation !== "constant") emitVec3(normals, "normal");
   else geometry.computeVertexNormals();
@@ -212,24 +489,24 @@ function buildGprimGeometry(prim) {
       return buildMeshGeometry(prim);
     case "Cube": {
       const size = getNumber(prim, "size") ?? 2;
-      return new THREE.BoxGeometry(size, size, size);
+      return new THREE3.BoxGeometry(size, size, size);
     }
     case "Sphere":
-      return new THREE.SphereGeometry(getNumber(prim, "radius") ?? 1, 32, 16);
+      return new THREE3.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);
+      return orientSpine(new THREE3.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);
+      return orientSpine(new THREE3.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);
+      return orientSpine(new THREE3.ConeGeometry(radius, height, 32), prim);
     }
     default:
       return null;
@@ -245,15 +522,25 @@ function buildGprimObject(prim, stage, options = {}) {
       const geometry = buildGprimGeometry(prim);
       if (!geometry) return null;
       const custom = stage && options.materialFactory ? options.materialFactory(prim, stage) : null;
-      return new THREE.Mesh(
+      const mesh = new THREE3.Mesh(
         geometry,
         custom ?? buildMeshMaterials(prim, stage, options.textureProvider, options.onWarn, options.mdl)
       );
+      if (options.shadows) applyShadowFlags(mesh);
+      return mesh;
     }
   }
 }
+function applyShadowFlags(mesh) {
+  mesh.receiveShadow = true;
+  const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+  mesh.castShadow = materials.some((material) => {
+    const transmission = material.transmission ?? 0;
+    return !material.transparent && transmission === 0;
+  });
+}
 function resolveFlatColor(prim, stage, mdl) {
-  const color = new THREE.Color(DEFAULT_COLOR);
+  const color = new THREE3.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]);
@@ -278,10 +565,10 @@ function meanWidth(prim) {
 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 geometry = new THREE3.BufferGeometry();
+  geometry.setAttribute("position", new THREE3.Float32BufferAttribute(flat3(points), 3));
   const flat = resolveFlatColor(prim, stage, mdl);
-  const material = new THREE.PointsMaterial({ color: flat.color });
+  const material = new THREE3.PointsMaterial({ color: flat.color });
   if (flat.opacity < 1) {
     material.transparent = true;
     material.opacity = flat.opacity;
@@ -289,7 +576,7 @@ function buildPointsObject(prim, stage, mdl) {
   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));
+    geometry.setAttribute("color", new THREE3.Float32BufferAttribute(flat3(displayColor), 3));
     material.vertexColors = true;
     material.color.set(16777215);
   }
@@ -301,7 +588,7 @@ function buildPointsObject(prim, stage, mdl) {
     material.size = 3;
     material.sizeAttenuation = false;
   }
-  return new THREE.Points(geometry, material);
+  return new THREE3.Points(geometry, material);
 }
 var CURVE_DIVISIONS = 8;
 var CUBIC_BASES = {
@@ -363,10 +650,10 @@ function sampleCubicCurve(cvs, basisName, periodic) {
   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]));
+  const path = new THREE3.CurvePath();
+  const vecs = samples.map(([x, y, z]) => new THREE3.Vector3(x, y, z));
+  for (let i = 0; i < vecs.length - 1; i++) path.add(new THREE3.LineCurve3(vecs[i], vecs[i + 1]));
+  if (closed) path.add(new THREE3.LineCurve3(vecs[vecs.length - 1], vecs[0]));
   return path;
 }
 function buildBasisCurvesObject(prim, stage, curveTubes, mdl) {
@@ -379,13 +666,13 @@ function buildBasisCurvesObject(prim, stage, curveTubes, mdl) {
   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 });
+  const material = asTubes ? new THREE3.MeshStandardMaterial({ color: flat.color, roughness: 0.8, metalness: 0.1 }) : new THREE3.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();
+  const group = new THREE3.Group();
   let offset = 0;
   for (const count of counts) {
     const cvs = points.slice(offset, offset + count);
@@ -394,19 +681,19 @@ function buildBasisCurvesObject(prim, stage, curveTubes, mdl) {
     if (!samples || samples.length < 2) continue;
     if (asTubes) {
       const path = polylinePath(samples, periodic);
-      const geometry = new THREE.TubeGeometry(
+      const geometry = new THREE3.TubeGeometry(
         path,
         Math.max(samples.length, 2),
         width / 2,
         8,
         periodic
       );
-      group.add(new THREE.Mesh(geometry, material));
+      group.add(new THREE3.Mesh(geometry, material));
     } else {
-      const geometry = new THREE.BufferGeometry();
-      geometry.setAttribute("position", new THREE.Float32BufferAttribute(flat3(samples), 3));
+      const geometry = new THREE3.BufferGeometry();
+      geometry.setAttribute("position", new THREE3.Float32BufferAttribute(flat3(samples), 3));
       group.add(
-        periodic ? new THREE.LineLoop(geometry, material) : new THREE.Line(geometry, material)
+        periodic ? new THREE3.LineLoop(geometry, material) : new THREE3.Line(geometry, material)
       );
     }
   }
@@ -423,7 +710,7 @@ function orientSpine(geometry, prim) {
   return geometry.rotateX(Math.PI / 2);
 }
 function buildMeshMaterial(meshPrim, stage, textures, bindingPrim, onWarn, mdl) {
-  const color = new THREE.Color(DEFAULT_COLOR);
+  const color = new THREE3.Color(DEFAULT_COLOR);
   let opacity = 1;
   let vertexColors = false;
   const resolveOptions = {
@@ -485,7 +772,7 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim, onWarn, mdl)
   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);
+  const emissive = new THREE3.Color(0);
   if (bound?.emissiveColor) {
     emissive.setRGB(bound.emissiveColor[0], bound.emissiveColor[1], bound.emissiveColor[2]);
   } else if (emissiveMap) {
@@ -508,7 +795,7 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim, onWarn, mdl)
     opacity,
     ...vertexColors ? { vertexColors: true } : {},
     ...alphaTest > 0 ? { alphaTest } : {},
-    side: doubleSided ? THREE.DoubleSide : THREE.FrontSide,
+    side: doubleSided ? THREE3.DoubleSide : THREE3.FrontSide,
     ...map ? { map } : {},
     ...alphaMap ? { alphaMap } : {},
     ...normalMap ? { normalMap } : {},
@@ -518,8 +805,8 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim, onWarn, mdl)
     ...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) {
+  const material = physical ? new THREE3.MeshPhysicalMaterial(params) : new THREE3.MeshStandardMaterial(params);
+  if (material instanceof THREE3.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)
@@ -551,7 +838,8 @@ function bindRobotMeshes(stage, robot3d, desc, options = {}) {
     ...options.curveTubes ? { curveTubes: true } : {},
     ...options.onWarn ? { onWarn: options.onWarn } : {},
     ...options.mdl ? { mdl: options.mdl } : {},
-    ...options.materialFactory ? { materialFactory: options.materialFactory } : {}
+    ...options.materialFactory ? { materialFactory: options.materialFactory } : {},
+    ...options.shadows ? { shadows: true } : {}
   };
   for (const [key, link] of Object.entries(desc.links)) {
     const linkObj = robot3d.getLinkObject(key);
@@ -584,7 +872,7 @@ function bindSceneMeshes(stage, robot3d, desc, options = {}) {
     if (!parent || parent.IsPseudoRoot()) return robot3d;
     let node = nodes.get(parent.GetPath());
     if (!node) {
-      node = new THREE.Group();
+      node = new THREE3.Group();
       node.name = parent.GetName();
       node.userData.kind = "scene";
       node.userData.primPath = parent.GetPath();
@@ -599,7 +887,8 @@ function bindSceneMeshes(stage, robot3d, desc, options = {}) {
     ...options.curveTubes ? { curveTubes: true } : {},
     ...options.onWarn ? { onWarn: options.onWarn } : {},
     ...options.mdl ? { mdl: options.mdl } : {},
-    ...options.materialFactory ? { materialFactory: options.materialFactory } : {}
+    ...options.materialFactory ? { materialFactory: options.materialFactory } : {},
+    ...options.shadows ? { shadows: true } : {}
   };
   let attached = 0;
   for (const prim of stage.Traverse()) {
@@ -640,7 +929,11 @@ function attachGprim(stage, linkPrim, meshPath, parent, kind, options) {
   object.name = meshPrim.GetName();
   object.userData.kind = kind;
   object.userData.primPath = meshPath;
-  if (kind === "collision") object.visible = false;
+  if (kind === "collision") {
+    object.visible = false;
+    object.castShadow = false;
+    object.receiveShadow = false;
+  }
   object.matrixAutoUpdate = false;
   object.matrix.fromArray(relativeTransform(linkPrim, meshPrim));
   object.matrixWorldNeedsUpdate = true;
@@ -739,8 +1032,9 @@ 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) {
+function createTextureProvider(resolver, baseUrl, onWarn) {
   const images = /* @__PURE__ */ new Map();
+  let warnedUdim = false;
   const imageFor = (url) => {
     let p = images.get(url);
     if (!p) {
@@ -750,14 +1044,22 @@ function createTextureProvider(resolver, baseUrl) {
     return p;
   };
   return (assetPath, options = {}) => {
+    let path = assetPath;
+    if (/<UDIM>/i.test(path)) {
+      path = path.replace(/<UDIM>/gi, "1001");
+      if (!warnedUdim) {
+        warnedUdim = true;
+        onWarn?.(`UDIM texture sets are not supported; using tile 1001 only (e.g. ${path})`);
+      }
+    }
     let url;
     try {
-      url = resolver.resolve(assetPath, baseUrl);
+      url = resolver.resolve(path, baseUrl);
     } catch {
       return null;
     }
-    const texture = new THREE.Texture();
-    texture.colorSpace = options.colorSpace === "linear" ? THREE.NoColorSpace : THREE.SRGBColorSpace;
+    const texture = new THREE3.Texture();
+    texture.colorSpace = options.colorSpace === "linear" ? THREE3.NoColorSpace : THREE3.SRGBColorSpace;
     texture.wrapS = toThreeWrap(options.wrapS);
     texture.wrapT = toThreeWrap(options.wrapT);
     if (options.channel !== void 0) texture.channel = options.channel;
@@ -789,11 +1091,11 @@ function toThreeWrap(wrap) {
   switch (wrap) {
     case "clamp":
     case "black":
-      return THREE.ClampToEdgeWrapping;
+      return THREE3.ClampToEdgeWrapping;
     case "mirror":
-      return THREE.MirroredRepeatWrapping;
+      return THREE3.MirroredRepeatWrapping;
     default:
-      return THREE.RepeatWrapping;
+      return THREE3.RepeatWrapping;
   }
 }
 function applyTransform(texture, t) {
@@ -884,6 +1186,10 @@ var ThreeUsdRobotLoader = class {
     const tree = buildKinematicTree(robot);
     const robot3d = new ThreeUsdRobot(robot, tree, this.robotOptions());
     robot3d.stage = stage;
+    robot3d.assetContext = { resolver, baseUrl };
+    if (this.options.lightIntensityScale !== void 0) {
+      robot3d.lightIntensityScale = this.options.lightIntensityScale;
+    }
     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;
@@ -893,10 +1199,11 @@ var ThreeUsdRobotLoader = class {
       );
     }
     const loadScene = this.options.loadSceneGeometry ?? isStaticScene;
+    const shadows = this.options.shadows ?? true;
+    const onWarn = this.options.onWarn;
     if (loadVisuals || loadCollisions || loadScene) {
-      const textureProvider = this.options.loadTextures ?? true ? createTextureProvider(resolver, baseUrl) : void 0;
+      const textureProvider = this.options.loadTextures ?? true ? createTextureProvider(resolver, baseUrl, onWarn) : void 0;
       const curveTubes = this.options.curveTubes ?? false;
-      const onWarn = this.options.onWarn;
       const materialFactory = this.options.materialFactory;
       const mdl = await loadMdlModules(stage, resolver, baseUrl);
       if (loadVisuals || loadCollisions) {
@@ -907,7 +1214,8 @@ var ThreeUsdRobotLoader = class {
           ...curveTubes ? { curveTubes } : {},
           ...onWarn ? { onWarn } : {},
           ...mdl ? { mdl } : {},
-          ...materialFactory ? { materialFactory } : {}
+          ...materialFactory ? { materialFactory } : {},
+          ...shadows ? { shadows } : {}
         });
       }
       if (loadScene) {
@@ -916,11 +1224,26 @@ var ThreeUsdRobotLoader = class {
           ...curveTubes ? { curveTubes } : {},
           ...onWarn ? { onWarn } : {},
           ...mdl ? { mdl } : {},
-          ...materialFactory ? { materialFactory } : {}
+          ...materialFactory ? { materialFactory } : {},
+          ...shadows ? { shadows } : {}
         });
       }
       this.warnUnsupportedGprims(stage);
     }
+    if (this.options.loadLights ?? true) {
+      const bound = bindLights(stage, robot3d, {
+        ...this.options.lightIntensityScale !== void 0 ? { lightIntensityScale: this.options.lightIntensityScale } : {},
+        ...shadows ? { shadows } : {},
+        ...onWarn ? { onWarn } : {}
+      });
+      robot3d.lights = bound.lights;
+      robot3d.domeLights = bound.domes;
+    }
+    if (this.options.loadCameras ?? true) {
+      robot3d.cameras = bindCameras(stage, robot3d, {
+        ...onWarn ? { onWarn } : {}
+      });
+    }
     return robot3d;
   }
   /** Surface recognized-but-unrenderable gprim schemas instead of silence (M18). */
@@ -968,6 +1291,6 @@ var ThreeUsdRobotLoader = class {
   }
 };
 
-export { ThreeUsdRobotLoader, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildGprimObject, buildMeshGeometry, buildMeshMaterial, createTextureProvider };
-//# sourceMappingURL=chunk-GRJGPHLW.js.map
-//# sourceMappingURL=chunk-GRJGPHLW.js.map
+export { ThreeUsdRobotLoader, bindCameras, bindLights, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildGprimObject, buildMeshGeometry, buildMeshMaterial, conformCameraAspect, createTextureProvider };
+//# sourceMappingURL=chunk-WQRP5IDJ.js.map
+//# sourceMappingURL=chunk-WQRP5IDJ.js.map