@supersoniks/concorde 4.9.97-visual-stack.0 → 4.9.98-visual-stack.1

package/src/core/components/functional/3d/runtime.ts

@@ -6,14 +6,22 @@ import { bootScene } from "./boot";
 import { ops, type OpsCtx } from "./ops";
 import type { SceneRuntimeOptions } from "./opts";
 import type { SceneHit } from "./pick";
+import {
+  PostFxCompileError,
+  PostFxPipeline,
+  type PostFxConfig,
+  type PostFxUniforms,
+} from "./post-fx";
 import { tune, type TuneCtx } from "./tune";
 import type { Sonic3dAsset, Sonic3dOutput } from "./types";
 import { view, type ViewCtx } from "./view";
 
 export type { SceneHit, SceneRuntimeOptions };
+export { PostFxCompileError };
+export type { PostFxConfig, PostFxUniforms };
 
 /**
- * Runtime Three.js encapsulé : renderer, scène, caméra, load, fit, pick.
+ * Runtime Three.js encapsulé : renderer, scène, caméra, load, fit, pick, post FX.
  * Le composant Lit gère RAF / viewport / DP.
  */
 export class SceneRuntime {
@@ -46,6 +54,19 @@ export class SceneRuntime {
   private highlighted: THREE.Mesh | null = null;
   private prevEmissive = new THREE.Color();
   private prevEmissiveIntensity = 0;
+  private postFx: PostFxPipeline;
+  private lastCssW = 1;
+  private lastCssH = 1;
+  private damping = 0.08;
+  private postFrame: PostFxUniforms = {
+    time: 0,
+    timeDelta: 1 / 60,
+    frame: 0,
+    mouse: [0, 0, 0, 0],
+    params: [0, 0, 0, 0],
+    near: 0.1,
+    far: 100,
+  };
 
   constructor(opts: SceneRuntimeOptions) {
     const b = bootScene(opts);
@@ -62,9 +83,32 @@ export class SceneRuntime {
     this.fov = b.fov;
     this.fitEnabled = b.fitEnabled;
     this.limits = b.limits;
+    this.postFx = new PostFxPipeline(this.renderer);
     this.applyCameraMode(this.mode);
     if (b.autoRotate) this.setAutoRotate(true);
-    void [this.canvas, this.perspCam, this.orthoCam, this.root, this.content, this.lights, this.loader, this.loadToken, this.blobUrl, this.dprMax, this.fov, this.fitEnabled, this.limits, this.bbox, this.target, this.raycaster, this.pointerNdc, this.highlighted, this.prevEmissive, this.prevEmissiveIntensity, this.unbindWheelRelay];
+    void [
+      this.canvas,
+      this.perspCam,
+      this.orthoCam,
+      this.root,
+      this.content,
+      this.lights,
+      this.loader,
+      this.loadToken,
+      this.blobUrl,
+      this.dprMax,
+      this.fov,
+      this.fitEnabled,
+      this.limits,
+      this.bbox,
+      this.target,
+      this.raycaster,
+      this.pointerNdc,
+      this.highlighted,
+      this.prevEmissive,
+      this.prevEmissiveIntensity,
+      this.unbindWheelRelay,
+    ];
   }
 
   get ready() {
@@ -79,6 +123,9 @@ export class SceneRuntime {
   get isLost() {
     return this.renderer.getContext()?.isContextLost?.() ?? false;
   }
+  get hasPostFx() {
+    return this.postFx.isEnabled;
+  }
 
   setDprMax(v: number) {
     tune.setDprMax(this.asTuneCtx(), v);
@@ -95,6 +142,15 @@ export class SceneRuntime {
   setAutoRotate(v: boolean) {
     tune.setAutoRotate(this.asTuneCtx(), v);
   }
+  setDamping(v: number) {
+    this.damping = Number.isFinite(v) ? Math.max(0, v) : 0.08;
+    tune.setDamping(this.asTuneCtx(), this.damping);
+  }
+  /** Coupe autoRotate + inertie OrbitControls. */
+  stopMotion() {
+    tune.setAutoRotate(this.asTuneCtx(), false);
+    tune.stopMotion(this.asTuneCtx());
+  }
   setOrbitLimits(opts: Parameters<typeof tune.setOrbitLimits>[1]) {
     tune.setOrbitLimits(this.asTuneCtx(), opts);
   }
@@ -104,9 +160,17 @@ export class SceneRuntime {
 
   applyCameraMode(mode: Sonic3dCameraMode) {
     view.applyCameraMode(this.asViewCtx(), mode);
+    tune.setDamping(this.asTuneCtx(), this.damping);
   }
   resize(cssW: number, cssH: number) {
+    this.lastCssW = cssW;
+    this.lastCssH = cssH;
     view.resize(this.asViewCtx(), cssW, cssH);
+    const dpr = Math.min(
+      typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+      this.dprMax,
+    );
+    this.postFx.resize(cssW * dpr, cssH * dpr);
   }
   async load(asset: Sonic3dAsset | null) {
     return ops.runLoad(this.asOpsCtx(), asset);
@@ -114,9 +178,34 @@ export class SceneRuntime {
   fitToContent() {
     ops.fitToContent(this.asOpsCtx());
   }
+
+  setPostConfig(config: PostFxConfig | null) {
+    this.postFx.setConfig(config);
+    if (config && this.lastCssW > 0) {
+      this.resize(this.lastCssW, this.lastCssH);
+    }
+  }
+
+  setPostElementResolver(fn: ((key: string) => Element | null) | null) {
+    this.postFx.setElementResolver(fn);
+  }
+
+  setPostFrame(frame: Partial<PostFxUniforms>) {
+    Object.assign(this.postFrame, frame);
+    const cam = this.activeCam as THREE.PerspectiveCamera;
+    if ("near" in cam && "far" in cam) {
+      this.postFrame.near = cam.near;
+      this.postFrame.far = cam.far;
+    }
+  }
+
   render() {
     this.controls?.update();
-    this.renderer.render(this.scene, this.activeCam);
+    if (this.postFx.isEnabled) {
+      this.postFx.render(this.scene, this.activeCam, this.postFrame);
+    } else {
+      this.renderer.render(this.scene, this.activeCam);
+    }
   }
   pick(normX: number, normY: number): SceneHit | null {
     return ops.pick(this.asOpsCtx(), normX, normY);
@@ -138,6 +227,7 @@ export class SceneRuntime {
     return ops.buildSnapshot(this.asOpsCtx(), base);
   }
   dispose(loseContext = false) {
+    this.postFx.dispose();
     ops.dispose(this.asOpsCtx(), loseContext);
   }
 
@@ -145,4 +235,3 @@ export class SceneRuntime {
   private asViewCtx = () => this as unknown as ViewCtx;
   private asOpsCtx = () => this as unknown as OpsCtx;
 }
-

package/src/core/components/functional/3d/scene-runtime.ts

@@ -4,6 +4,9 @@
  */
 export {
   SceneRuntime,
+  PostFxCompileError,
   type SceneHit,
   type SceneRuntimeOptions,
+  type PostFxConfig,
+  type PostFxUniforms,
 } from "./runtime";

package/src/core/components/functional/3d/tune.ts

@@ -37,6 +37,25 @@ function setAutoRotate(ctx: TuneCtx, v: boolean) {
   if (ctx.controls) ctx.controls.autoRotate = v;
 }
 
+function setDamping(ctx: TuneCtx, v: number) {
+  if (!ctx.controls) return;
+  const d = Number.isFinite(v) ? Math.max(0, v) : 0.08;
+  ctx.controls.enableDamping = d > 0;
+  ctx.controls.dampingFactor = d > 0 ? d : 0.08;
+}
+
+/** Coupe autoRotate + vide l’inertie OrbitControls. */
+function stopMotion(ctx: TuneCtx) {
+  if (!ctx.controls) return;
+  ctx.controls.autoRotate = false;
+  const wasDamping = ctx.controls.enableDamping;
+  const factor = ctx.controls.dampingFactor;
+  ctx.controls.enableDamping = false;
+  ctx.controls.update();
+  ctx.controls.enableDamping = wasDamping;
+  ctx.controls.dampingFactor = factor;
+}
+
 function setOrbitLimits(ctx: TuneCtx, opts: Partial<OrbitLimits>) {
   ctx.limits = orbit.mergeLimits(ctx.limits, opts);
   orbit.applyLimitsToControls(ctx.controls, ctx.limits);
@@ -67,6 +86,8 @@ export const tune = {
   setFov,
   setFit,
   setAutoRotate,
+  setDamping,
+  stopMotion,
   setOrbitLimits,
   setOrbitSpherical,
 } as const;

package/src/core/components/functional/3d/types.ts

@@ -65,6 +65,13 @@ export type Sonic3dConfig = {
   playOnHover?: boolean;
   /** Libère le renderer hors viewport (défaut true). */
   releaseOffscreen?: boolean;
+  /**
+   * Garde RAF / runtime hors viewport (pont live).
+   * Aussi auto via `registerFrameConsumer`.
+   */
+  playOffscreen?: boolean;
+  /** Inertie OrbitControls (défaut 0.08, 0 = off). */
+  damping?: number;
   dprMax?: number;
   aspectRatio?: string;
 
@@ -124,6 +131,8 @@ export type Sonic3dOutput = {
   distance: number;
   yaw: number;
   pitch: number;
+  /** 1 si la caméra bouge (orbit / inertie / autoRotate), sinon 0. */
+  moving?: number;
   /** Présents après un pick réussi. */
   hitX?: number;
   hitY?: number;
@@ -142,4 +151,9 @@ export type Sonic3dOutput = {
   frameUrl?: string;
   /** MediaRef du canvas (url + dimensions) — chaînable vers `sonic-shader`. */
   snapshot?: Sonic3dSnapshot;
+  /**
+   * Pont live (Lot 1) : `{ element: sonic-3d }` pour `channel0` sans JPEG.
+   * Publié une fois au ready si un lecteur écoute `frameSource`.
+   */
+  frameSource?: { element: Element };
 };

package/src/core/components/functional/3d/updated.ts

@@ -3,6 +3,7 @@ import type { LifeHost } from "./life";
 import { life } from "./life";
 import { parse } from "./parse";
 import { playback } from "./playback";
+import { postBind } from "./post-bind";
 import { reload } from "./reload";
 
 function hasAny(
@@ -61,10 +62,25 @@ function updated(
   if (changed.has("autoRotate") || changed.has("play")) {
     playback.syncAutoRotate(host as never);
   }
-  if (changed.has("play") || changed.has("playOnHover")) {
+  if (
+    changed.has("play") ||
+    changed.has("playOnHover") ||
+    changed.has("playOffscreen")
+  ) {
     host.syncPlayback();
   }
+  if (changed.has("playOffscreen") || changed.has("releaseOffscreen")) {
+    ensure.syncVisibility(host as never);
+  }
+  if (changed.has("damping") && host.runtime) {
+    host.runtime.setDamping(
+      (host as unknown as { damping: number }).damping,
+    );
+  }
   if (changed.has("src") || changed.has("asset")) void reload.run(host as never);
+  if (postBind.propsChanged(changed)) {
+    postBind.applyConfig(host as never);
+  }
 }
 
 export const propUpdate = { updated } as const;