@konitif/viewer-3d 0.285.0 → 0.285.2

package/dist/renderer/Viewer3DRenderer.js

@@ -18,7 +18,7 @@ import { SMAAPass } from 'three/examples/jsm/postprocessing/SMAAPass.js';
 import { HorizontalTiltShiftShader } from 'three/examples/jsm/shaders/HorizontalTiltShiftShader.js';
 import { VerticalTiltShiftShader } from 'three/examples/jsm/shaders/VerticalTiltShiftShader.js';
 import { getRobotMotionAnimationDuration, interpolateRobotMotionTrackValueAtTime, toRobotMotionJointValue, resolveRobotMotionPlaybackDuration } from './robotViewerMotion.js';
-import { createViewerProjectileLaunchSolution, createViewerProjectileTrajectoryPoints, resolveViewerProjectileChargedLaunchProfile, resolveViewerProjectileImpulse, resolveViewerProjectileLauncherWorldScale, resolveViewerSlingshotReleasePull, stepViewerProjectileAgainstGround } from './ProjectileInteraction.js';
+import { createViewerProjectileLaunchSolution, VIEWER3D_PROJECTILE_PARTICLE_LIMIT, createViewerProjectileTrajectoryPoints, resolveViewerProjectileChargedLaunchProfile, resolveViewerProjectileImpulse, resolveViewerProjectileLauncherWorldScale, resolveViewerSlingshotReleasePull, stepViewerProjectileAgainstGround } from './ProjectileInteraction.js';
 import { createInteractionKeyboardSignal, DEFAULT_VIEWER_INPUT_BINDINGS, VIEWER_PROJECTILE_CHARGE_ACTION_ID, VIEWER_PROJECTILE_LAUNCH_ACTION_ID } from './ViewerInputBindings.js';
 import { ViewerProjectileParticleRenderer } from './ViewerProjectileParticleRenderer.js';
 import { ROBOT_COMPARISON_VISIBILITY_LAYOUT_SHARE, resolveRobotComparisonVisibilityTransitionPhases } from './RobotComparisonVisibilityTransition.js';
@@ -64,7 +64,7 @@ const ROBOT_VIEWER_SCRUB_PHYSICS_SYNC_MINIMUM_INTERVAL_MS = 1000 / 30;
 const ROBOT_VIEWER_PROJECTILE_MASS_KG = 0.18;
 const ROBOT_VIEWER_PROJECTILE_RADIUS_M = 0.03;
 const ROBOT_VIEWER_PROJECTILE_SETTLE_MS = 3_000;
-export const VIEWER3D_PROJECTILE_PARTICLE_LIMIT = 24;
+export { VIEWER3D_PROJECTILE_PARTICLE_LIMIT } from './ProjectileInteraction.js';
 const ROBOT_VIEWER_PROJECTILE_MAX_LIFETIME_MS = 12_000;
 const ROBOT_VIEWER_PROJECTILE_SETTLED_HOLD_MS = 1_300;
 const ROBOT_VIEWER_PROJECTILE_FADE_MS = 900;
@@ -192,6 +192,7 @@ const VIEWER3D_DEFAULT_CAMERA_POSITION = { x: 1.4, y: 0.9, z: 1.4 };
 const VIEWER3D_DEFAULT_CAMERA_TARGET = { x: 0, y: 0.32, z: 0 };
 const EMPTY_MUTED_TRACK_TARGET_SET = new Set();
 export class Viewer3D {
+    displayedRecordedPhysicsObservation = null;
     container;
     renderer;
     scene;
@@ -1275,6 +1276,79 @@ export class Viewer3D {
     getPhysicsSnapshot() {
         return this.physicsService.snapshot();
     }
+    /** Project an already assembled URDF root; presentation offsets are excluded. */
+    readDisplayedRobotRootTransform(target, frame) {
+        const robot = target === 'observed' ? this.observedRobotGhost : this.robot;
+        if (!robot)
+            return null;
+        // A hidden ghost still supplies its grounded projection to external viewers.
+        if (target === 'observed')
+            this.applyObservedRobotGhostGrounding();
+        robot.updateMatrix();
+        const reference = { bodyName: frame.bodyName, position: { x: 0, y: 0, z: 0 },
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            metadata: { visualRoot: true, coordinateFrame: frame.coordinateFrame, sceneYawRadians: frame.sceneYawRadians } };
+        const canonical = this.createPhysicsCoordinateFrameMatrix(reference).invert().multiply(robot.matrix);
+        const position = new Vector3(), rotation = new Quaternion(), scale = new Vector3();
+        canonical.decompose(position, rotation, scale);
+        return { ...reference, position: { x: position.x, y: position.y, z: position.z },
+            rotation: { x: rotation.x, y: rotation.y, z: rotation.z, w: rotation.w } };
+    }
+    readDisplayedRobotObservation(timeSeconds) {
+        if (!this.robot)
+            return null;
+        const physical = this.readPhysicsObservation();
+        const jointAngles = this.captureRuntimeHistoryVisualJointStates();
+        const bodies = this.projectedPhysicsBodyTransforms.length ? this.projectedPhysicsBodyTransforms : physical?.bodyTransforms.length ? physical.bodyTransforms : this.physicsService.getBodyTransforms();
+        const root = bodies.find(body => body.metadata?.visualRoot === true) ?? bodies.find(body => body.bodyName === this.physicsVisualRootBodyName);
+        let rootTransform;
+        const alignment = root ? this.physicsVisualRootToRobotMatrix ?? this.resolvePhysicsVisualRootToRobotMatrix(this.createPhysicsBodyViewerWorldMatrix(root), bodies) : null;
+        if (root && alignment) {
+            this.robot.updateMatrix();
+            const robotMatrix = this.robot.matrix.clone();
+            if (this.robot.parent && this.robot.parent !== this.simulatedRobotPresentationRoot) {
+                this.robot.parent.updateMatrixWorld(true);
+                robotMatrix.premultiply(this.robot.parent.matrixWorld);
+            }
+            const canonicalMatrix = this.createPhysicsCoordinateFrameMatrix(root).invert()
+                .multiply(robotMatrix).multiply(alignment.clone().invert());
+            const position = new Vector3(), rotation = new Quaternion(), scale = new Vector3();
+            canonicalMatrix.decompose(position, rotation, scale);
+            rootTransform = { ...structuredClone(root), position: { x: position.x, y: position.y, z: position.z }, rotation: { x: rotation.x, y: rotation.y, z: rotation.z, w: rotation.w } };
+        }
+        const time = Number.isFinite(timeSeconds) ? timeSeconds : physical?.simulatedTimeSeconds ?? 0;
+        return {
+            sampleId: `displayed:${time}:${JSON.stringify(jointAngles)}:${JSON.stringify(rootTransform)}`,
+            observedAtMs: performance.now(), simulatedTimeSeconds: time,
+            jointAngles, rootTransform, bodyTransforms: structuredClone(bodies), centerOfMass: this.projectedPhysicsCenterOfMass ?? physical?.centerOfMass ?? this.physicsService.getCenterOfMass(), navigation: null,
+            projectionStage: this.displayedRecordedPhysicsObservation ? 'simulated' : 'authored'
+        };
+    }
+    readPhysicsObservation() {
+        if (this.displayedRecordedPhysicsObservation)
+            return structuredClone(this.displayedRecordedPhysicsObservation);
+        if (this.playbackState?.animation && this.robot) {
+            const jointAngles = this.captureRuntimeHistoryVisualJointStates();
+            const time = this.playbackState.currentTime;
+            return {
+                sampleId: `displayed:${this.playbackState.sourceId ?? 'animation'}:${time}:${JSON.stringify(jointAngles)}`,
+                observedAtMs: performance.now(), simulatedTimeSeconds: time,
+                projectionStage: 'authored', jointAngles, bodyTransforms: [], centerOfMass: null, navigation: null
+            };
+        }
+        const snapshot = this.physicsService.snapshot();
+        const bodies = this.physicsService.getBodyTransforms();
+        if (!snapshot.loadedSourceId || !bodies.length)
+            return null;
+        const metadata = snapshot.backendStatus?.metadata;
+        const time = typeof metadata?.simulatedTime === 'number' ? metadata.simulatedTime : 0;
+        return {
+            sampleId: `${snapshot.engine}:${snapshot.loadedSourceId}:${metadata?.stepCount ?? 0}:${metadata?.stateRevision ?? 0}`,
+            observedAtMs: performance.now(), simulatedTimeSeconds: time,
+            jointAngles: this.capturePhysicsVisualJointAngles(),
+            bodyTransforms: structuredClone(bodies), centerOfMass: this.physicsService.getCenterOfMass(), navigation: null
+        };
+    }
     readNavigationPhysicsObservation() {
         const snapshot = this.physicsService.snapshot();
         if (!snapshot.enabled ||
@@ -1502,6 +1576,7 @@ export class Viewer3D {
         return true;
     }
     resumeRuntimeHistoryLiveProjection() {
+        this.displayedRecordedPhysicsObservation = null;
         if (!this.runtimeHistoryReplayActive) {
             return;
         }
@@ -2377,6 +2452,9 @@ export class Viewer3D {
         this.deferredBoundaryPreviewRuntimeHistoryProjection = null;
         if (!transition) {
             this.boundaryPosePreviewTransitionState = null;
+            this.groundSimulatedRobotOnSupportFloor(this.robot);
+            this.syncPhysicsKinematicPoseFromRobotPose({ holdFrames: 0, clearDynamics: true, resetCadence: false });
+            this.updateViewerDebugLayers();
             this.requestRender();
             return true;
         }
@@ -2436,6 +2514,7 @@ export class Viewer3D {
         return this.createMutedTrackTargetSet(mutedTrackTargets);
     }
     applyRobotPose(animation, time, mutedTrackTargets = [], durationOverride = null) {
+        this.displayedRecordedPhysicsObservation = null;
         if (!this.robot) {
             return false;
         }
@@ -2886,6 +2965,10 @@ export class Viewer3D {
             poseChanged = this.applyDesiredProjectionJointValue(joint, value) || poseChanged;
         }
         if (poseChanged) {
+            // A catalogue pose owns joint angles, not the previous incarnation's root height.
+            // Ground only this authored preview; recorded physical samples retain their root.
+            if (this.robot)
+                this.groundSimulatedRobotOnSupportFloor(this.robot);
             this.robot?.updateMatrixWorld(true);
             this.updateViewerDebugLayers();
             this.syncPhysicsKinematicPoseFromRobotPose({
@@ -4101,6 +4184,7 @@ export class Viewer3D {
         }
         const receivedPhysicsSample = sampleId !== this.lastTemporalProjectionSampleId;
         if (receivedPhysicsSample) {
+            this.displayedRecordedPhysicsObservation = null;
             this.markFrameSignal('physics-observation');
             this.lastTemporalProjectionSampleId = sampleId;
             this.temporalProjection.ingest({
@@ -4114,6 +4198,7 @@ export class Viewer3D {
             });
             if (this.options.physicsObservationEnabled) {
                 this.options.onPhysicsObservation({
+                    jointAngles: this.capturePhysicsVisualJointAngles(),
                     sampleId,
                     observedAtMs: now,
                     simulatedTimeSeconds: simulatedTime,
@@ -4394,6 +4479,22 @@ export class Viewer3D {
             // never the last live/bake observation left in these projection fields.
             this.projectedPhysicsBodyTransforms = bodyTransforms;
             this.projectedPhysicsCenterOfMass = centerOfMass;
+            if (viewer.physics?.enabled && bodyTransforms.length > 0) {
+                this.displayedRecordedPhysicsObservation = {
+                    projectionStage: 'simulated',
+                    sampleId: `recorded:${sample.id}:${sample.timeSeconds}`,
+                    observedAtMs: performance.now(), simulatedTimeSeconds: sample.timeSeconds,
+                    jointAngles: { ...(viewer.joints ?? {}) },
+                    bodyTransforms: structuredClone(bodyTransforms),
+                    centerOfMass: viewer.physics.centerOfMass ? { ...viewer.physics.centerOfMass } : null,
+                    navigation: null
+                };
+                if (this.options.physicsObservationEnabled)
+                    this.options.onPhysicsObservation(structuredClone(this.displayedRecordedPhysicsObservation));
+            }
+            else {
+                this.displayedRecordedPhysicsObservation = null;
+            }
             const hasVisualJointStates = viewer.joints && Object.keys(viewer.joints).length > 0;
             const visualJointPoseChanged = this.applyRuntimeHistoryVisualJointStates(viewer.joints ?? null);
             poseChanged = visualJointPoseChanged;
@@ -9146,28 +9247,8 @@ export class Viewer3D {
     resolveEyeRingCalibration() {
         const defaults = this.options.ledRingDefaults?.eyes ?? ROBOT_VIEWER_EMPTY_LED_RING_CALIBRATION;
         const calibration = this.options.eyeRingCalibration ?? {};
-        const legacyCalibration = calibration;
         return {
-            layout: this.resolveLedLayout(calibration.layout, defaults.layout),
-            forwardOffset: this.resolveFiniteCalibrationNumber(calibration.forwardOffset, defaults.forwardOffset),
-            verticalOffset: this.resolveFiniteCalibrationNumber(calibration.verticalOffset, defaults.verticalOffset),
-            lateralOffset: this.resolveFiniteCalibrationNumber(calibration.lateralOffset, defaults.lateralOffset ?? 0),
-            separation: this.resolveFiniteCalibrationNumber(calibration.separation, defaults.separation),
-            radius: this.resolveFiniteCalibrationNumber(calibration.radius, defaults.radius),
-            stripLength: this.resolveFiniteCalibrationNumber(calibration.stripLength, defaults.stripLength ?? defaults.radius * 2),
-            ledCount: this.resolveFiniteCalibrationNumber(calibration.ledCount, defaults.ledCount),
-            ledSize: this.resolveFiniteCalibrationNumber(calibration.ledSize, defaults.ledSize),
-            rotationX: this.resolveFiniteCalibrationNumber(calibration.rotationX, defaults.rotationX),
-            rotationY: this.resolveFiniteCalibrationNumber(calibration.rotationY ?? legacyCalibration.tiltY, defaults.rotationY),
-            rotationZ: this.resolveFiniteCalibrationNumber(calibration.rotationZ ?? legacyCalibration.tiltX, defaults.rotationZ),
-            isVisible: typeof calibration.isVisible === 'boolean'
-                ? calibration.isVisible
-                : defaults.isVisible,
-            mireVisible: typeof calibration.mireVisible === 'boolean'
-                ? calibration.mireVisible
-                : defaults.mireVisible,
-            variantCount: this.resolveFiniteCalibrationNumber(calibration.variantCount, defaults.variantCount),
-            variantStep: this.resolveFiniteCalibrationNumber(calibration.variantStep, defaults.variantStep),
+            ...resolveViewerLedRingCalibration(calibration, defaults),
             zones: this.resolveLedRingCalibrationZones(calibration.zones)
         };
     }
@@ -9205,34 +9286,9 @@ export class Viewer3D {
     resolveFiniteCalibrationNumber(value, fallback) {
         return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
     }
-    resolveLedLayout(value, fallback = 'circle') {
-        if (value === 'strip' || value === 'circle')
-            return value;
-        return fallback === 'strip' ? 'strip' : 'circle';
-    }
     resolveLedRingZoneCalibration(calibration, zoneId) {
-        const base = zoneId === 'eyes'
-            ? calibration
-            : (this.options.ledRingDefaults?.[zoneId] ?? ROBOT_VIEWER_EMPTY_LED_RING_CALIBRATION);
-        const override = calibration.zones?.[zoneId] ?? {};
-        return {
-            layout: this.resolveLedLayout(override.layout, base.layout),
-            forwardOffset: this.resolveFiniteCalibrationNumber(override.forwardOffset, base.forwardOffset),
-            verticalOffset: this.resolveFiniteCalibrationNumber(override.verticalOffset, base.verticalOffset),
-            lateralOffset: this.resolveFiniteCalibrationNumber(override.lateralOffset, base.lateralOffset ?? 0),
-            separation: this.resolveFiniteCalibrationNumber(override.separation, base.separation),
-            radius: this.resolveFiniteCalibrationNumber(override.radius, base.radius),
-            stripLength: this.resolveFiniteCalibrationNumber(override.stripLength, base.stripLength ?? base.radius * 2),
-            ledCount: this.resolveFiniteCalibrationNumber(override.ledCount, base.ledCount),
-            ledSize: this.resolveFiniteCalibrationNumber(override.ledSize, base.ledSize),
-            rotationX: this.resolveFiniteCalibrationNumber(override.rotationX, base.rotationX),
-            rotationY: this.resolveFiniteCalibrationNumber(override.rotationY, base.rotationY),
-            rotationZ: this.resolveFiniteCalibrationNumber(override.rotationZ, base.rotationZ),
-            isVisible: typeof override.isVisible === 'boolean' ? override.isVisible : base.isVisible,
-            mireVisible: typeof override.mireVisible === 'boolean' ? override.mireVisible : base.mireVisible,
-            variantCount: this.resolveFiniteCalibrationNumber(override.variantCount, base.variantCount),
-            variantStep: this.resolveFiniteCalibrationNumber(override.variantStep, base.variantStep)
-        };
+        const base = zoneId === 'eyes' ? calibration : (this.options.ledRingDefaults?.[zoneId] ?? ROBOT_VIEWER_EMPTY_LED_RING_CALIBRATION);
+        return resolveViewerLedRingCalibration(calibration.zones?.[zoneId], base);
     }
     resolveEyeRingDebugDimensions(calibration) {
         const variantCount = Math.max(1, Math.min(7, Math.round(calibration.variantCount)));
@@ -10652,4 +10708,5 @@ function sampleNavigationPath(points, progress) {
     }
     return points[points.length - 1]?.clone() ?? new Vector3();
 }
+import { resolveViewerLedRingCalibration } from '../ledRingCalibration.js';
 //# sourceMappingURL=Viewer3DRenderer.js.map