three-usd-robot 0.13.0 → 0.14.0

package/dist/{chunk-FUVHAORT.js → chunk-KRT4NL3H.js}

@@ -1,6 +1,7 @@
-import { multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, RAD2DEG } from './chunk-YGJ23CG3.js';
 import { parseMdl, joinPosix } from './chunk-PPPRB6KE.js';
-import { Quat, AssetPath, UsdMatrix } from './chunk-JGIVJXBU.js';
+import { computeWorldTransform } from './chunk-ZQXYVBQI.js';
+import { multiply, makeTranslation, makeRotationFromQuat, DEG2RAD, RAD2DEG } from './chunk-IAOPNN6V.js';
+import { AssetPath, Quat, UsdMatrix } from './chunk-JGIVJXBU.js';
 import { unzipSync } from 'fflate';
 
 // src/schemas/usdGeom.ts
@@ -87,6 +88,137 @@ function gatherGprimDescendants(prim) {
   return paths;
 }
 
+// src/schemas/usdLux.ts
+var LIGHT_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["DistantLight", "distant"],
+  ["SphereLight", "sphere"],
+  ["RectLight", "rect"],
+  ["DiskLight", "disk"],
+  ["CylinderLight", "cylinder"],
+  ["DomeLight", "dome"],
+  ["DomeLight_1", "dome"]
+]);
+var UNSUPPORTED_LIGHT_TYPES = /* @__PURE__ */ new Set([
+  "PortalLight",
+  "GeometryLight",
+  "PluginLight"
+]);
+function isLight(prim) {
+  return LIGHT_KIND_BY_TYPE.has(prim.GetTypeName());
+}
+function isUnsupportedLight(prim) {
+  return UNSUPPORTED_LIGHT_TYPES.has(prim.GetTypeName());
+}
+function getLightKind(prim) {
+  return LIGHT_KIND_BY_TYPE.get(prim.GetTypeName()) ?? null;
+}
+function readLightDescription(prim) {
+  const kind = getLightKind(prim);
+  if (!kind) return null;
+  const intensity = inputNumber(prim, "intensity") ?? (kind === "distant" ? 5e4 : 1);
+  const exposure = inputNumber(prim, "exposure") ?? 0;
+  let color = inputVec3(prim, "color") ?? [1, 1, 1];
+  if (inputBoolean(prim, "enableColorTemperature") === true) {
+    const tint = colorTemperatureToRgb(inputNumber(prim, "colorTemperature") ?? 6500);
+    color = [color[0] * tint[0], color[1] * tint[1], color[2] * tint[2]];
+  }
+  const shadowAuthoredValue = inputBoolean(prim, "shadow:enable");
+  const desc = {
+    primPath: prim.GetPath(),
+    name: prim.GetName(),
+    kind,
+    color,
+    intensity: intensity * 2 ** exposure,
+    normalize: inputBoolean(prim, "normalize") ?? false,
+    shadowEnabled: shadowAuthoredValue ?? true,
+    shadowAuthored: shadowAuthoredValue !== void 0
+  };
+  const coneAngle = inputNumber(prim, "shaping:cone:angle");
+  if (coneAngle !== void 0 && coneAngle < 90) {
+    desc.cone = { angleDeg: coneAngle, softness: inputNumber(prim, "shaping:cone:softness") ?? 0 };
+  }
+  switch (kind) {
+    case "distant": {
+      const angle = inputNumber(prim, "angle");
+      if (angle !== void 0) desc.angle = angle;
+      break;
+    }
+    case "sphere": {
+      desc.radius = inputNumber(prim, "radius") ?? 0.5;
+      const asPoint = inputBoolean(prim, "treatAsPoint");
+      if (asPoint !== void 0) desc.treatAsPoint = asPoint;
+      break;
+    }
+    case "rect": {
+      desc.width = inputNumber(prim, "width") ?? 1;
+      desc.height = inputNumber(prim, "height") ?? 1;
+      const file = inputAssetPath(prim, "texture:file");
+      if (file) desc.textureFile = file;
+      break;
+    }
+    case "disk":
+      desc.radius = inputNumber(prim, "radius") ?? 0.5;
+      break;
+    case "cylinder":
+      desc.radius = inputNumber(prim, "radius") ?? 0.5;
+      desc.length = inputNumber(prim, "length") ?? 1;
+      break;
+    case "dome": {
+      const file = inputAssetPath(prim, "texture:file");
+      if (file) desc.textureFile = file;
+      const format = inputString(prim, "texture:format");
+      if (format) desc.textureFormat = format;
+      const poleAxis = inputString(prim, "poleAxis");
+      if (poleAxis) desc.poleAxis = poleAxis;
+      break;
+    }
+  }
+  return desc;
+}
+function inputValue(prim, name) {
+  const namespaced = prim.GetAttribute(`inputs:${name}`).Get();
+  if (namespaced !== void 0) return namespaced;
+  return prim.GetAttribute(name).Get();
+}
+function inputNumber(prim, name) {
+  const v = inputValue(prim, name);
+  return typeof v === "number" ? v : void 0;
+}
+function inputBoolean(prim, name) {
+  const v = inputValue(prim, name);
+  if (typeof v === "boolean") return v;
+  if (v === 0 || v === 1) return v === 1;
+  return void 0;
+}
+function inputString(prim, name) {
+  const v = inputValue(prim, name);
+  return typeof v === "string" ? v : void 0;
+}
+function inputVec3(prim, name) {
+  const v = inputValue(prim, name);
+  if (Array.isArray(v) && v.length === 3 && typeof v[0] === "number" && typeof v[1] === "number" && typeof v[2] === "number") {
+    return [v[0], v[1], v[2]];
+  }
+  return void 0;
+}
+function inputAssetPath(prim, name) {
+  const v = inputValue(prim, name);
+  return v instanceof AssetPath && v.path ? v.path : void 0;
+}
+function colorTemperatureToRgb(kelvin) {
+  const raw = blackbodyRgb(kelvin);
+  const white = blackbodyRgb(6500);
+  return [raw[0] / white[0], raw[1] / white[1], raw[2] / white[2]];
+}
+function blackbodyRgb(kelvin) {
+  const t = Math.min(Math.max(kelvin, 1e3), 4e4) / 100;
+  const r = t <= 66 ? 255 : 329.698727446 * (t - 60) ** -0.1332047592;
+  const g = t <= 66 ? 99.4708025861 * Math.log(t) - 161.1195681661 : 288.1221695283 * (t - 60) ** -0.0755148492;
+  const b = t >= 66 ? 255 : t <= 19 ? 0 : 138.5177312231 * Math.log(t - 10) - 305.0447927307;
+  const clamp = (v) => Math.min(Math.max(v, 0), 255) / 255;
+  return [clamp(r), clamp(g), clamp(b)];
+}
+
 // src/schemas/usdPhysics.ts
 var JOINT_TYPE_BY_SCHEMA = {
   PhysicsFixedJoint: "fixed",
@@ -156,27 +288,35 @@ function getJointDrive(prim, kind) {
 function getJointStatePosition(prim, kind) {
   return readNumber(prim, `state:${kind}:physics:position`);
 }
-function getJointMimic(prim) {
+function physxMimicDof(type, axis) {
+  if (type === "fixed") return void 0;
+  return `${type === "prismatic" ? "trans" : "rot"}${axis}`;
+}
+function getJointMimic(prim, dof) {
   if (prim.HasAPI(NEWTON_MIMIC_API)) {
     if (prim.GetAttribute("newton:mimicEnabled").Get() === false) return void 0;
-    const referencePath = prim.GetRelationship("newton:mimicJoint").GetTargets()[0];
-    if (referencePath === void 0) return void 0;
+    const referencePath2 = prim.GetRelationship("newton:mimicJoint").GetTargets()[0];
+    if (referencePath2 === void 0) return void 0;
     return {
-      referencePath,
+      referencePath: referencePath2,
       multiplier: readNumber(prim, "newton:mimicCoef1") ?? 1,
       offset: readNumber(prim, "newton:mimicCoef0") ?? 0
     };
   }
-  for (const instance of physxMimicInstances(prim)) {
-    const referencePath = prim.GetRelationship(`physxMimicJoint:${instance}:referenceJoint`).GetTargets()[0];
-    if (referencePath === void 0) continue;
-    const gearing = readNumber(prim, `physxMimicJoint:${instance}:gearing`) ?? 1;
-    const offset = readNumber(prim, `physxMimicJoint:${instance}:offset`) ?? 0;
-    return { referencePath, multiplier: -gearing, offset: -offset };
-  }
-  return void 0;
+  if (dof === void 0) return void 0;
+  const referencePath = prim.GetRelationship(`physxMimicJoint:${dof}:referenceJoint`).GetTargets()[0];
+  if (referencePath === void 0) return void 0;
+  const gearing = readNumber(prim, `physxMimicJoint:${dof}:gearing`) ?? 1;
+  const offset = readNumber(prim, `physxMimicJoint:${dof}:offset`) ?? 0;
+  const referenceDof = prim.GetAttribute(`physxMimicJoint:${dof}:referenceJointAxis`).Get();
+  return {
+    referencePath,
+    multiplier: -gearing,
+    offset: -offset,
+    ...typeof referenceDof === "string" ? { referenceDof } : {}
+  };
 }
-function physxMimicInstances(prim) {
+function getPhysxMimicDofs(prim) {
   const out = /* @__PURE__ */ new Set();
   for (const schema of prim.GetAppliedSchemas()) {
     if (schema.startsWith(`${PHYSX_MIMIC_API}:`)) out.add(schema.slice(PHYSX_MIMIC_API.length + 1));
@@ -220,103 +360,6 @@ function readQuat(prim, name, def) {
   return v instanceof Quat ? v : def;
 }
 
-// src/usd/xformOps.ts
-var INVERT_PREFIX = "!invert!";
-var RESET_STACK = "!resetXformStack!";
-var ROTATE_ORDERS = /* @__PURE__ */ new Set([
-  "rotateXYZ",
-  "rotateXZY",
-  "rotateYXZ",
-  "rotateYZX",
-  "rotateZXY",
-  "rotateZYX"
-]);
-function computeWorldTransform(prim) {
-  const chain = [];
-  for (let p = prim; p && !p.IsPseudoRoot(); p = p.GetParent()) chain.push(p);
-  let m = identity4();
-  for (let i = chain.length - 1; i >= 0; i--) {
-    m = multiply(m, computeLocalTransform(chain[i]).matrix);
-  }
-  return m;
-}
-function computeLocalTransform(prim) {
-  const orderAttr = prim.GetAttribute("xformOpOrder");
-  const order = orderAttr.Get();
-  if (!Array.isArray(order)) {
-    return { matrix: identity4(), resetsXformStack: false };
-  }
-  let matrix = identity4();
-  let resetsXformStack = false;
-  for (const entry of order) {
-    if (typeof entry !== "string") continue;
-    if (entry === RESET_STACK) {
-      resetsXformStack = true;
-      continue;
-    }
-    let opName = entry;
-    let doInvert = false;
-    if (opName.startsWith(INVERT_PREFIX)) {
-      doInvert = true;
-      opName = opName.slice(INVERT_PREFIX.length);
-    }
-    const attr = prim.GetAttribute(opName);
-    if (!attr.IsValid()) continue;
-    const opValue = attr.Get();
-    if (opValue === void 0) continue;
-    let opMatrix = opMatrixFor(parseOpType(opName), opValue, `${prim.GetPath()}.${opName}`);
-    if (doInvert) opMatrix = invert(opMatrix);
-    matrix = multiply(matrix, opMatrix);
-  }
-  return { matrix, resetsXformStack };
-}
-function parseOpType(opName) {
-  const body = opName.startsWith("xformOp:") ? opName.slice("xformOp:".length) : opName;
-  return body.split(":")[0] ?? body;
-}
-function opMatrixFor(opType, value, where) {
-  switch (opType) {
-    case "translate":
-      return makeTranslation(asVec3(value, where));
-    case "scale":
-      return makeScale(asVec3(value, where));
-    case "orient":
-      return makeRotationFromQuat(asQuat(value, where));
-    case "transform":
-      return fromUsdMatrix(asMatrix(value, where));
-    case "rotateX":
-      return makeRotationX(asNumber(value, where) * DEG2RAD);
-    case "rotateY":
-      return makeRotationY(asNumber(value, where) * DEG2RAD);
-    case "rotateZ":
-      return makeRotationZ(asNumber(value, where) * DEG2RAD);
-    default:
-      if (ROTATE_ORDERS.has(opType)) {
-        const [x, y, z] = asVec3(value, where);
-        return makeEuler([x * DEG2RAD, y * DEG2RAD, z * DEG2RAD], opType.slice("rotate".length));
-      }
-      throw new Error(`${where}: unsupported xformOp type "${opType}"`);
-  }
-}
-function asVec3(v, where) {
-  if (Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number")) {
-    return v;
-  }
-  throw new Error(`${where}: expected a 3-component value`);
-}
-function asNumber(v, where) {
-  if (typeof v === "number") return v;
-  throw new Error(`${where}: expected a number`);
-}
-function asQuat(v, where) {
-  if (v && typeof v === "object" && "real" in v && "imaginary" in v) return v;
-  throw new Error(`${where}: expected a quaternion`);
-}
-function asMatrix(v, where) {
-  if (v && typeof v === "object" && "values" in v && "dim" in v) return v;
-  throw new Error(`${where}: expected a matrix`);
-}
-
 // src/robot/buildKinematicTree.ts
 var WORLD = "";
 function buildKinematicTree(robot, options = {}) {
@@ -578,16 +621,37 @@ function buildJoint(prim, linkKeyByPath, jointKeyByPath, warn) {
     });
     joint.valueSamples = { times, values };
   }
-  const mimic = getJointMimic(prim);
+  const dof = physxMimicDof(type, joint.axis);
+  const mimic = getJointMimic(prim, dof);
   if (mimic) {
-    joint.mimic = {
-      joint: jointKeyByPath.get(mimic.referencePath) ?? mimic.referencePath,
-      multiplier: mimic.multiplier,
-      offset: jointValueToSI(angular, mimic.offset)
-    };
+    const leaderDof = jointDof(prim, mimic.referencePath);
+    if (mimic.referenceDof !== void 0 && leaderDof !== void 0 && mimic.referenceDof !== leaderDof) {
+      warn(
+        `${path}: mimic reads "${mimic.referencePath}" on \`${mimic.referenceDof}\`, which is not the dof it moves about (\`${leaderDof}\`); ignoring`
+      );
+    } else {
+      joint.mimic = {
+        joint: jointKeyByPath.get(mimic.referencePath) ?? mimic.referencePath,
+        multiplier: mimic.multiplier,
+        offset: jointValueToSI(angular, mimic.offset)
+      };
+    }
+  } else if (dof !== void 0) {
+    const authored = getPhysxMimicDofs(prim).filter((d) => d !== dof);
+    if (authored.length > 0) {
+      warn(
+        `${path}: mimic authored on \`${authored.join("`, `")}\` but the joint moves about \`${dof}\`; ignoring`
+      );
+    }
   }
   return joint;
 }
+function jointDof(from, path) {
+  const prim = from.GetStage().GetPrimAtPath(path);
+  if (!prim) return void 0;
+  const type = getJointType(prim);
+  return type ? physxMimicDof(type, getJointAxis(prim)) : void 0;
+}
 function dropInvalidMimics(joints, warn) {
   for (const [key, joint] of Object.entries(joints)) {
     const mimic = joint.mimic;
@@ -2885,7 +2949,7 @@ function crateToUsdaFile(crate) {
     if (spec.specType !== SPEC_PRIM) continue;
     const fm = fieldsOf(spec.fieldSetIndex);
     primByPath.set(path, {
-      specifier: SPECIFIERS2[asNumber2(crate, fm.get("specifier")) ?? 0] ?? "def",
+      specifier: SPECIFIERS2[asNumber(crate, fm.get("specifier")) ?? 0] ?? "def",
       typeName: asString(crate, fm.get("typeName")) ?? "",
       name: leaf(path),
       metadata: buildPrimMetadata(crate, fm),
@@ -2939,7 +3003,7 @@ function buildAttribute(crate, name, fm) {
     name,
     typeName: isArrayType ? rawType.slice(0, -2) : rawType,
     isArray: isArrayType || (defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false),
-    variability: asNumber2(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
+    variability: asNumber(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
     custom: customRep !== void 0 && crate.getValue(customRep) === true,
     metadata: {},
     line: 0
@@ -3011,10 +3075,10 @@ function buildLayerMetadata(crate, fm) {
   if (upAxis !== void 0) meta.upAxis = upAxis;
   const defaultPrim2 = asString(crate, fm.get("defaultPrim"));
   if (defaultPrim2 !== void 0) meta.defaultPrim = defaultPrim2;
-  const metersPerUnit = asNumber2(crate, fm.get("metersPerUnit"));
+  const metersPerUnit = asNumber(crate, fm.get("metersPerUnit"));
   if (metersPerUnit !== void 0) meta.metersPerUnit = metersPerUnit;
   for (const key of ["startTimeCode", "endTimeCode", "timeCodesPerSecond", "framesPerSecond"]) {
-    const value = asNumber2(crate, fm.get(key));
+    const value = asNumber(crate, fm.get(key));
     if (value !== void 0) meta[key] = value;
   }
   const customLayerData = fm.has("customLayerData") ? crate.getValue(fm.get("customLayerData")) : void 0;
@@ -3028,7 +3092,7 @@ function asString(crate, rep) {
   const v = crate.getValue(rep);
   return typeof v === "string" ? v : void 0;
 }
-function asNumber2(crate, rep) {
+function asNumber(crate, rep) {
   if (rep === void 0) return void 0;
   const v = crate.getValue(rep);
   return typeof v === "number" ? v : void 0;
@@ -3408,6 +3472,6 @@ function openUsdz(bytes) {
   return { rootEntry, resolver };
 }
 
-export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, Layer, MASS_API, MESH_COLLISION_API, NEWTON_MIMIC_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, collectMdlAssetPaths, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, jointValueFromSI, jointValueToSI, loadMdlModules, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, serializeUsda, toBytes, tokenize };
-//# sourceMappingURL=chunk-FUVHAORT.js.map
-//# sourceMappingURL=chunk-FUVHAORT.js.map
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, Layer, MASS_API, MESH_COLLISION_API, NEWTON_MIMIC_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, collectMdlAssetPaths, colorTemperatureToRgb, composeFile, composeLayer, crateToUsdaFile, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getLightKind, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isLight, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isUnsupportedLight, isXform, isZip, iterDescendants, jointValueFromSI, jointValueToSI, loadMdlModules, normalizeJointLimits, openUsdz, parseUsda, readLightDescription, refineJointType, serializeUsda, toBytes, tokenize };
+//# sourceMappingURL=chunk-KRT4NL3H.js.map
+//# sourceMappingURL=chunk-KRT4NL3H.js.map