three-usd-robot 0.9.0 → 0.11.0

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { CollisionApproximation, ExportPhysicsMaterial, RobotGeometryProvider, ExportRobotOptions, ExportMaterial, ExportMesh } from './core.js';
-export { ARTICULATION_ROOT_API, COLLISION_API, ComposeOptions, CrateReader, ExtractOptions, MASS_API, MESH_COLLISION_API, PACKAGE_NAME, PHYSICS_MATERIAL_API, ParseError, RIGID_BODY_API, ResolvedXform, TextureChannel, TokenizeError, UsdzPackage, VERSION, ValidateRobotOptions, ValidationIssue, ValidationSeverity, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, driveKindFor, exportRobotUsda, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isMesh, isRenderableGprim, isScope, isSolidGprim, isXform, isZip, iterDescendants, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, serializeUsda, stageGeometryProvider, tokenize, validateRobotDescription, writeUsdz } from './core.js';
+import { MdlModuleProvider, CollisionApproximation, ExportPhysicsMaterial, RobotGeometryProvider, ExportRobotOptions, ExportMaterial, ExportMesh } from './core.js';
+export { ARTICULATION_ROOT_API, COLLISION_API, ComposeOptions, CrateReader, ExtractOptions, JointDofInput, JointRelativeDecomposition, MASS_API, MESH_COLLISION_API, MdlMaterialDecl, MdlModule, MdlTextureValue, MdlValue, PACKAGE_NAME, PHYSICS_MATERIAL_API, ParseError, RIGID_BODY_API, ResolvedXform, TextureChannel, TokenizeError, UsdzPackage, VERSION, ValidateRobotOptions, ValidationIssue, ValidationSeverity, collectMdlAssetPaths, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, decomposeJointRelative, driveKindFor, exportRobotUsda, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMdlTexture, isMesh, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, jointValueFromSI, jointValueToSI, loadMdlModules, nearestAngleBranch, normalizeJointLimits, openUsdz, parseMdl, parseMdlLiteral, parseOpType, parseUsda, refineJointType, serializeUsda, stageGeometryProvider, tokenize, validateRobotDescription, writeUsdz } from './core.js';
 import * as THREE from 'three';
-import { A as Axis, V as Vec2, b as Vec3, S as Stage, P as Prim, R as RobotDescription, c as JointDriveDescription, d as LinkInertialDescription, K as KinematicTree, U as UsdaFile, M as Mat4 } from './buildKinematicTree-DQ4Vr4sJ.js';
-export { e as AssetPath, f as Attribute, g as AttributeSpec, B as BuildTreeOptions, C as CompositionArc, D as DEFAULT_METERS_PER_UNIT, h as DEG2RAD, a as JointDescription, J as JointType, i as KinematicNode, j as Layer, L as LinkDescription, k as ListOp, l as MetadataMap, m as PrimSpec, n as PropertySpec, Q as Quat, o as RAD2DEG, p as Relationship, q as RelationshipSpec, r as SampleChannel, s as SdfPath, t as Specifier, T as TreeEdge, u as UpAxis, v as UsdDictionary, w as UsdMatrix, x as UsdValue, y as Variability, z as Vec4, E as buildKinematicTree, F as channelFromSamples, G as decomposeRigid, H as fromUsdMatrix, I as getTranslation, N as identity4, O as interpolate, W as invert, X as makeEuler, Y as makeRotationFromQuat, Z as makeRotationX, _ as makeRotationY, $ as makeRotationZ, a0 as makeScale, a1 as makeTranslation, a2 as multiply, a3 as multiplyAll, a4 as toUsdMatrix } from './buildKinematicTree-DQ4Vr4sJ.js';
-import { T as ThreeUsdRobot } from './ThreeUsdRobot-BAh-48DD.js';
-export { J as JointObject, L as LinkObject, a as ThreeUsdRobotOptions, W as WorldUpAxis } from './ThreeUsdRobot-BAh-48DD.js';
+import { A as Axis, V as Vec2, b as Vec3, S as Stage, P as Prim, R as RobotDescription, c as JointDriveDescription, d as LinkInertialDescription, K as KinematicTree, U as UsdaFile, M as Mat4 } from './buildKinematicTree-BCySuZZn.js';
+export { e as AssetPath, f as Attribute, g as AttributeSpec, B as BuildTreeOptions, C as CompositionArc, D as DEFAULT_METERS_PER_UNIT, h as DEG2RAD, a as JointDescription, J as JointType, i as KinematicNode, j as Layer, L as LinkDescription, k as ListOp, l as MetadataMap, m as PrimSpec, n as PropertySpec, Q as Quat, o as RAD2DEG, p as Relationship, q as RelationshipSpec, r as SampleChannel, s as SdfPath, t as Specifier, T as TreeEdge, u as UpAxis, v as UsdDictionary, w as UsdMatrix, x as UsdValue, y as Variability, z as Vec4, E as buildKinematicTree, F as channelFromSamples, G as decomposeRigid, H as fromUsdMatrix, I as getTranslation, N as identity4, O as interpolate, W as invert, X as makeEuler, Y as makeRotationFromQuat, Z as makeRotationX, _ as makeRotationY, $ as makeRotationZ, a0 as makeScale, a1 as makeTranslation, a2 as multiply, a3 as multiplyAll, a4 as toUsdMatrix } from './buildKinematicTree-BCySuZZn.js';
+import { T as ThreeUsdRobot } from './ThreeUsdRobot-BxnCluuK.js';
+export { J as JointObject, b as JointResidual, c as JointValuesFromLinkTransformsOptions, L as LinkObject, d as LinkPose, e as LinkPoseSpace, f as LinkPosesOptions, a as ThreeUsdRobotOptions, W as WorldUpAxis } from './ThreeUsdRobot-BxnCluuK.js';
 import { A as AssetResolver } from './bytes-MOJ2oN-u.js';
 export { B as BinarySource, D as DefaultAssetResolver, U as UsdSource, c as createMemoryResolver, j as joinPosix, t as toBytes } from './bytes-MOJ2oN-u.js';
-export { a as ThreeUsdRobotLoader, T as ThreeUsdRobotLoaderOptions } from './ThreeUsdRobotLoader-DYtvelif.js';
+export { a as ThreeUsdRobotLoader, T as ThreeUsdRobotLoaderOptions } from './ThreeUsdRobotLoader-C-E9uwEe.js';
 
 /** Unit vector for a USD joint axis token. Returns a fresh vector each call. */
 declare function axisVector(axis: Axis): THREE.Vector3;
@@ -20,8 +20,13 @@ declare function axisVector(axis: Axis): THREE.Vector3;
  * emissive inputs plus the **texture** asset paths for the diffuse, normal,
  * roughness, metallic, occlusion and emissive channels. Handles both
  * `UsdPreviewSurface` (constant inputs or a connected `UsdUVTexture` network)
- * and Omniverse `OmniPBR` MDL (direct asset-valued texture inputs such as
- * `inputs:normalmap_texture`).
+ * and the Omniverse MDL material families (M20): `OmniPBR` (and derivatives
+ * such as `OmniPBR_Opacity`), `OmniPBR_ClearCoat`, `OmniGlass`, and an
+ * `OmniSurface(Lite)` constants subset. MDL shaders are identified by
+ * `info:mdl:sourceAsset` / `:subIdentifier`; when the referenced `.mdl` module
+ * text is available (see `loadMdlModules`), parameter values fall back from
+ * authored USD inputs to the module's wrapper arguments and declaration
+ * defaults. Executing MDL remains out of scope.
  */
 
 /** `UsdUVTexture` wrap mode for one axis (`black` ≈ clamp; three has no border). */
@@ -47,6 +52,19 @@ type ResolvedTexture = {
     scale?: [number, number, number, number];
     /** `inputs:bias` — added to the sampled value. */
     bias?: [number, number, number, number];
+    /**
+     * UV-set (primvar) name the texture reads, resolved through the `inputs:st`
+     * connection to a `UsdPrimvarReader_float2.inputs:varname`. Absent ⇒ `"st"`.
+     */
+    uvSet?: string;
+    /** `inputs:sourceColorSpace` — overrides the per-channel colorspace default. */
+    sourceColorSpace?: "raw" | "sRGB" | "auto";
+    /**
+     * Which output the consuming input connects to (`outputs:r` → `"r"`, …).
+     * three.js samples fixed channels (roughness = G, metalness = B, ao = R);
+     * a mismatch is surfaced as a load warning.
+     */
+    outputChannel?: "r" | "g" | "b" | "a" | "rgb";
 };
 type ResolvedMaterial = {
     /** Name of the bound `Material` prim, for round-tripping and debugging. */
@@ -61,6 +79,20 @@ type ResolvedMaterial = {
      * clip / cutout); when `0`/absent, sub-unit opacity blends translucently.
      */
     opacityThreshold?: number;
+    /** `inputs:ior` — promotes the three material to `MeshPhysicalMaterial`. */
+    ior?: number;
+    /** `inputs:clearcoat` (physical promotion). */
+    clearcoat?: number;
+    /** `inputs:clearcoatRoughness` (physical promotion). */
+    clearcoatRoughness?: number;
+    /** `inputs:specularColor`, only when `inputs:useSpecularWorkflow = 1`. */
+    specularColor?: Vec3;
+    /** OmniPBR `inputs:emissive_intensity` — multiplies the emissive color. */
+    emissiveIntensity?: number;
+    /** OmniGlass — `1` marks a transmissive dielectric (physical promotion, M20). */
+    transmission?: number;
+    /** OmniGlass `inputs:depth` — refraction volume thickness (scene units, M20). */
+    thickness?: number;
     /** Diffuse/albedo texture, if any. */
     colorTexture?: ResolvedTexture;
     /** Opacity / alpha texture (may be the same image as `colorTexture`). */
@@ -75,9 +107,17 @@ type ResolvedMaterial = {
     occlusionTexture?: ResolvedTexture;
     /** Emissive map, if any. */
     emissiveTexture?: ResolvedTexture;
+    /** OmniPBR_ClearCoat `clearcoat_normalmap_texture` (physical promotion, M20). */
+    clearcoatNormalTexture?: ResolvedTexture;
+};
+type ResolveMaterialOptions = {
+    /** Parsed `.mdl` modules for MDL family detection and value fallback (M20). */
+    mdl?: MdlModuleProvider;
+    /** Receives diagnostics (unknown MDL material families). */
+    onWarn?: (message: string) => void;
 };
 /** Resolve the bound material's flat parameters for `prim`, or `undefined`. */
-declare function resolveBoundMaterial(stage: Stage, prim: Prim): ResolvedMaterial | undefined;
+declare function resolveBoundMaterial(stage: Stage, prim: Prim, options?: ResolveMaterialOptions): ResolvedMaterial | undefined;
 
 /**
  * Loads texture image assets referenced by `UsdShade` materials.
@@ -103,6 +143,8 @@ type TextureOptions = {
     wrapS?: TextureWrap;
     wrapT?: TextureWrap;
     transform?: TextureTransform;
+    /** UV channel index (0 = `uv`, 1 = `uv1`, …) for multi-UV-set meshes. */
+    channel?: number;
 };
 /** Resolve an authored texture asset path to a `THREE.Texture` (or `null`). */
 type TextureProvider = (assetPath: string, options?: TextureOptions) => THREE.Texture | null;
@@ -119,11 +161,11 @@ declare function createTextureProvider(resolver: AssetResolver, baseUrl: string)
  * `Sphere` / `Cylinder` / `Capsule` / `Cone`) — to Three.js geometry and
  * attaches them under the robot's link objects.
  *
- * Meshes are triangulated with a simple fan, use authored per-vertex normals
- * when present (else computed smooth normals), and read `primvars:st` UVs and
- * `primvars:displayColor`. Solids tessellate from their schema attributes.
- * Geometry is left in stage units; the global `metersPerUnit` scale is applied
- * at the root in M9.
+ * Meshes are triangulated with a simple fan. Primvars (`st` UV sets, `normals`,
+ * `displayColor`) resolve with USD interpolation semantics — `:indices`
+ * de-referencing, vertex vs faceVarying (de-indexed) layouts, multiple UV
+ * channels. Solids tessellate from their schema attributes. Geometry is left
+ * in stage units; the global `metersPerUnit` scale is applied at the root in M9.
  */
 
 type MeshKind = "visual" | "collision";
@@ -132,10 +174,23 @@ type BindMeshesOptions = {
     loadCollisions?: boolean;
     /** Resolves diffuse texture asset paths to `THREE.Texture` (M-tex). */
     textureProvider?: TextureProvider;
+    /** Render `BasisCurves` with authored `widths` as tube meshes (M18). */
+    curveTubes?: boolean;
+    /** Receives fidelity diagnostics (channel-packing mismatches, M19). */
+    onWarn?: (message: string) => void;
+    /** Parsed `.mdl` modules for MDL material family/value resolution (M20). */
+    mdl?: MdlModuleProvider;
 };
 /**
  * Build a `BufferGeometry` from a Mesh prim, or `null` if it has no points.
  *
+ * Primvars resolve with full interpolation semantics (M19): `:indices` arrays
+ * are de-referenced, vertex-interpolated `st` sets / `normals` /
+ * `displayColor` bind onto the shared vertices, and any faceVarying primvar
+ * (or per-face color) switches the mesh to a de-indexed layout where every
+ * face corner owns its vertex. Extra UV sets become `uv1`, `uv2`, … in
+ * {@link meshUvSetNames} order.
+ *
  * When the mesh carries `materialBind` face subsets, the triangles are ordered
  * subset by subset and a geometry group is added for each — so the mesh can be
  * drawn with one material per subset (see {@link buildMeshMaterials}). Group
@@ -150,6 +205,28 @@ declare function buildMeshGeometry(meshPrim: Prim): THREE.BufferGeometry | null;
  * section. Returns `null` for unsupported prim types.
  */
 declare function buildGprimGeometry(prim: Prim): THREE.BufferGeometry | null;
+type BuildGprimOptions = {
+    /** Resolves texture asset paths for mesh materials. */
+    textureProvider?: TextureProvider;
+    /**
+     * Render `BasisCurves` that author `widths` as tube meshes instead of
+     * 1-px lines (default `false`).
+     */
+    curveTubes?: boolean;
+    /** Receives fidelity diagnostics (channel-packing mismatches, M19). */
+    onWarn?: (message: string) => void;
+    /** Parsed `.mdl` modules for MDL material family/value resolution (M20). */
+    mdl?: MdlModuleProvider;
+};
+/**
+ * Build a renderable `THREE.Object3D` for any supported gprim (M18):
+ * `Mesh` and the parametric solids become a `THREE.Mesh` (via
+ * {@link buildGprimGeometry} + {@link buildMeshMaterials}), `Points` a
+ * `THREE.Points`, and `BasisCurves` a `THREE.Group` holding one line — or,
+ * with {@link BuildGprimOptions.curveTubes}, one tube mesh — per curve.
+ * Returns `null` for unsupported prim types and degenerate geometry.
+ */
+declare function buildGprimObject(prim: Prim, stage?: Stage, options?: BuildGprimOptions): THREE.Object3D | null;
 /**
  * Build a material for a gprim. Color priority: bound `UsdShade` material
  * (when `stage` is given) → `primvars:displayColor` → default gray. Textures
@@ -160,7 +237,11 @@ declare function buildGprimGeometry(prim: Prim): THREE.BufferGeometry | null;
  */
 declare function buildMeshMaterial(meshPrim: Prim, stage?: Stage, textures?: TextureProvider, 
 /** Resolve the material binding from here instead (a `GeomSubset`). */
-bindingPrim?: Prim): THREE.Material;
+bindingPrim?: Prim, 
+/** Receives fidelity diagnostics (channel-packing mismatches, M19). */
+onWarn?: (message: string) => void, 
+/** Parsed `.mdl` modules for MDL material family/value resolution (M20). */
+mdl?: MdlModuleProvider): THREE.Material;
 /**
  * Attach visual (and optionally collision) meshes to every link of a built
  * {@link ThreeUsdRobot}. Each mesh is positioned by its transform relative to
@@ -178,6 +259,9 @@ declare function bindRobotMeshes(stage: Stage, robot3d: ThreeUsdRobot, desc: Rob
  */
 declare function bindSceneMeshes(stage: Stage, robot3d: ThreeUsdRobot, desc: RobotDescription, options?: {
     textureProvider?: TextureProvider;
+    curveTubes?: boolean;
+    onWarn?: (message: string) => void;
+    mdl?: MdlModuleProvider;
 }): number;
 
 /**
@@ -313,4 +397,4 @@ type ExportThreeUsdRobotOptions = Omit<ExportRobotOptions, "geometry"> & {
 /** Export a loaded robot back to a USDA AST (pass the result to `serializeUsda`). */
 declare function exportThreeUsdRobot(robot: ThreeUsdRobot, options?: ExportThreeUsdRobotOptions): UsdaFile;
 
-export { type AddJointOptions, type AddLinkOptions, AssetResolver, Axis, type BindMeshesOptions, CollisionApproximation, ExportMaterial, ExportMesh, ExportPhysicsMaterial, ExportRobotOptions, type ExportThreeUsdRobotOptions, type GeometryToExportMeshOptions, JointDriveDescription, KinematicTree, LinkInertialDescription, Mat4, type MeshKind, Prim, type ResolvedMaterial, type ResolvedTexture, RobotBuilder, type RobotBuilderOptions, RobotDescription, RobotGeometryProvider, Stage, type TextureColorSpace, type TextureOptions, type TextureProvider, type TextureTransform, type TextureWrap, ThreeUsdRobot, UsdaFile, Vec2, Vec3, type WorldFrame, axisVector, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildMeshGeometry, buildMeshMaterial, createTextureProvider, exportThreeUsdRobot, geometryToExportMesh, materialToExportMaterial, resolveBoundMaterial, threeGeometryProvider };
+export { type AddJointOptions, type AddLinkOptions, AssetResolver, Axis, type BindMeshesOptions, type BuildGprimOptions, CollisionApproximation, ExportMaterial, ExportMesh, ExportPhysicsMaterial, ExportRobotOptions, type ExportThreeUsdRobotOptions, type GeometryToExportMeshOptions, JointDriveDescription, KinematicTree, LinkInertialDescription, Mat4, MdlModuleProvider, type MeshKind, Prim, type ResolveMaterialOptions, type ResolvedMaterial, type ResolvedTexture, RobotBuilder, type RobotBuilderOptions, RobotDescription, RobotGeometryProvider, Stage, type TextureColorSpace, type TextureOptions, type TextureProvider, type TextureTransform, type TextureWrap, ThreeUsdRobot, UsdaFile, Vec2, Vec3, type WorldFrame, axisVector, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildGprimObject, buildMeshGeometry, buildMeshMaterial, createTextureProvider, exportThreeUsdRobot, geometryToExportMesh, materialToExportMaterial, resolveBoundMaterial, threeGeometryProvider };

package/dist/index.js

@@ -1,11 +1,11 @@
-import { stageGeometryProvider, exportRobotUsda } from './chunk-TE4MPP5Q.js';
-export { PACKAGE_NAME, VERSION, exportRobotUsda, stageGeometryProvider, validateRobotDescription, writeUsdz } from './chunk-TE4MPP5Q.js';
-export { ThreeUsdRobotLoader, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildMeshGeometry, buildMeshMaterial, createTextureProvider } from './chunk-XEXFGL7R.js';
-import { refineJointType, buildKinematicTree } from './chunk-2UD32EGU.js';
-export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isMesh, isRenderableGprim, isScope, isSolidGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize } from './chunk-2UD32EGU.js';
-export { JointObject, LinkObject, ThreeUsdRobot, axisVector } from './chunk-WROYLUSS.js';
-import { identity4, multiply, invert } from './chunk-IYKPVUZ2.js';
-export { AssetPath, DEG2RAD, Quat, RAD2DEG, UsdMatrix, channelFromSamples, decomposeRigid, fromUsdMatrix, getTranslation, identity4, interpolate, invert, makeEuler, makeRotationFromQuat, makeRotationX, makeRotationY, makeRotationZ, makeScale, makeTranslation, multiply, multiplyAll, toUsdMatrix } from './chunk-IYKPVUZ2.js';
+import { stageGeometryProvider, exportRobotUsda } from './chunk-BCRRXGNB.js';
+export { PACKAGE_NAME, VERSION, exportRobotUsda, stageGeometryProvider, validateRobotDescription, writeUsdz } from './chunk-BCRRXGNB.js';
+export { ThreeUsdRobotLoader, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildGprimObject, buildMeshGeometry, buildMeshMaterial, createTextureProvider } from './chunk-5SVRTKS4.js';
+import { refineJointType, buildKinematicTree } from './chunk-AXPMXEQC.js';
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, collectMdlAssetPaths, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMdlTexture, isMesh, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, loadMdlModules, normalizeJointLimits, openUsdz, parseMdl, parseMdlLiteral, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize } from './chunk-AXPMXEQC.js';
+export { JointObject, LinkObject, ThreeUsdRobot, axisVector } from './chunk-ENWFOYHU.js';
+import { identity4, multiply, invert } from './chunk-LDO5FKQS.js';
+export { AssetPath, DEG2RAD, Quat, RAD2DEG, UsdMatrix, channelFromSamples, decomposeJointRelative, decomposeRigid, fromUsdMatrix, getTranslation, identity4, interpolate, invert, makeEuler, makeRotationFromQuat, makeRotationX, makeRotationY, makeRotationZ, makeScale, makeTranslation, multiply, multiplyAll, nearestAngleBranch, toUsdMatrix } from './chunk-LDO5FKQS.js';
 import * as THREE from 'three';
 
 function geometryToExportMesh(geometry, options) {

package/dist/react.d.ts

@@ -1,10 +1,10 @@
 import * as _react_three_fiber from '@react-three/fiber';
 import { ThreeElements } from '@react-three/fiber';
 import * as React from 'react';
-import { T as ThreeUsdRobot } from './ThreeUsdRobot-BAh-48DD.js';
-import { T as ThreeUsdRobotLoaderOptions } from './ThreeUsdRobotLoader-DYtvelif.js';
+import { T as ThreeUsdRobot } from './ThreeUsdRobot-BxnCluuK.js';
+import { T as ThreeUsdRobotLoaderOptions } from './ThreeUsdRobotLoader-C-E9uwEe.js';
 import 'three';
-import './buildKinematicTree-DQ4Vr4sJ.js';
+import './buildKinematicTree-BCySuZZn.js';
 import './bytes-MOJ2oN-u.js';
 
 /**

package/dist/react.js

@@ -1,7 +1,7 @@
-import { ThreeUsdRobotLoader } from './chunk-XEXFGL7R.js';
-import './chunk-2UD32EGU.js';
-import './chunk-WROYLUSS.js';
-import './chunk-IYKPVUZ2.js';
+import { ThreeUsdRobotLoader } from './chunk-5SVRTKS4.js';
+import './chunk-AXPMXEQC.js';
+import './chunk-ENWFOYHU.js';
+import './chunk-LDO5FKQS.js';
 import { useFrame } from '@react-three/fiber';
 import * as React from 'react';
 import { jsx } from 'react/jsx-runtime';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-usd-robot",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Kinematic OpenUSD robot loader for Three.js — load Isaac Sim / OpenUSD robot assets, extract joints and links, and control articulations in the browser.",
   "type": "module",
   "license": "MIT",

package/dist/ThreeUsdRobot-BAh-48DD.d.ts

@@ -1,185 +0,0 @@
-import * as THREE from 'three';
-import { J as JointType, A as Axis, a as JointDescription, L as LinkDescription, R as RobotDescription, K as KinematicTree, S as Stage } from './buildKinematicTree-DQ4Vr4sJ.js';
-
-/**
- * The articulated "motion" node of a joint, inserted between the joint's two
- * fixed frames (`jointFrame0` and `inverse(jointFrame1)`). {@link setValue}
- * rotates it about the axis (revolute/continuous) or slides it along the axis
- * (prismatic); fixed joints are inert.
- */
-declare class JointObject extends THREE.Object3D {
-    readonly isJointObject = true;
-    readonly jointName: string;
-    /** Full USD prim path of the joint — the collision-proof address. */
-    readonly primPath: string;
-    readonly jointType: JointType;
-    readonly axisToken: Axis;
-    readonly axis: THREE.Vector3;
-    readonly lower: number | undefined;
-    readonly upper: number | undefined;
-    private _value;
-    constructor(joint: JointDescription);
-    get value(): number;
-    get articulated(): boolean;
-    /**
-     * Set the joint value (radians for revolute/continuous, length for prismatic).
-     * Optionally clamps to authored limits. Returns the value actually applied.
-     */
-    setValue(value: number, clampToLimits?: boolean): number;
-}
-
-/**
- * Three.js node for a robot link. Its frame is the USD link prim's frame;
- * visual/collision meshes (M6) attach as children relative to it. Placement
- * relative to the parent is supplied by the joint chain, so a link's own local
- * matrix is identity (except the root, which carries the world-fixed placement).
- */
-declare class LinkObject extends THREE.Object3D {
-    readonly isLinkObject = true;
-    readonly linkName: string;
-    readonly primPath: string;
-    constructor(link: LinkDescription);
-}
-
-/** Target world up-axis: normalize to Y-up / Z-up, or keep the authored orientation. */
-type WorldUpAxis = "Y" | "Z" | "keep";
-type ThreeUsdRobotOptions = {
-    /** Clamp `setJointValue` to authored limits (default `true`). */
-    clampJointLimits?: boolean;
-    /** Size of the built-in joint-axis / link-frame helpers (stage units, default `0.15`). */
-    helperSize?: number;
-    /**
-     * Target world up-axis. The root is rotated so the stage's authored `upAxis`
-     * lands in that convention: `"Y"` for a standard three.js scene, `"Z"` for a
-     * robotics-style Z-up world, `"keep"` for no correction. Takes precedence
-     * over the deprecated {@link ThreeUsdRobotOptions.upAxisConversion}.
-     */
-    worldUp?: WorldUpAxis;
-    /**
-     * Legacy up-axis correction: `"auto"` ≡ `worldUp: "Y"`, `"Y"` / `"none"` ≡
-     * `worldUp: "keep"`, and `"Z"` forces the Z-up→Y-up rotation regardless of
-     * stage metadata. Default `"none"` (the loader defaults to `"auto"`).
-     * @deprecated Use {@link ThreeUsdRobotOptions.worldUp}.
-     */
-    upAxisConversion?: "auto" | "Y" | "Z" | "none";
-    /** Extra uniform scale multiplied with the stage `metersPerUnit` (default `1`). */
-    unitScale?: number;
-    /** Seed joints from their authored initial value (drive target / joint state). Default `true`. */
-    applyInitialPose?: boolean;
-};
-/**
- * A Three.js `Object3D` that realizes a {@link RobotDescription} as a kinematic
- * hierarchy and drives forward kinematics via {@link setJointValue}.
- *
- * Per joint the hierarchy is
- * `parentLink → jointFrame0 → jointMotion → jointFrame1⁻¹ → childLink`,
- * where only `jointMotion` (a {@link JointObject}) changes with the joint value;
- * world poses then fall out of Three.js's `updateMatrixWorld`.
- *
- * **Naming contract** — a link/joint's key is its prim's leaf name when that
- * is unique across the robot, else its full prim path (deterministic; see the
- * extractor). Every accessor taking a name equally accepts the full prim path,
- * which is stable regardless of collisions; {@link getLinkObjectsByPath} /
- * {@link getJointObjectsByPath} enumerate the path-keyed tables.
- */
-declare class ThreeUsdRobot extends THREE.Object3D {
-    readonly isThreeUsdRobot = true;
-    readonly robot: RobotDescription;
-    readonly tree: KinematicTree;
-    readonly clampJointLimits: boolean;
-    /**
-     * The composed USD stage this robot was built from — the full prim tree, for
-     * inspection tooling (structure panels, attribute browsers). Attached by
-     * {@link ThreeUsdRobotLoader}; `undefined` for programmatically-built robots.
-     */
-    stage?: Stage;
-    private readonly linkObjects;
-    private readonly jointObjects;
-    private readonly linkKeyByPath;
-    private readonly jointKeyByPath;
-    private dirty;
-    private readonly helperSize;
-    private _showVisual;
-    private _showCollision;
-    private _showJointAxes;
-    private _showLinkFrames;
-    private jointAxesHelpers;
-    private linkFrameHelpers;
-    constructor(robot: RobotDescription, tree: KinematicTree, options?: ThreeUsdRobotOptions);
-    /** Orient (authored upAxis → target world up) and scale (metersPerUnit × unitScale) the root. */
-    private applyStageNormalization;
-    /** Apply each joint's authored initial value, if any. */
-    private applyInitialPose;
-    private attachRoot;
-    private attachTreeEdges;
-    /** Build `parent → frame0 → motion → frame1⁻¹ → child` for one joint. */
-    private attachJointChain;
-    private attachIsolatedLinks;
-    /** Resolve a link reference — key or full prim path — to the extractor key. */
-    private linkKey;
-    /** Resolve a joint reference — key or full prim path — to the extractor key. */
-    private jointKey;
-    /**
-     * Set one joint value, addressed by key or full prim path. Unknown joints
-     * are ignored. Returns whether it applied.
-     */
-    setJointValue(name: string, value: number): boolean;
-    /** Set several joint values at once (matrix update is coalesced). */
-    setJointValues(values: Record<string, number>): void;
-    getJointValue(name: string): number | undefined;
-    /** Recompute world matrices. Called lazily by the getters; safe to call directly. */
-    updateKinematics(): void;
-    private ensureUpdated;
-    /** World matrix of a link, addressed by key or full prim path. */
-    getLinkWorldMatrix(name: string): THREE.Matrix4;
-    getLinkWorldPosition(name: string): THREE.Vector3;
-    /** Link object by key or full prim path. */
-    getLinkObject(name: string): LinkObject | undefined;
-    /** Joint object by key or full prim path. */
-    getJointObject(name: string): JointObject | undefined;
-    /**
-     * Table of link prim path → {@link LinkObject}. Prim paths are the
-     * collision-proof way to pin a link (e.g. to attach tools or gizmos).
-     */
-    getLinkObjectsByPath(): Map<string, LinkObject>;
-    /**
-     * Table of joint prim path → {@link JointObject}, covering the joints
-     * realized in the kinematic tree (loop joints have no motion node).
-     */
-    getJointObjectsByPath(): Map<string, JointObject>;
-    getJoints(): JointDescription[];
-    getLinks(): LinkDescription[];
-    /** Names of the articulated (controllable) joints. */
-    getJointNames(): string[];
-    getLinkNames(): string[];
-    getKinematicTree(): KinematicTree;
-    /** Authored stage up-axis (`"Y"` or `"Z"`) — unaffected by `worldUp` normalization. */
-    get upAxis(): "Y" | "Z";
-    /** Authored stage scale in meters per unit (already applied to the root). */
-    get metersPerUnit(): number;
-    /** Playback rate in time codes per second (from the stage; default 24). */
-    getTimeCodesPerSecond(): number;
-    /** Whether any joint has a time-sampled trajectory. */
-    hasAnimation(): boolean;
-    /**
-     * Animation range in time codes: the union of authored joint sample ranges,
-     * falling back to the stage `startTimeCode`/`endTimeCode`. `null` if neither.
-     */
-    getTimeRange(): {
-        start: number;
-        end: number;
-    } | null;
-    /** Sample every animated joint at time code `t` and apply the values. */
-    setTime(t: number): void;
-    get showVisual(): boolean;
-    set showVisual(v: boolean);
-    get showCollision(): boolean;
-    set showCollision(v: boolean);
-    get showJointAxes(): boolean;
-    set showJointAxes(v: boolean);
-    get showLinkFrames(): boolean;
-    set showLinkFrames(v: boolean);
-    private setKindVisibility;
-}
-
-export { JointObject as J, LinkObject as L, ThreeUsdRobot as T, type WorldUpAxis as W, type ThreeUsdRobotOptions as a };