@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiPreludeSurface.d.ts

@@ -0,0 +1,203 @@
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+export interface PreludeSurfaceLayout {
+    participantArea: PixiLayoutRect;
+    participantPhoto: {
+        width: number;
+        height: number;
+    };
+    participantFrame: {
+        width: number;
+        height: number;
+    };
+    participantImageRect: PixiLayoutRect;
+    participantLabel: PixiLayoutRect & {
+        fontSize: number;
+    };
+    modulePhoto: PixiLayoutRect;
+    moduleFrame: PixiLayoutRect;
+    moduleImageRect: PixiLayoutRect;
+    smokeOrigin: {
+        x: number;
+        y: number;
+    };
+    lampLightArea: PixiLayoutRect;
+}
+export interface PreludeSurfacePorts {
+    logger: RuntimeLogger;
+    stage: {
+        width: number;
+        height: number;
+    };
+    layout: PreludeSurfaceLayout;
+    maxParticipants: number;
+    portraitColumns: number;
+    portraitGap: number;
+    typography: ReturnType<typeof createPixiTypography>;
+    colors: {
+        desk: string;
+        mask: string;
+        text: string;
+    };
+    photoColors: {
+        preludeParticipantLabel: string;
+    };
+    ambient: {
+        lamp: {
+            baseAlpha: number;
+            color: string;
+            flickerBurstGapMaxMs: number;
+            flickerBurstGapMinMs: number;
+            flickerBurstMaxPulses: number;
+            flickerBurstMinPulses: number;
+            flickerDimming: number;
+            flickerDurationMs: number;
+            flickerIntervalMaxMs: number;
+            flickerIntervalMinMs: number;
+            flickerTransitionMs: number;
+        };
+        smoke: {
+            blurStrength: number;
+            color: string;
+            fillAlpha: number;
+            riseDistance: number;
+        };
+    };
+}
+import type { BlurFilter, ColorMatrixFilter, Container, Graphics, Mesh, MeshGeometry, Shader, Sprite, Text, Texture, Ticker, UniformGroup } from 'pixi.js';
+export interface PreludeParticipant {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+}
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { createPixiTypography } from './PixiTypography.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import { type SessionDisplayPreludeFrameTextures } from './PixiSessionSkin.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+import type { PixiVideoRuntime } from './PixiVideoRuntime.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    ColorMatrixFilter: typeof ColorMatrixFilter;
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Mesh: typeof Mesh;
+    MeshGeometry: typeof MeshGeometry;
+    Shader: typeof Shader;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+    UniformGroup: typeof UniformGroup;
+}
+export interface PreludeStoryPortraitProxy {
+    readonly id: string;
+    readonly root: Container;
+}
+export interface PreludeStoryTransitionArtwork {
+    readonly root: Container;
+    readonly module: {
+        readonly root: Container;
+        readonly image: Sprite | null;
+        readonly width: number;
+        readonly height: number;
+        readonly textureSize: {
+            readonly width: number;
+            readonly height: number;
+        } | null;
+        readonly targetImagePosition: {
+            readonly x: number;
+            readonly y: number;
+        } | null;
+        readonly targetImageScale: {
+            readonly x: number;
+            readonly y: number;
+        } | null;
+    };
+    readonly portraits: readonly PreludeStoryPortraitProxy[];
+    readonly releaseMediaBreath?: () => void;
+}
+export declare class PixiPreludeSurface {
+    private readonly assets;
+    private readonly constructors;
+    private readonly ticker;
+    private readonly activity;
+    private readonly requestRender;
+    private readonly ports;
+    private readonly frameTextures;
+    private tuning?;
+    private readonly mediaBreath?;
+    private readonly videoRuntime?;
+    private disposed;
+    private readonly resourceScope;
+    readonly node: Container;
+    readonly modulePhotoAnchor: Container;
+    private readonly photos;
+    private readonly photosMask;
+    private readonly photoLampOverlayLayer;
+    private readonly photoNodes;
+    private readonly dust;
+    private readonly smoke;
+    private readonly smokeLayer;
+    private readonly smokeBlur;
+    private readonly lampLayer;
+    private readonly lampGlow;
+    private readonly photoLampGlow;
+    private readonly backgroundSprite;
+    private readonly ambientFilter;
+    private readonly moduleMask;
+    private readonly moduleFrame;
+    private active;
+    private elapsed;
+    private nextLampBurstAt;
+    private nextLampPulseAt;
+    private lampDimUntil;
+    private lampBurstPulsesRemaining;
+    private lampTargetAlpha;
+    private lampCurrentAlpha;
+    private ambientRandomStep;
+    private releaseActivity;
+    private moduleImage;
+    private moduleMediaBreath;
+    private moduleVideoBinding;
+    private moduleMediaReady;
+    private moduleMediaFailed;
+    private moduleKey;
+    private moduleVersion;
+    private participants;
+    private storyTransitionActive;
+    private uiHighlightMultiplier;
+    private readonly releaseUiHighlight;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, constructors: Constructors, ticker: Ticker, activity: PixiAnimationActivity, requestRender: () => void, skinTexture: Texture | null, ports: PreludeSurfacePorts, frameTextures?: SessionDisplayPreludeFrameTextures, tuning?: SessionTuningResolver | undefined, mediaBreath?: PixiMediaBreathRuntime | undefined, videoRuntime?: PixiVideoRuntime | undefined);
+    sync(participants: PreludeParticipant[], moduleImageUrl: string | null, moduleVideoUrlOrVisible: string | null | boolean, visibleValue?: boolean): void;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    previewAmbient(): void;
+    createStoryTransitionArtwork(): PreludeStoryTransitionArtwork;
+    restoreStoryTransitionPose(): void;
+    reset(): void;
+    destroy(): void;
+    private syncParticipants;
+    private createPhotoNode;
+    private syncParticipantAvatar;
+    private syncStoryTransitionPortraitSources;
+    private loadModuleImage;
+    waitForVideoReady(imageUrl: string | null, videoUrl: string, signal: AbortSignal): Promise<boolean>;
+    private upgradeModuleImageToVideo;
+    private syncActivity;
+    private update;
+    private resolveLampFlickerInterval;
+    private syncLayout;
+    private resolveModuleFrame;
+    private resolveModuleImageRect;
+    private configureLampGlow;
+    private resolveLampLightArea;
+    private resolveTuningNumber;
+    private triggerLampPulse;
+    private nextAmbientRandom;
+}
+export declare const resolvePreludePhotoRects: (participantIds: readonly string[], layout: PreludeSurfaceLayout, options: {
+    maxCount: number;
+    columns: number;
+    gap: number;
+}) => PixiLayoutRect[];
+export {};

package/dist/PixiProgressCinematic.d.ts

@@ -0,0 +1,65 @@
+import type { Container, Texture } from 'pixi.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { SessionTuningResolver, SessionTuningPath } from '@bardway/trpg-media/tuning';
+export interface ProgressCinematicInstruction {
+    id: string;
+    label: string;
+    kind: 'start' | 'progress' | 'success' | 'failure';
+    totalCount: number;
+    fromCount: number;
+    toCount: number;
+}
+export interface ProgressCinematicContext {
+    scene: PixiSceneGraph;
+    director: PixiAnimationDirector;
+    constructors: Pick<typeof import('pixi.js'), 'Container' | 'Sprite' | 'Graphics' | 'Text' | 'BlurFilter' | 'Rectangle'>;
+    getTuning(): SessionTuningResolver | undefined;
+    stage: {
+        width: number;
+        height: number;
+    };
+    maxCount: number;
+    defaultLabel: string;
+    fontFamily: string;
+    titleColor: string;
+    panelColor: string;
+    borderColor: string;
+    panel: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    frameTexture: Texture | null;
+    createBackdrop(): Container;
+    releaseBackdrop(node: Container): void;
+    playCue(kind: 'start' | 'increment' | 'decrement' | 'success' | 'failure'): void;
+    resolveColor(path: SessionTuningPath, fallback: string | number): string | number;
+}
+export declare class PixiProgressCinematic {
+    private readonly context;
+    private lifetime;
+    private teamCheckRoot;
+    private teamCheckStrands;
+    private teamCheckGlowLayer;
+    private teamCheckGlowFilter;
+    private teamCheckOwnerKey;
+    private teamCheckTitle;
+    private teamCheckLights;
+    private uiHighlightMultiplier;
+    constructor(context: ProgressCinematicContext);
+    setHighlightMultiplier(value: number): void;
+    reset(): void;
+    destroy(): void;
+    play(event: ProgressCinematicInstruction, signal: AbortSignal): Promise<void>;
+    private ensureTeamCheck;
+    private createTeamCheckFrame;
+    private createTeamCheckFallbackPanel;
+    private createTeamCheckLamp;
+    private syncTeamCheckLights;
+    private resolveTeamCheckFailureKeyframes;
+    private resolveTuningNumber;
+    private resolveTuningColor;
+    private releaseTeamCheck;
+}

package/dist/PixiResultEffectSurface.d.ts

@@ -0,0 +1,101 @@
+import type { Container } from 'pixi.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+export interface ResultLandingPoint {
+    id: string;
+    x: number;
+    y: number;
+}
+import { type ResultEffectTuning, type VisualResultEffect } from './ResultEffectTuning.js';
+export interface PixiResultEffectConstructors {
+    readonly Container: typeof import('pixi.js').Container;
+    readonly Mesh: typeof import('pixi.js').Mesh;
+    readonly MeshGeometry: typeof import('pixi.js').MeshGeometry;
+    readonly Shader: typeof import('pixi.js').Shader;
+    readonly Sprite: typeof import('pixi.js').Sprite;
+    readonly UniformGroup: typeof import('pixi.js').UniformGroup;
+}
+export interface PixiResultEffectSurfaceOptions {
+    readonly parent: Container;
+    readonly constructors: PixiResultEffectConstructors;
+    readonly director: PixiAnimationDirector;
+    readonly assets: PixiAssetManager;
+    readonly requestRender: () => void;
+    readonly tuning: ResultEffectTuning;
+    readonly stage: {
+        width: number;
+        height: number;
+    };
+    readonly imageUrl: string;
+    readonly scope: string;
+    readonly targetCount: number;
+    readonly logger: RuntimeLogger;
+}
+export interface ResultEffectDiagnostics {
+    readonly activeEffect: VisualResultEffect | null;
+    readonly objectCount: number;
+    readonly estimatedDrawCalls: number;
+    readonly pixelCoverageRatio: number;
+}
+export declare const hashResultEffectSeed: (seed: string) => number;
+export declare const sampleRectangularEdgeAlpha: (x: number, y: number, edgeDepthPx: number, softnessPx: number, stage: {
+    width: number;
+    height: number;
+}) => number;
+export declare const sampleImageBurstUnfold: (elapsedMs: number, revealMs: number, expandMs: number, endScale: number) => {
+    envelope: number;
+    rotation: number;
+    scale: number;
+};
+export declare const normalizeResultLandingPoints: (points: readonly ResultLandingPoint[], tuning: ResultEffectTuning, count: number) => readonly ResultLandingPoint[];
+/** Retained Pixi result FX placed below the Three dice canvas and system HUD. */
+export declare class PixiResultEffectSurface {
+    private readonly options;
+    private readonly root;
+    private readonly edgeMesh;
+    private readonly edgeGeometry;
+    private readonly edgeShader;
+    private readonly edgeUniformGroup;
+    private readonly burstMeshes;
+    private readonly burstGeometries;
+    private readonly burstShaders;
+    private readonly burstUniformGroups;
+    private failureSprites;
+    private failureTexture;
+    private failureTexturePromise;
+    private assetWarningLogged;
+    private activeController;
+    private activeEffect;
+    private activeLandingPoints;
+    private sourceLandingPoints;
+    private edgeEnvelope;
+    private failureEnvelope;
+    private failureScaleFactor;
+    private failureRotation;
+    private reducedMotion;
+    private destroyed;
+    private tuning;
+    constructor(options: PixiResultEffectSurfaceOptions);
+    prewarm(): Promise<void>;
+    play(effect: VisualResultEffect, landingPoints: readonly ResultLandingPoint[], seed: string, signal: AbortSignal): Promise<void>;
+    updateTuning(tuning: ResultEffectTuning): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    reset(): void;
+    diagnostics(): ResultEffectDiagnostics;
+    destroy(): void;
+    private playEdge;
+    private playCriticalFailure;
+    private playCriticalSuccess;
+    private wait;
+    private waitForFailureTexture;
+    private applyEdgeVisuals;
+    private applyFailureLayout;
+    private applyFailureVisuals;
+    private failureBaseScale;
+    private applyBurstVisuals;
+    private ensureFailureSprites;
+    private hideAll;
+    private createEdgeMesh;
+    private createBurstMesh;
+}

package/dist/PixiRetainedMeterAnimator.d.ts

@@ -0,0 +1,44 @@
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+export interface PixiRetainedMeterView {
+    setRatio(ratio: number): void;
+    setFlashAlpha(alpha: number): void;
+}
+export interface PixiRetainedMeterSnapshot {
+    readonly displayedRatio: number;
+    readonly targetRatio: number;
+    readonly initialized: boolean;
+}
+export interface PixiRetainedMeterAnimationOptions {
+    readonly flashDuration: number;
+    readonly transitionDuration: number;
+}
+/**
+ * Animates a retained meter from its currently rendered value. Snapshot syncs
+ * may replace the target while a tween is active without snapping back to the
+ * prior authoritative value.
+ */
+export declare class PixiRetainedMeterAnimator {
+    private readonly animation;
+    private readonly view;
+    private readonly requestRender;
+    private displayedRatio;
+    private targetRatio;
+    private initialized;
+    private reducedMotion;
+    private controller;
+    private options;
+    constructor(animation: PixiAnimationDirector, view: PixiRetainedMeterView, requestRender: () => void, options?: Partial<PixiRetainedMeterAnimationOptions>);
+    updateOptions(options: Partial<PixiRetainedMeterAnimationOptions>): void;
+    sync(ratio: number, options?: {
+        immediate?: boolean;
+    }): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    settle(ratio?: number): void;
+    reset(): void;
+    destroy(): void;
+    getSnapshot(): PixiRetainedMeterSnapshot;
+    private play;
+    private applyRatio;
+    private applyFlash;
+    private normalizeOptions;
+}

package/dist/PixiRuntimeContext.d.ts

@@ -0,0 +1,21 @@
+import type { Application, Assets } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiViewportController } from './PixiViewportController.js';
+import type { StageRenderQuality } from './PixiApplicationFactory.js';
+export type PixiRuntimeApi = typeof import('pixi.js');
+export interface PixiRuntimeContext {
+    readonly app: Application;
+    readonly pixi: PixiRuntimeApi;
+    readonly assetsApi: typeof Assets;
+    readonly scene: PixiSceneGraph;
+    readonly activity: PixiAnimationActivity;
+    readonly assets: PixiAssetManager;
+    readonly animation: PixiAnimationDirector;
+    readonly viewport: PixiViewportController;
+    readonly quality: StageRenderQuality;
+    requestRender(): void;
+}
+export declare const createPixiRuntimeContext: (context: PixiRuntimeContext) => PixiRuntimeContext;

package/dist/PixiSceneGraph.d.ts

@@ -0,0 +1,42 @@
+import type { Container } from 'pixi.js';
+export type PixiContainerConstructor = new () => Container;
+export interface PixiSceneGraph {
+    readonly root: Container;
+    readonly backgroundLayer: Container;
+    /** Battle-world shake transform. The semantic camera remains its child. */
+    readonly worldShakeLayer: Container;
+    /** Additive hit reaction between field shake and semantic camera transforms. */
+    readonly cameraImpactLayer: Container;
+    readonly cameraContainer: Container;
+    readonly viewportMaskLayer: Container;
+    readonly mapLayer: Container;
+    readonly gridLayer: Container;
+    readonly worldUnderlayFxLayer: Container;
+    readonly tokenLayer: Container;
+    readonly tokenStatusLayer: Container;
+    readonly worldOverlayFxLayer: Container;
+    readonly fieldFxLayer: Container;
+    readonly cinematicLayer: Container;
+    /** Top-level transient battle illustration surface. */
+    readonly battlePictureFxLayer: Container;
+    /** Top-level combo photo surface, above battle illustrations. */
+    readonly comboFxLayer: Container;
+    readonly globalFxLayer: Container;
+    /** Fixed-stage surfaces that are not part of the battle camera. */
+    readonly presentationLayer: Container;
+    readonly screenFxLayer: Container;
+    readonly sceneHudLayer: Container;
+    /** @deprecated Migration-only alias. New scene UI must use sceneHudLayer. */
+    readonly modalLayer: Container;
+    readonly systemHudLayer: Container;
+    /** Unmasked Story illustration entrance, above UI and below active Global FX. */
+    readonly storyEntranceLayer: Container;
+    readonly debugLayer: Container;
+}
+export interface PixiSessionEffectLayerPlacement {
+    readonly fieldAboveUi: boolean;
+    readonly globalAboveUi: boolean;
+}
+export declare const DEFAULT_PIXI_SESSION_EFFECT_LAYER_PLACEMENT: PixiSessionEffectLayerPlacement;
+export declare const placePixiSessionEffectLayers: (scene: PixiSceneGraph, profile: "story" | "battle", placement?: PixiSessionEffectLayerPlacement, storyEntranceActive?: boolean) => void;
+export declare const createPixiSceneGraph: (ContainerConstructor: PixiContainerConstructor) => PixiSceneGraph;

package/dist/PixiSceneMotion.d.ts

@@ -0,0 +1,41 @@
+import type { ScenePictureInstruction, ImageBurstInstruction, PixiSceneMotionContext, PixiSceneMotionPorts } from './PixiSceneMotionPorts.js';
+export declare function resolveScenePictureLayout(stage: {
+    width: number;
+    height: number;
+}, source: {
+    width: number;
+    height: number;
+}, direction: -1 | 1, bounds: {
+    maxWidth: number;
+    maxHeight: number;
+    allowUpscale?: boolean;
+}): {
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+    entryX: number;
+    driftX: number;
+    exitX: number;
+};
+export declare class PixiSceneMotion {
+    private readonly context;
+    private readonly ports;
+    private readonly active;
+    private closed;
+    private scopeSequence;
+    private readonly fxResources;
+    constructor(context: PixiSceneMotionContext, ports: PixiSceneMotionPorts);
+    playPicture(event: ScenePictureInstruction, signal: AbortSignal): Promise<void>;
+    playImageBurst(event: ImageBurstInstruction, signal: AbortSignal): Promise<void>;
+    playTitle(label: string, signal: AbortSignal): Promise<void>;
+    playCounter(label: string, signal: AbortSignal): Promise<void>;
+    reset(): void;
+    destroy(): void;
+    private run;
+    private resolveTuningNumber;
+    private playBattlePicture;
+    private playBurst;
+    private playCinematicTitle;
+    private playRoundFlip;
+}

package/dist/PixiSceneMotionPorts.d.ts

@@ -0,0 +1,83 @@
+import type { TextStyleOptions } from 'pixi.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiBattleFxResourceOwner } from './PixiBattleFxResources.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiShaderRuntime } from './PixiShaderRuntime.js';
+import type { PixiVideoRuntime } from './PixiVideoRuntime.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+import type { SessionTuningPath } from './tuning/SessionTuningTypes.js';
+export interface ScenePictureInstruction {
+    id: string;
+    imageUrl: string;
+    mediaKind: 'image' | 'video';
+    videoUrl?: string;
+    direction: -1 | 1;
+    rotationRadians: number;
+    /** Host-supplied deterministic visual random seed, 0..1. */
+    seed: number;
+}
+export interface ImageBurstInstruction {
+    id: string;
+    participants: readonly {
+        id: string;
+        imageUrl?: string;
+        tint: string;
+    }[];
+    seed: number;
+}
+export interface PixiSceneMotionPorts {
+    stage: {
+        width: number;
+        height: number;
+    };
+    /** Unique for instances sharing an AssetManager. */
+    assetScopePrefix: string;
+    defaultImageUrl: string;
+    reducedMotion(): boolean;
+    number?(path: SessionTuningPath): unknown;
+    colors: {
+        cinematic: string;
+        transition: string;
+        borderStrong: string;
+        pictureVeil: string;
+        shadow: string;
+        mask: string;
+        roundShade: string;
+        roundDepth: string;
+    };
+    typography: {
+        title: TextStyleOptions;
+        round: TextStyleOptions;
+    };
+    burstBounds: PixiLayoutRect;
+    burstEntryMargin: number;
+    roundShade: PixiLayoutRect;
+    roundEntryY: number;
+    roundExitY: number;
+    lightning: {
+        offsetY: number;
+        amplitude: number;
+        hue: number;
+        speed: number;
+        intensity: number;
+        size: number;
+        alpha: number;
+    };
+    playPictureSound?(): void;
+    playBurstSound?(): void;
+}
+export interface PixiSceneMotionContext {
+    constructors: Pick<typeof import('pixi.js'), 'Container' | 'Graphics' | 'Sprite' | 'Text' | 'BlurFilter' | 'Rectangle'>;
+    scene: Pick<PixiSceneGraph, 'battlePictureFxLayer' | 'comboFxLayer' | 'cinematicLayer'>;
+    assets: Pick<PixiAssetManager, 'loadTexture' | 'releaseScope'>;
+    director: PixiAnimationDirector;
+    activity?: PixiAnimationActivity;
+    fxResources: Pick<PixiBattleFxResourceOwner, 'acquireSpeedLines' | 'getSpeedLineUniforms' | 'release' | 'acquireBlurFilter' | 'releaseBlurFilter'>;
+    shaderRuntime: Pick<PixiShaderRuntime, 'create' | 'release'>;
+    videoRuntime?: Pick<PixiVideoRuntime, 'loadBinding'>;
+    mediaBreath?: Pick<PixiMediaBreathRuntime, 'attach'>;
+    requestRender(): void;
+}