@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiScenePresentationDirector.d.ts

@@ -0,0 +1,118 @@
+import type { BlurFilter, Container, Filter, Graphics, Particle, ParticleContainer, Rectangle, Sprite, Text, Texture } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiSummaryBoardSurface, SummaryBoardData } from './PixiSummaryBoardSurface.js';
+import type { PixiPreludeSurface } from './PixiPreludeSurface.js';
+import type { PixiStorySurface, StoryMediaContent } from './PixiStorySurface.js';
+import type { PixiEndingSurface } from './PixiEndingSurface.js';
+import type { PixiPartyHudSurface } from './PixiPartyHudSurface.js';
+import type { PixiBattleHudSurface } from './PixiBattleHudSurface.js';
+import type { PixiStoryWorkspaceSurface } from './PixiStoryWorkspaceSurface.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { BattleViewportGridLayout, PixiLayoutRect } from './PixiSessionLayout.js';
+import type { SessionTuningResolver } from '@bardway/trpg-media/tuning';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Filter?: typeof Filter;
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Particle: typeof Particle;
+    ParticleContainer: typeof ParticleContainer;
+    Rectangle: typeof Rectangle;
+    Sprite?: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: typeof Text;
+    Texture: typeof Texture;
+}
+export interface ScenePresentationFrame {
+    owner: string;
+    revision: number;
+    scene: 'prelude' | 'story' | 'battle' | 'ending';
+    hydrate: boolean;
+    map?: {
+        layout: BattleViewportGridLayout;
+        imageUrl: string;
+        videoUrl?: string;
+    };
+    storyContent: StoryMediaContent | null;
+    endingImageUrl: string | null;
+    endPresentation: 'direct' | 'summary';
+}
+export interface ScenePresentationSurfaces {
+    prelude: Pick<PixiPreludeSurface, 'node' | 'createStoryTransitionArtwork'>;
+    story: Pick<PixiStorySurface, 'node' | 'mainImageAnchor' | 'mainBackdrop' | 'leftPanelNode' | 'rightPanelNode' | 'waitForPresentationContentReady' | 'getMainBackdropTargetAlpha' | 'resetTransitionPose'>;
+    ending: Pick<PixiEndingSurface, 'waitForPhotoReady' | 'playTimeline'>;
+    partyHud: Pick<PixiPartyHudSurface, 'getPreludeStoryEntries'>;
+    battleHud?: Pick<PixiBattleHudSurface, 'prepareBattleEntry' | 'finishBattleEntry' | 'cancelBattleEntry'>;
+    caseWorkspace: Pick<PixiStoryWorkspaceSurface, 'node'>;
+    preparePreludeToStory(frame: ScenePresentationFrame): void;
+    preparePreludeToStoryHandoff(): void;
+    restorePreludeToStoryTransition(story: boolean): void;
+    sync(frame: ScenePresentationFrame): void;
+    reset(): void;
+    getTransitionNumber(key: string, fallback: number): number;
+    getTransitionString(key: string, fallback: string): string;
+}
+export interface ScenePresentationDirectorOptions {
+    summary: PixiSummaryBoardSurface;
+    summaryData(frame: ScenePresentationFrame): SummaryBoardData;
+    stage: {
+        width: number;
+        height: number;
+    };
+    mediaRect: PixiLayoutRect;
+    colors: {
+        transition: string;
+        mask: string;
+        gridLine: string;
+    };
+    tuning?: SessionTuningResolver;
+    resolveExitTarget(frame: ScenePresentationFrame): ScenePresentationFrame;
+    waitForMapReady(frame: ScenePresentationFrame, signal: AbortSignal, timeoutMs: number): Promise<'ready' | 'fallback'>;
+    onTransitionStarted?(frame: ScenePresentationFrame, signal: AbortSignal): void;
+    onCommitted?(frame: ScenePresentationFrame): void;
+}
+/** Owns scene commits and every cross-scene transition. Surfaces never call each other. */
+export declare class PixiScenePresentationDirector {
+    private readonly scene;
+    private readonly surfaces;
+    private readonly animation;
+    private readonly activity;
+    private readonly constructors;
+    private readonly requestRender;
+    private readonly commit;
+    private readonly options;
+    private committed;
+    private transitionAbort;
+    private activeBattleTransition;
+    private reducedMotion;
+    private preludeStoryTransitionActive;
+    private readonly summary;
+    private activeBattleEntryVisuals;
+    private activeBattleExitVisuals;
+    private tuning;
+    private readonly waitForBattleMapReady;
+    constructor(scene: PixiSceneGraph, surfaces: ScenePresentationSurfaces, animation: PixiAnimationDirector, activity: PixiAnimationActivity, constructors: Constructors, requestRender: () => void, commit: (snapshot: ScenePresentationFrame) => void, options: ScenePresentationDirectorOptions);
+    sync(next: ScenePresentationFrame): Promise<void>;
+    setReducedMotion(reducedMotion: boolean): void;
+    updateTuning(tuning: SessionTuningResolver): void;
+    reset(): void;
+    destroy(): void;
+    private commitSnapshot;
+    private commitBattleSnapshotIfNew;
+    private waitForBattleEntryMapSnapshot;
+    private playPreludeToStory;
+    private playBattleEntry;
+    private playBattleExit;
+    private playEnding;
+    private revealEndingFromBlack;
+    private createBattleEntryVisuals;
+    private createModalVeil;
+    private createVeil;
+    private beginTransition;
+    private cancelTransition;
+    private restoreSceneTransitionPose;
+    private transitionNumber;
+    private resolveBattleExitTarget;
+    private resolvePreludeStoryTiming;
+}
+export {};

package/dist/PixiSessionLayout.d.ts

@@ -0,0 +1,61 @@
+export interface PixiLayoutRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PixiLayoutCenter {
+    x: number;
+    y: number;
+}
+/** Builds a rect from a stable visual center for all image-layout scaling. */
+export declare const resolvePixiLayoutRectAtCenter: (center: PixiLayoutCenter, size: Pick<PixiLayoutRect, "width" | "height">) => PixiLayoutRect;
+export declare const resizePixiLayoutRectFromCenter: (rect: PixiLayoutRect, size: Pick<PixiLayoutRect, "width" | "height">) => PixiLayoutRect;
+export interface BattleViewportGridLayout extends PixiLayoutRect {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+    offsetX: number;
+    offsetY: number;
+    renderW: number;
+    renderH: number;
+}
+export declare const stablePortraitRotation: (id: string) => number;
+export declare const stableSeededRotation: (id: string, maxDegrees: number, salt?: string) => number;
+/** Stable integer jitter for casually placed repeated cards; never returns zero. */
+export declare const stableSeededPixelOffset: (id: string, minPixels?: number, maxPixels?: number, salt?: string) => number;
+export declare const clampResourceRatio: (current: number | undefined, max: number | undefined) => number;
+export declare const normalizedPositionToScreen: (position: {
+    x: number;
+    y: number;
+}, rect: PixiLayoutRect) => {
+    x: number;
+    y: number;
+};
+export declare const resolveBattleViewportGridLayout: (map: {
+    size: {
+        width: number;
+        height: number;
+    };
+    grid: {
+        cols: number;
+        rows: number;
+    };
+}, viewport: PixiLayoutRect) => BattleViewportGridLayout;
+export interface PixiMosaicTile extends PixiLayoutRect {
+    col: number;
+    row: number;
+    order: number;
+}
+export declare const createBattleMosaicTiles: (layout: BattleViewportGridLayout, transitionId: string) => PixiMosaicTile[];
+export interface ComboSlashRegion {
+    index: number;
+    points: number[];
+    bounds: PixiLayoutRect;
+}
+export declare const createComboSlashRegions: (participantCount: number, bounds?: PixiLayoutRect) => ComboSlashRegion[];
+export declare const PIXI_SESSION_STAGE: {
+    readonly width: 1920;
+    readonly height: 1080;
+};

package/dist/PixiSessionSkin.d.ts

@@ -0,0 +1,30 @@
+import type { Sprite, Texture } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+export interface PixiSkinEntry<TId extends string> {
+    id: TId;
+    alias: string;
+    uri: string;
+    scope: string;
+    required: boolean;
+}
+/** Preserves parallel scoped loading while the host supplies its complete skin manifest. */
+export declare function preloadPixiSkin<TId extends string>(assets: PixiAssetManager, entries: readonly PixiSkinEntry<TId>[], logger: RuntimeLogger, signal?: AbortSignal): Promise<ReadonlyMap<TId, Texture | null>>;
+type SpriteConstructor = new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+export declare const createStageSkinSprite: (SpriteConstructor: SpriteConstructor, texture: Texture, stage?: {
+    width: number;
+    height: number;
+}) => Sprite;
+export declare const syncStageSkinSprite: (sprite: Sprite, texture?: Texture, stage?: {
+    width: number;
+    height: number;
+}) => void;
+export interface SessionDisplayPreludeFrameTextures {
+    moduleFrame: Texture | null;
+    playerFrame: Texture | null;
+}
+export interface SessionDisplayCaseWorkspaceTextures {
+    shell: Texture | null;
+    panel: Texture | null;
+}
+export {};

package/dist/PixiShaderRuntime.d.ts

@@ -0,0 +1,191 @@
+import type { Filter, Rectangle, Sprite, Texture, Ticker, UniformGroup } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+export type PixiShaderEffectId = 'galaxy' | 'prismaticBurst' | 'sideRays' | 'lightning' | 'lightPillar' | 'lineWaves' | 'teamCheckStrands' | 'arcaneVeil' | 'heavyRain' | 'fire' | 'denseFog' | 'dark' | 'thunderstorm' | 'earthquake';
+export type PixiShaderUniformEntry = {
+    value: number | Float32Array;
+    type: 'f32' | 'vec2<f32>' | 'vec3<f32>';
+};
+export type PixiShaderUniformEntries = Record<string, PixiShaderUniformEntry>;
+interface PixiEffectReleaseTarget {
+    sprite: Sprite;
+    filter: Filter;
+}
+export interface PixiEffectDefinition<TUniforms extends PixiShaderUniformEntries = PixiShaderUniformEntries> {
+    id: PixiShaderEffectId;
+    /** A stable mode consumed by the shared full-screen WebGL program. */
+    mode: number;
+    layer: 'field' | 'global' | 'cinematic';
+    qualityCost: 'low' | 'medium' | 'high';
+    reducedMotion: 'static-commit' | 'disabled';
+    resolution: number;
+    fragment: () => string;
+    createUniforms: () => TUniforms;
+    update: (uniforms: UniformGroup, elapsed: number) => void;
+    release: (target: PixiEffectReleaseTarget) => void;
+}
+export declare const PIXI_SHADER_REGISTRY: Readonly<Record<PixiShaderEffectId, PixiEffectDefinition>>;
+export interface PixiShaderUniformConfig {
+    mode: number;
+    intensity: number;
+    rate: number;
+}
+export interface PixiLineWavesUniforms {
+    speed: number;
+    innerLines: number;
+    outerLines: number;
+    warpIntensity: number;
+    rotation: number;
+    edgeFadeWidth: number;
+    colorCycleSpeed: number;
+    brightness: number;
+    color1: Float32Array;
+    color2: Float32Array;
+    color3: Float32Array;
+}
+export interface PixiSideRaysUniforms {
+    speed: number;
+    rayColor1: Float32Array;
+    rayColor2: Float32Array;
+    intensity: number;
+    spread: number;
+    flipX: number;
+    flipY: number;
+    tilt: number;
+    saturation: number;
+    blend: number;
+    falloff: number;
+    opacity: number;
+}
+export interface PixiLightningUniforms {
+    hue: number;
+    xOffset: number;
+    speed: number;
+    intensity: number;
+    size: number;
+}
+export interface PixiLightPillarUniforms {
+    topColor: Float32Array;
+    bottomColor: Float32Array;
+    intensity: number;
+    glowAmount: number;
+    width: number;
+    height: number;
+    noiseIntensity: number;
+    rotation: number;
+    waveRotation: number;
+    timeScale: number;
+    rotationSpeed: number;
+}
+export interface PixiGalaxyUniforms {
+    focal: Float32Array;
+    rotation: Float32Array;
+    starSpeed: number;
+    density: number;
+    hueShift: number;
+    speed: number;
+    glowIntensity: number;
+    saturation: number;
+    twinkleIntensity: number;
+    rotationSpeed: number;
+    autoCenterRepulsion: number;
+}
+export interface PixiPrismaticBurstUniforms {
+    intensity: number;
+    speed: number;
+    animationType: number;
+    distort: number;
+    offset: Float32Array;
+    noiseAmount: number;
+    rayCount: number;
+    color1: Float32Array;
+    color2: Float32Array;
+    color3: Float32Array;
+}
+export interface PixiArcaneVeilUniforms {
+    color: Float32Array;
+    speed: number;
+    scale: number;
+    opacity: number;
+    quality: number;
+}
+export interface PixiHeavyRainUniforms {
+    color: Float32Array;
+    density: number;
+    speed: number;
+    hazeOpacity: number;
+    slant: number;
+}
+export interface PixiFieldSurfaceUniforms {
+    color1: Float32Array;
+    color2: Float32Array;
+    color3: Float32Array;
+    density: number;
+    speed: number;
+    opacity: number;
+}
+export interface PixiTeamCheckStrandsUniforms {
+    count: number;
+    speed: number;
+    amplitude: number;
+    waviness: number;
+    thickness: number;
+    glow: number;
+    taper: number;
+    spread: number;
+    hueShift: number;
+    opacity: number;
+    scale: number;
+    saturation: number;
+    color1: Float32Array;
+    color2: Float32Array;
+    color3: Float32Array;
+}
+/** Exact Line Waves parameters previously supplied by the raw WebGL host. */
+type PixiFilterConstructor = {
+    from(options: {
+        gl: {
+            vertex: string;
+            fragment: string;
+            name: string;
+        };
+        resources: Record<string, UniformGroup>;
+        resolution?: number;
+    }): Filter;
+};
+export interface PixiShaderRuntimeConstructors {
+    Filter: PixiFilterConstructor;
+    Rectangle: new (x?: number, y?: number, width?: number, height?: number) => Rectangle;
+    Sprite: new (texture?: Texture) => Sprite;
+    Texture: {
+        WHITE: Texture;
+    };
+    UniformGroup: typeof import('pixi.js').UniformGroup;
+}
+export declare class PixiShaderRuntime {
+    private readonly constructors;
+    private readonly activity;
+    private readonly uniformsFor;
+    private readonly stageSize;
+    private readonly surfaces;
+    private readonly stageBounds;
+    private readonly stageResolution;
+    private paused;
+    private playbackRate;
+    private reducedMotion;
+    private elapsed;
+    constructor(constructors: PixiShaderRuntimeConstructors, ticker: Ticker, activity: PixiAnimationActivity, uniformsFor: (effect: PixiShaderEffectId) => PixiShaderUniformEntries, stageSize?: {
+        width: number;
+        height: number;
+    });
+    private readonly ticker;
+    create(effectId: PixiShaderEffectId, intensity?: number, uniformOverrides?: PixiShaderUniformEntries): Sprite;
+    release(sprite: Sprite): void;
+    setPaused(paused: boolean): void;
+    setPlaybackRate(rate: number): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    resize(): void;
+    setSuspended(sprite: Sprite, suspended: boolean): void;
+    destroy(): void;
+    private tick;
+}
+export {};

package/dist/PixiStageFontLoader.d.ts

@@ -0,0 +1,2 @@
+/** Waits for browser font resolution without adding the PDF CJK font to the stage preload. */
+export declare const preloadPixiStageFonts: (fontTests: readonly string[]) => Promise<void>;

package/dist/PixiStageMetrics.d.ts

@@ -0,0 +1,25 @@
+export declare const PIXI_STAGE_METRICS: {
+    readonly width: 1920;
+    readonly height: 1080;
+    readonly centerX: 960;
+    readonly centerY: 540;
+    readonly aspectRatio: number;
+    readonly edgeInset: 28;
+    readonly overscanRatio: 0.05;
+};
+export declare const PIXI_STAGE_SAFE_AREA: {
+    readonly x: 28;
+    readonly y: 28;
+    readonly width: number;
+    readonly height: number;
+};
+export declare const PIXI_STAGE_OVERSCAN_AREA: {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+export declare const PIXI_LOGICAL_STAGE: {
+    readonly width: 1920;
+    readonly height: 1080;
+};

package/dist/PixiStageTheme.d.ts

@@ -0,0 +1,26 @@
+export interface PixiStageTheme {
+    palette: {
+        surface: string;
+        backdrop: string;
+        veil: string;
+        accent: string;
+        investigator: string;
+        enemy: string;
+    };
+    radius: {
+        container: number;
+    };
+    opacity: {
+        disabled: number;
+        muted: number;
+        strong: number;
+    };
+    sceneTransition: {
+        motionBlurStrength: number;
+        motionBlurResolution: number;
+    };
+    stroke: {
+        subtle: number;
+        strong: number;
+    };
+}

package/dist/PixiStoryArchiveMotion.d.ts

@@ -0,0 +1,19 @@
+import { type PixiDirectionalMotionBlur } from './PixiDirectionalMotionBlur.js';
+export interface StoryArchiveMotionPose {
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+}
+export interface StoryArchiveMotionFrame extends StoryArchiveMotionPose {
+    shadeAlpha: number;
+    blurX: number;
+    blurY: number;
+}
+export type PixiStoryArchiveMotionFilter = PixiDirectionalMotionBlur;
+export declare const writeStoryArchiveMotionFrame: (start: StoryArchiveMotionPose, end: StoryArchiveMotionPose, linearProgress: number, maxBlurStrength: number, output: StoryArchiveMotionFrame) => void;
+export declare const createPixiStoryArchiveMotionFilter: (FilterConstructor: typeof import("pixi.js").Filter, options?: {
+    resolution?: number;
+    padding?: number;
+}) => PixiDirectionalMotionBlur;

package/dist/PixiStoryCardCut.d.ts

@@ -0,0 +1,58 @@
+import type { BlurFilter, Container, Graphics, Sprite, Texture } from 'pixi.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+interface Constructors {
+    BlurFilter: typeof BlurFilter;
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+}
+export interface StoryCardCutOptions {
+    readonly duration: number;
+    readonly travel: number;
+    readonly shadowAlpha: number;
+}
+export interface StoryCardCutFrame {
+    readonly layer: 'back' | 'front';
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+    readonly scale: number;
+    readonly shadowAlpha: number;
+    readonly shadowOffsetX: number;
+    readonly shadowOffsetY: number;
+    readonly edgeAlpha: number;
+}
+export declare const resolveStoryCardCutFrame: (progress: number, bounds: PixiLayoutRect, travel: number, maximumShadowAlpha: number) => StoryCardCutFrame;
+export declare class PixiStoryCardCut {
+    private readonly backLayer;
+    private readonly frontLayer;
+    private readonly animation;
+    private readonly requestRender;
+    private readonly photoColors;
+    readonly node: Container;
+    private readonly page;
+    private readonly backing;
+    private readonly shadow;
+    private readonly edge;
+    private readonly shadowBlur;
+    private activeVersion;
+    private progress;
+    private boundsResolver;
+    private options;
+    private frontVisible;
+    private onFrontVisible;
+    private readonly mediaBreathBinding;
+    constructor(backLayer: Container, frontLayer: Container, constructors: Constructors, animation: PixiAnimationDirector, requestRender: () => void, photoColors: {
+        paper: string;
+        shadow: string;
+        paperEdge: string;
+    }, mediaBreath?: PixiMediaBreathRuntime);
+    play(texture: Texture, boundsResolver: () => PixiLayoutRect, options: StoryCardCutOptions, signal: AbortSignal, onFrontVisible: () => void): Promise<boolean>;
+    refresh(): void;
+    hide(): void;
+    destroy(): void;
+    private applyFrame;
+}
+export {};