three-usd-robot 0.11.0 → 0.12.0

package/README.md

@@ -27,7 +27,7 @@ exported back to `.usda` / `.usdz` in the browser.
   `Capsule` / `Cone`), point clouds (`Points`) and curves (`BasisCurves`:
   linear / bezier / bspline / catmullRom, periodic wrap, and an opt-in
   `curveTubes` mode that turns authored widths into tube meshes) with
-  `UsdShade` materials (UsdPreviewSurface / Omniverse MDL) and textures; up-axis
+  `UsdShade` materials (UsdPreviewSurface / Omniverse MDL / MaterialX) and textures; up-axis
   and units normalized automatically. Articulation-free stages load as
   static scenes.
 - **Animation** — plays back time-sampled joint trajectories, and replays
@@ -55,7 +55,7 @@ The CDN is public and CORS-enabled, so this works in the browser too. Try
 FK check, and a re-export to one self-contained file), or open the Vite example
 and pick a robot from the preset list.
 
-Materials target **UsdPreviewSurface fidelity plus an Omniverse MDL mapping**:
+Materials target **UsdPreviewSurface fidelity plus Omniverse MDL and MaterialX mappings**:
 constant and textured inputs, faceVarying / indexed UVs, multiple UV sets,
 per-vertex display colors, physical extensions (`ior` / `clearcoat` /
 specular workflow → `MeshPhysicalMaterial`), packed ORM maps,
@@ -74,11 +74,51 @@ wrapper arguments > declaration defaults.
 | `OmniGlass` | `MeshPhysicalMaterial` with `transmission` / `ior` (default 1.491) / `roughness` / `thickness`, glass color + texture |
 | `OmniSurface(Lite)` | constants subset: diffuse color / metalness / roughness / IOR / coat / emission / opacity |
 
-Executing MDL or MaterialX shader graphs is out of scope; unknown MDL
-materials fall back to the OmniPBR mapping with a warning. Not yet
-supported: collection-based material bindings, and the exotic curve schemas
-(`NurbsCurves`, `HermiteCurves`, `NurbsPatch`) which load with a warning and
-are skipped.
+MaterialX networks authored natively in UsdShade (`outputs:mtlx:surface` +
+`ND_*` shaders) resolve the same way — by parameter mapping, without graph
+execution. `ND_standard_surface_surfaceshader` maps `base × base_color` /
+`metalness` / `specular_roughness` / `specular_IOR` / `coat(_roughness)` /
+`transmission` / `emission (× emission_color)` / `opacity` / `normal` onto
+the standard (or, when coat / transmission / IOR are authored, physical)
+three material; the `ND_Usd*` compatibility nodes delegate to the
+UsdPreviewSurface readers. Image and UV nodes are supported
+(`ND_image_*` address modes, `ND_tiledimage_*` uvtiling/uvoffset,
+`ND_texcoord_*` UV-channel index, `ND_geompropvalue_*` primvar name,
+`ND_normalmap`), and constant-only `ND_multiply_* / ND_mix_* / ND_convert_*`
+(plus `ND_constant_*` / `ND_dot_*`) fold into values. Anything that needs
+real evaluation (noise, ramps, …) skips just that channel with a warning —
+the rest of the material still renders — unless you opt into the TSL entry
+below. External `.mtlx` file references (UsdMtlx) are not parsed; load them
+with `loadMaterialXDocument` (a thin wrapper over three's official
+`MaterialXLoader`) from `three-usd-robot/nodes`.
+
+**Executing MaterialX graphs (optional, WebGPU)** — the separate
+`three-usd-robot/nodes` entry converts `ND_*` graphs (noise, ramps, math,
+images, procedural UV warps — a ~45-node practical subset) into three.js TSL
+`MeshPhysicalNodeMaterial`s and plugs in through the loader's
+`materialFactory` hook:
+
+```ts
+import { ThreeUsdRobotLoader } from "three-usd-robot";
+import { createMaterialXNodeFactory } from "three-usd-robot/nodes";
+
+const loader = new ThreeUsdRobotLoader({
+  materialFactory: createMaterialXNodeFactory({ onWarn: console.warn }),
+});
+```
+
+Requires `WebGPURenderer` (it falls back to WebGL2 internally). Graphs with
+nodes outside the conversion table fall back to the parameter mapping with a
+warning, and the WebGL core bundles never import `three/webgpu` / `three/tsl`
+(verified at build time). See `examples/vite-webgpu-nodes` for a procedural
+marble / worley / lava demo.
+
+Executing MDL remains out of scope (a language, not a graph — it would need
+an MDL SDK-class compiler); unknown MDL materials fall back to the OmniPBR
+mapping (and unknown `ND_*` surface shaders to the UsdPreviewSurface reads)
+with a warning. Not yet supported: collection-based material bindings, and
+the exotic curve schemas (`NurbsCurves`, `HermiteCurves`, `NurbsPatch`)
+which load with a warning and are skipped.
 
 ## Install
 
@@ -390,6 +430,7 @@ and builds the deployable site.
 | `three-usd-robot/core` | Three.js-independent USD parser & writer, robot IR, forward-kinematics math |
 | `three-usd-robot/helpers` | Viewer helpers (joint axes, link frames, joint limits) |
 | `three-usd-robot/extras` | Joint slider panel (bring your own `lil-gui`) |
+| `three-usd-robot/nodes` | Optional MaterialX → TSL execution (`three/webgpu`) — `createMaterialXNodeFactory`, `loadMaterialXDocument` |
 | `three-usd-robot/react` | React Three Fiber `<UsdRobot>` component + hooks |
 
 ## Development

package/dist/MeshBinding-DQKXuYNr.d.ts

@@ -0,0 +1,288 @@
+import * as THREE from 'three';
+import { x as Vec2, y as Vec3, S as Stage, P as Prim, R as RobotDescription } from './buildKinematicTree-iFqaw0Jl.js';
+import { b as MdlModuleProvider, A as AssetResolver } from './parseMdl-vfzBGoMr.js';
+import { T as ThreeUsdRobot } from './ThreeUsdRobot-C3N6-XBJ.js';
+
+/**
+ * Resolves `UsdShade` material bindings to flat PBR parameters.
+ *
+ * Follows a prim's (or an ancestor's) `material:binding` to a `Material`, finds
+ * its surface `Shader`, and reads constant color/metalness/roughness/opacity/
+ * 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 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.
+ *
+ * MaterialX networks authored natively in UsdShade (M21) resolve here too:
+ * `ND_standard_surface_surfaceshader` has a dedicated reader (see
+ * `MaterialXBinding.ts`), while the `ND_Usd*` compatibility nodes share
+ * `UsdPreviewSurface` input names and reuse the generic reads.
+ */
+
+/** `UsdUVTexture` wrap mode for one axis (`black` ≈ clamp; three has no border). */
+type TextureWrap = "repeat" | "clamp" | "mirror" | "black";
+/** `UsdTransform2d` applied to the `st` coords feeding a texture. */
+type TextureTransform = {
+    /** `inputs:translation` (UV offset). */
+    translation?: Vec2;
+    /** `inputs:rotation` in degrees (CCW about the origin). */
+    rotation?: number;
+    /** `inputs:scale` (UV tiling). */
+    scale?: Vec2;
+};
+/** A resolved texture reference plus its `UsdUVTexture` sampler/transform state. */
+type ResolvedTexture = {
+    /** Authored asset path of the image. */
+    path: string;
+    wrapS?: TextureWrap;
+    wrapT?: TextureWrap;
+    /** `UsdTransform2d` on the `st` input, if any. */
+    transform?: TextureTransform;
+    /** `inputs:scale` — multiplies the sampled value (folded into material factors). */
+    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;
+    /**
+     * Direct UV channel index (MaterialX `ND_texcoord_*.inputs:index`, M21).
+     * Beats `uvSet`; channel N is the mesh's N-th UV set in `meshUvSetNames`
+     * order (`st` first, extras sorted).
+     */
+    uvChannel?: number;
+    /** `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. */
+    name?: string;
+    color?: Vec3;
+    opacity?: number;
+    metalness?: number;
+    roughness?: number;
+    emissiveColor?: Vec3;
+    /**
+     * `inputs:opacityThreshold`. When `> 0`, opacity is a binary mask (alpha
+     * 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`). */
+    opacityTexture?: ResolvedTexture;
+    /** Tangent-space normal map, if any. */
+    normalTexture?: ResolvedTexture;
+    /** Roughness map, if any. */
+    roughnessTexture?: ResolvedTexture;
+    /** Metallic map, if any. */
+    metalnessTexture?: ResolvedTexture;
+    /** Ambient-occlusion map, if any. */
+    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, options?: ResolveMaterialOptions): ResolvedMaterial | undefined;
+/**
+ * The `Shader` prim driving `prim`'s bound material surface, or `undefined`.
+ * Follows the same binding/surface-output resolution as
+ * {@link resolveBoundMaterial} — exposed for custom material factories (M22)
+ * that need the raw shader network rather than the flattened parameters.
+ */
+declare function findBoundSurfaceShader(stage: Stage, prim: Prim): Prim | undefined;
+
+/**
+ * Loads texture image assets referenced by `UsdShade` materials.
+ *
+ * A {@link TextureProvider} maps an authored asset path (plus sampler/transform
+ * options) to a `THREE.Texture`. The default provider fetches the image **bytes**
+ * through the {@link AssetResolver} and decodes them via a blob URL — so it works
+ * uniformly for textures served over HTTP and for images embedded inside a
+ * `.usdz` package (whose resolver serves zip entries, not real URLs). Decoded
+ * images are cached per resolved URL and shared across every texture that uses
+ * them; each `THREE.Texture` carries its own color space / wrap / transform.
+ */
+
+/**
+ * Color space to interpret a texture in. Color/albedo and emissive maps are
+ * `"srgb"`; data maps (normal, roughness, metalness, occlusion) are `"linear"`.
+ */
+type TextureColorSpace = "srgb" | "linear";
+/** Per-use sampler state applied to the returned `THREE.Texture`. */
+type TextureOptions = {
+    /** Defaults to `"srgb"`. */
+    colorSpace?: TextureColorSpace;
+    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;
+/**
+ * A {@link TextureProvider} backed by the {@link AssetResolver}, resolving paths
+ * against `baseUrl`. Image bytes are fetched once per URL (works for HTTP and
+ * `.usdz` entries alike) and the decoded image is shared; each call returns a
+ * distinct `THREE.Texture` carrying the requested color space / wrap / transform.
+ */
+declare function createTextureProvider(resolver: AssetResolver, baseUrl: string): TextureProvider;
+
+/**
+ * Binds renderable gprims — `UsdGeom.Mesh` plus the parametric solids (`Cube` /
+ * `Sphere` / `Cylinder` / `Capsule` / `Cone`) — to Three.js geometry and
+ * attaches them under the robot's link objects.
+ *
+ * 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";
+/**
+ * Replaces material creation for mesh-like gprims (`Mesh` and the parametric
+ * solids). Return `null` to fall back to the default `UsdShade` resolution —
+ * the hook that lets the optional `three-usd-robot/nodes` entry build TSL
+ * `NodeMaterial`s without the core depending on `three/webgpu` (M22).
+ */
+type MaterialFactory = (prim: Prim, stage: Stage) => THREE.Material | null;
+type BindMeshesOptions = {
+    loadVisuals?: boolean;
+    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;
+    /** Overrides material creation for mesh-like gprims (M22). */
+    materialFactory?: MaterialFactory;
+};
+/**
+ * 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
+ * order matches {@link getMaterialSubsets}, with any unassigned faces last.
+ */
+declare function buildMeshGeometry(meshPrim: Prim): THREE.BufferGeometry | null;
+/**
+ * Build geometry for any renderable gprim: `Mesh` via {@link buildMeshGeometry},
+ * parametric solids from their schema attributes. Solids follow UsdGeom
+ * semantics — sizes in stage units, centered at the origin, `axis` (default
+ * `"Z"`) along the spine, and a capsule's `height` spans only its cylindrical
+ * 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;
+    /** Overrides material creation for mesh-like gprims (M22). */
+    materialFactory?: MaterialFactory;
+};
+/**
+ * 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
+ * (via `textures`) become the matching `MeshStandardMaterial` maps — diffuse →
+ * `map` (sRGB), plus `normalMap` / `roughnessMap` / `metalnessMap` / `aoMap`
+ * (linear data) and emissive `emissiveMap`. Metalness / roughness / opacity /
+ * emissive constants come from the bound material when present.
+ */
+declare function buildMeshMaterial(meshPrim: Prim, stage?: Stage, textures?: TextureProvider, 
+/** Resolve the material binding from here instead (a `GeomSubset`). */
+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
+ * the owning link prim.
+ */
+declare function bindRobotMeshes(stage: Stage, robot3d: ThreeUsdRobot, desc: RobotDescription, options?: BindMeshesOptions): void;
+/**
+ * Attach the gprims that belong to no link — the static scenery of a cell that
+ * also contains robots. The authored prim hierarchy is mirrored with
+ * `THREE.Group` nodes (each carrying `userData.primPath` and its prim's local
+ * transform), so grouped scenery — a pallet and its cartons, a fence and its
+ * wires — stays one movable subtree. World placements are unchanged, and the
+ * loader's up-axis and unit normalization still applies at the robot root.
+ * Collision-only and guide/proxy prims are skipped.
+ */
+declare function bindSceneMeshes(stage: Stage, robot3d: ThreeUsdRobot, desc: RobotDescription, options?: {
+    textureProvider?: TextureProvider;
+    curveTubes?: boolean;
+    onWarn?: (message: string) => void;
+    mdl?: MdlModuleProvider;
+    materialFactory?: MaterialFactory;
+}): number;
+
+export { type BindMeshesOptions as B, type MaterialFactory as M, type ResolveMaterialOptions as R, type TextureProvider as T, type BuildGprimOptions as a, type MeshKind as b, type ResolvedMaterial as c, type ResolvedTexture as d, type TextureColorSpace as e, type TextureOptions as f, type TextureTransform as g, type TextureWrap as h, bindRobotMeshes as i, bindSceneMeshes as j, buildGprimGeometry as k, buildGprimObject as l, buildMeshGeometry as m, buildMeshMaterial as n, createTextureProvider as o, findBoundSurfaceShader as p, resolveBoundMaterial as r };

package/dist/{ThreeUsdRobot-BxnCluuK.d.ts → ThreeUsdRobot-C3N6-XBJ.d.ts}

@@ -1,5 +1,5 @@
 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-BCySuZZn.js';
+import { f as JointType, A as Axis, e as JointDescription, i as LinkDescription, R as RobotDescription, K as KinematicTree, S as Stage } from './buildKinematicTree-iFqaw0Jl.js';
 
 /**
  * The articulated "motion" node of a joint, inserted between the joint's two

package/dist/{ThreeUsdRobotLoader-C-E9uwEe.d.ts → ThreeUsdRobotLoader-D2fEo9_p.d.ts}

@@ -1,6 +1,8 @@
-import { R as RobotDescription } from './buildKinematicTree-BCySuZZn.js';
-import { A as AssetResolver, U as UsdSource, B as BinarySource } from './bytes-MOJ2oN-u.js';
-import { W as WorldUpAxis, a as ThreeUsdRobotOptions, T as ThreeUsdRobot } from './ThreeUsdRobot-BxnCluuK.js';
+import { R as RobotDescription } from './buildKinematicTree-iFqaw0Jl.js';
+import { A as AssetResolver } from './parseMdl-vfzBGoMr.js';
+import { U as UsdSource, B as BinarySource } from './bytes-CxGRGry_.js';
+import { M as MaterialFactory } from './MeshBinding-DQKXuYNr.js';
+import { W as WorldUpAxis, a as ThreeUsdRobotOptions, T as ThreeUsdRobot } from './ThreeUsdRobot-C3N6-XBJ.js';
 
 type ThreeUsdRobotLoaderOptions = {
     /** Resolver for references / payloads / sublayers (default {@link DefaultAssetResolver}). */
@@ -51,6 +53,12 @@ type ThreeUsdRobotLoaderOptions = {
     robotName?: string;
     /** Receives non-fatal load diagnostics. */
     onWarn?: (message: string) => void;
+    /**
+     * Overrides material creation for mesh-like gprims (M22) — e.g. the TSL
+     * MaterialX factory from `three-usd-robot/nodes`. Return `null` per prim to
+     * keep the default `UsdShade` resolution.
+     */
+    materialFactory?: MaterialFactory;
 };
 /**
  * Loads Isaac Sim / OpenUSD robot assets into a controllable {@link ThreeUsdRobot}.

package/dist/{buildKinematicTree-BCySuZZn.d.ts → buildKinematicTree-iFqaw0Jl.d.ts}

@@ -528,4 +528,4 @@ type BuildTreeOptions = {
 };
 declare function buildKinematicTree(robot: RobotDescription, options?: BuildTreeOptions): KinematicTree;
 
-export { makeRotationZ as $, type Axis as A, type BuildTreeOptions as B, type CompositionArc as C, DEFAULT_METERS_PER_UNIT as D, buildKinematicTree as E, channelFromSamples as F, decomposeRigid as G, fromUsdMatrix as H, getTranslation as I, type JointType as J, type KinematicTree as K, type LinkDescription as L, type Mat4 as M, identity4 as N, interpolate as O, Prim as P, Quat as Q, type RobotDescription as R, Stage as S, type TreeEdge as T, type UsdaFile as U, type Vec2 as V, invert as W, makeEuler as X, makeRotationFromQuat as Y, makeRotationX as Z, makeRotationY as _, type JointDescription as a, makeScale as a0, makeTranslation as a1, multiply as a2, multiplyAll as a3, toUsdMatrix as a4, type Vec3 as b, type JointDriveDescription as c, type LinkInertialDescription as d, AssetPath as e, Attribute as f, type AttributeSpec as g, DEG2RAD as h, type KinematicNode as i, Layer as j, type ListOp as k, type MetadataMap as l, type PrimSpec as m, type PropertySpec as n, RAD2DEG as o, Relationship as p, type RelationshipSpec as q, type SampleChannel as r, type SdfPath as s, type Specifier as t, type UpAxis as u, type UsdDictionary as v, UsdMatrix as w, type UsdValue as x, type Variability as y, type Vec4 as z };
+export { makeRotationZ as $, type Axis as A, type BuildTreeOptions as B, type CompositionArc as C, DEFAULT_METERS_PER_UNIT as D, buildKinematicTree as E, channelFromSamples as F, decomposeRigid as G, fromUsdMatrix as H, getTranslation as I, type JointDriveDescription as J, type KinematicTree as K, type LinkInertialDescription as L, type Mat4 as M, identity4 as N, interpolate as O, Prim as P, Quat as Q, type RobotDescription as R, Stage as S, type TreeEdge as T, type UsdaFile as U, type Variability as V, invert as W, makeEuler as X, makeRotationFromQuat as Y, makeRotationX as Z, makeRotationY as _, AssetPath as a, makeScale as a0, makeTranslation as a1, multiply as a2, multiplyAll as a3, toUsdMatrix as a4, Attribute as b, type AttributeSpec as c, DEG2RAD as d, type JointDescription as e, type JointType as f, type KinematicNode as g, Layer as h, type LinkDescription as i, type ListOp as j, type MetadataMap as k, type PrimSpec as l, type PropertySpec as m, RAD2DEG as n, Relationship as o, type RelationshipSpec as p, type SampleChannel as q, type SdfPath as r, type Specifier as s, type UpAxis as t, type UsdDictionary as u, UsdMatrix as v, type UsdValue as w, type Vec2 as x, type Vec3 as y, type Vec4 as z };

package/dist/bytes-CxGRGry_.d.ts

@@ -0,0 +1,14 @@
+/**
+ * In-memory input normalization for the loader entry points. Callers hold USD
+ * content in many shapes — a `fetch` response's `ArrayBuffer`, a `Uint8Array`
+ * (or any typed-array view), a dropped `File` / `Blob` — and every byte-eating
+ * API here funnels through {@link toBytes} so all of them are accepted.
+ */
+/** Binary USD content: an `ArrayBuffer`, any typed-array view, or a `Blob`/`File`. */
+type BinarySource = ArrayBuffer | ArrayBufferView | Blob;
+/** In-memory USD content: USDA source text, or {@link BinarySource} bytes. */
+type UsdSource = string | BinarySource;
+/** Normalize a {@link BinarySource} to bytes, honoring a view's offset/length. */
+declare function toBytes(data: BinarySource): Promise<Uint8Array>;
+
+export { type BinarySource as B, type UsdSource as U, toBytes as t };