@displayxr/inline3d 1.49.3 → 1.51.0

package/CHANGELOG.md

@@ -5,6 +5,62 @@ entry points (`.`, `./three`) are frozen for 1.x, while the **scene subpaths** (
 `./splat`, `./model`) are a preview tier whose options may change in any release. Entries below say
 which tier they touch, because that is what tells you whether an upgrade can move your pixels.
 
+## Unreleased
+
+## 1.51.0 — 2026-11-08
+
+### Added — `./call`: `openTabShare()`, share a browser tab in 3D
+
+Opens the browser's tab picker and returns a track for `shareContent`. In a DisplayXR Browser with
+stereo tab capture (1.9.4+), a picked tab comes back as a true side-by-side track, so receivers need
+nothing new; a window, a screen or any other browser comes back flat. Needs
+`MediaStreamTrackProcessor` for the stereo path.
+
+### Fixed — `./splat` (`engine: 'playcanvas'`): no false "footprint fix SKIPPED" warning on PlayCanvas 2.23
+
+Preview tier. PlayCanvas 2.23 fixed the side-by-side splat footprint upstream, so the SDK now
+leaves that shader chunk untouched there instead of warning that splats will draw at half height.
+2.22.3 is still patched as before, and remains the only version validated on a panel.
+
+## 1.50.0 — 2026-11-04
+
+### Fixed — `./camera`, `./call`: half-width side-by-side webcams keep their aspect ratio
+
+A USB stereo webcam that sends 3840x2160 half-SBS came through as a 3840x1080 centre crop: each eye
+2x too tall, with half the vertical view. Such a camera (listed by USB id, since its shape matches
+a 4K webcam's) is now read in its native mode and sent as 2560x720 with square-pixel eyes. Needs
+`MediaStreamTrackProcessor`; without it the camera opens as before. `prefer: 'mono'` stays raw.
+
+### Added — `@displayxr/inline3d/hands`: tracked hands, and pinch controls for every viewer (`./hands`, `./viewer`, `./model`, `./splat`)
+
+Preview tier. The DisplayXR Browser 1.8.0+ (Windows, with a hand provider such as an Ultraleap
+tracker) exposes standard WebXR Hand Input on an inline-3D session: one `XRInputSource` per hand
+with a 25-joint `XRHand`, located in the same rig frame as the eye views. The new subpath reads it
+and turns it into controls:
+
+- `watchHands(wall, onFrame)` — the tracked hands every session frame (`poses`, `radii`,
+  `joint(name)`, `thumbTip`, `indexTip`, `palmLength`), the browser's per-frame gate
+  (`state.gate`: `'available'` or why hands are withheld) and the hand `inputsourceschange`.
+- `HandGestureController` / `PinchDetector` — the DisplayXR Model Viewer's gesture math, ported:
+  hand-relative throughout — the pinch thresholds (2.5 cm enter / 4 cm exit), the orbit gain
+  (10 rad/m) and the two-hand separation guard are all stated for a 9.5 cm palm and scale by the
+  hand's own palm length, so a hand that arrives scaled turns the subject by the same angle for
+  the same finger travel; one pinched hand orbits, two pinched hands zoom (separation ratio), roll
+  (twist) and orbit (midpoint drag); EMA-smoothed, anchored on every mode change.
+- `handControls(wall, target)` — drives anything with the viewer pose surface from those
+  gestures; and the option **`hands: true`** on `addModel` / `addSplat` (both engines, every
+  entry) wires it for you, exposed as `handle.hands`. Pointer and wheel keep working alongside.
+- `SceneViewer.nudgePose(delta)` and `PlayCanvasSplatViewer.nudgePose(delta)` — move the pose by
+  an eased delta, counting as input for the idle turntable (what the hands call; a page may too).
+- `OrbitPose.roll` on both viewers — degrees about the view axis, outside yaw and pitch (Euler
+  order `'ZXY'`; the PlayCanvas pivot quaternion gains the same Rz factor), bit-identical to
+  before at roll 0; `getPose()` now reports `roll`. (The first cut left the PlayCanvas viewer
+  without a roll axis, so the two-hand twist did nothing on the default engine — found on the
+  panel 2026-11-04.)
+
+Inert everywhere else: no hands, nothing moves, no errors. New sample `samples/hands/` (the raw
+surface), and `?hands` on `samples/model/` and `samples/splat/`. The porting guide's "no input
+sources" row is corrected (web#229). Tracks DisplayXR/displayxr-web#228.
 ## 1.49.3 — 2026-11-04
 
 ### Fixed — a camera view is not "woven" before the camera's first frame; `frameAgeMs` tells a stalled track (`.`, `./camera`, `./call`)

package/README.md

@@ -35,6 +35,9 @@ import { addModel } from '@displayxr/inline3d/model';               // experimen
 import { addPlayer } from '@displayxr/inline3d/player';             // preview: a media player, built
                                                                     //   on addVideo, with transport
 import { SceneViewer } from '@displayxr/inline3d/viewer';           // experimental: framing + orbit
+import { handControls } from '@displayxr/inline3d/hands';          // experimental: tracked hands,
+                                                                    //   pinch to orbit (or `hands: true`
+                                                                    //   on addModel / addSplat)
 ```
 
 No build step or bundler required — it's plain ES modules. You can also import a pinned version by
@@ -66,7 +69,9 @@ The repo's splat sample (`samples/splat/`) renders with PlayCanvas and keeps `?e
 its A/B switch.
 Bundlers: the engine is reached through a named-import module (`js/inline3d-playcanvas-engine.js`,
 so the unused ~40% of the engine tree-shakes away); its sort workers are Blob URLs (CSP
-`worker-src blob:`), and esbuild needs `node:worker_threads` marked external.
+`worker-src blob:`), and esbuild needs `node:worker_threads` marked external. Pin the engine to
+exactly `playcanvas@2.22.3`, the version validated on a panel
+([why](docs/playcanvas-adapter.md)).
 
 **Splat effects (preview, `engine: 'playcanvas'`).** Shader effects on the splats themselves,
 keyed on world position and time so both eyes agree: `addSplat(…, { reveal: 'inflate' | 'sweep' |

package/call.d.ts

@@ -420,6 +420,22 @@ export function watchShareableApps(cb: (apps: ShareableApp[]) => void, opts?: {
  */
 export function openAppShare(deviceId: string, opts?: { width?: number; height?: number; frameRate?: number; mediaDevices?: MediaDevices }): Promise<AppShare>;
 
+/** An opened tab share (`openTabShare`): pass `stream` (+ `descriptor`) to `shareContent`. The track is yours to stop. */
+export interface TabShare {
+  stream: MediaStream;
+  track: MediaStreamTrack;
+  /** true: a side-by-side track. false: the user picked a window or screen, or the browser captures tabs flat. */
+  stereo: boolean;
+  descriptor: { kind: 'content'; format: CallFormat; width: number; height: number; convergence: { known: true; frac: number }; appName: null };
+}
+
+/**
+ * Let the user pick a browser tab to share, in 3D where the browser can (the browser's picker is
+ * the consent). Comes back flat (`stereo: false`) for a window, a screen, or a browser without stereo
+ * tab capture. Cancelling rejects with `code: 'share-denied'`, anything else with `'share-failed'`.
+ */
+export function openTabShare(opts?: { width?: number; frameRate?: number; mediaDevices?: MediaDevices }): Promise<TabShare>;
+
 /**
  * `error` codes — fatal for a feature, never for the widget. `'camera-busy'` (held by another
  * app: audio-only until `retryCamera()`), `'no-camera'`, `'permission-denied'`, `'unreachable'`