@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiCombatMotion.d.ts

@@ -0,0 +1,223 @@
+import type { RuntimeLogger } from '@bardway/trpg-media';
+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 { PixiSceneGraph } from './PixiSceneGraph.js';
+import { PixiTokenWorld } from './PixiTokenWorld.js';
+import { type PixiBattleFxCapabilities } from './PixiBattleFxResources.js';
+import { type BattleFxPoint, type BattlePassByPath } from './BattleActionMotionMath.js';
+import type { SessionTuningResolver } from '@bardway/trpg-media/tuning';
+export interface VisualFloatInstruction {
+    id: string;
+    tokenId: string;
+    text: string;
+    color: string;
+    delay: number;
+    outward: boolean;
+}
+export interface VisualChargeMotion {
+    outcome: 'hit' | 'dodge' | 'miss' | 'blocked';
+    attackerFrom: {
+        col: number;
+        row: number;
+    };
+    attackerTo: {
+        col: number;
+        row: number;
+    };
+    targetFrom: {
+        col: number;
+        row: number;
+    };
+    targetTo: {
+        col: number;
+        row: number;
+    };
+    displacedTokens?: readonly {
+        tokenId: string;
+        from: {
+            col: number;
+            row: number;
+        };
+        to: {
+            col: number;
+            row: number;
+        };
+    }[];
+}
+export interface VisualAttackInstruction {
+    id: string;
+    attackerId: string;
+    targetId: string;
+    actionType: 'shoot' | 'throw' | 'melee' | 'electric' | 'swing' | 'blade' | 'charge' | 'whip';
+    evaded: boolean;
+    recovering: boolean;
+    hitIndex?: number;
+    resultFeedback: 'miss' | 'other';
+    feedbackText: string;
+    damageFloats: readonly VisualFloatInstruction[];
+    durations: {
+        line: number;
+    };
+    chargeMotion?: VisualChargeMotion;
+}
+export interface CombatMotionContext {
+    logger: RuntimeLogger;
+    scene: PixiSceneGraph;
+    world: PixiTokenWorld;
+    assets: PixiAssetManager;
+    director: PixiAnimationDirector;
+    constructors: Pick<typeof import('pixi.js'), 'Container' | 'Graphics' | 'Sprite' | 'Text' | 'Rectangle' | 'BlurFilter'>;
+    fxCapabilities: PixiBattleFxCapabilities;
+    getTuning(): SessionTuningResolver | undefined;
+    getAudio(): {
+        playCue(id: string): void;
+    } | null;
+    activity?: PixiAnimationActivity;
+    typography: {
+        data: TextStyleOptions;
+        damage: TextStyleOptions;
+    };
+    projectileImageUrl?: string;
+    colors: {
+        fx_attackLineColors_blade: string;
+        fx_attackLineColors_swing: string;
+        fx_attackLineColors_throw: string;
+        pixi_effect_attackLine: string;
+        pixi_effect_cinematic: string;
+        pixi_effect_damage: string;
+        pixi_effect_electric: string;
+        pixi_effect_miss: string;
+        pixi_effect_recover: string;
+        pixi_sessionGraybox_transition: string;
+    };
+}
+type CameraImpactShakeProfile = 'hit' | 'explosion';
+export declare class PixiCombatMotion {
+    private readonly context;
+    private readonly statusScope;
+    private lifetime;
+    private readonly fxResources;
+    private readonly presentationEngine;
+    private readonly cameraImpactShakes;
+    private readonly heldChargeDodges;
+    private electricGroupActive;
+    private electricGroupFlashPlayed;
+    constructor(context: CombatMotionContext);
+    setElectricGroup(active: boolean): void;
+    reset(): void;
+    destroy(): void;
+    playShatter(tokenId: string, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playIconScatter(imageUrl: string, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playCover(imageUrl: string, tokenId: string, _target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    private resetCamera;
+    private resetCameraImpactShake;
+    playCameraImpactShake(impactKey: string, profile: CameraImpactShakeProfile, signal: AbortSignal): Promise<void>;
+    playVisualDash(tokenId: string, to: BattleFxPoint, signal: AbortSignal, returning: boolean): Promise<void>;
+    private createChargeTrail;
+    playDirectionalRecoil(tokenId: string, from: {
+        x: number;
+        y: number;
+    }, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playLocalResourceLossShake(tokenId: string, signal: AbortSignal): Promise<void>;
+    runSidecarActivity(id: string, run: () => Promise<void>): Promise<void>;
+    playSupportPulse(from: {
+        x: number;
+        y: number;
+    }, target: {
+        x: number;
+        y: number;
+    }, durationMs: number, firstAid: boolean, signal: AbortSignal): Promise<void>;
+    playExplosion(from: {
+        x: number;
+        y: number;
+    }, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal, coverageRadius?: number, impactTokenIds?: readonly string[], cameraImpactKey?: string): Promise<void>;
+    playMeleeMotion(action: VisualAttackInstruction, attackerPoint: {
+        x: number;
+        y: number;
+    }, targetPoint: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playRangedApproach(action: VisualAttackInstruction, from: BattleFxPoint, target: BattleFxPoint, signal: AbortSignal): Promise<void>;
+    playSwingArc(action: VisualAttackInstruction, center: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playSwingTargetReaction(action: VisualAttackInstruction, from: {
+        x: number;
+        y: number;
+    }, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal, impactKey: string): Promise<void>;
+    playBladeSlash(action: VisualAttackInstruction, target: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal, impactKey: string): Promise<void>;
+    playProjectile(action: Pick<VisualAttackInstruction, 'id' | 'actionType' | 'evaded'>, from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal, shortRange?: boolean, passBy?: {
+        path: BattlePassByPath;
+        onProgress: (progress: number) => void;
+    }): Promise<void>;
+    playElectric(action: Pick<VisualAttackInstruction, 'id'>, from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playImpact(target: {
+        x: number;
+        y: number;
+    }, action: VisualAttackInstruction, signal: AbortSignal, impactKey: string): Promise<void>;
+    playResourceFloats(floats: VisualAttackInstruction['damageFloats'], action: VisualAttackInstruction, attackerPoint: {
+        x: number;
+        y: number;
+    }, targetPoint: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playMissFeedback(action: VisualAttackInstruction, targetPoint: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    private startMissFeedback;
+    private resolveTuningNumber;
+    private resolveTuningColor;
+    private hashActionId;
+    playChargeMotion(sequence: VisualAttackInstruction, attackerPoint: {
+        x: number;
+        y: number;
+    }, targetPoint: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal): Promise<void>;
+    playChargeImpact(sequence: VisualAttackInstruction, targetPoint: {
+        x: number;
+        y: number;
+    }, signal: AbortSignal, impactKey: string): Promise<void>;
+    playChargeDisplacements(sequence: VisualAttackInstruction, signal: AbortSignal, includeTarget: boolean): Promise<void>;
+}
+export {};

package/dist/PixiCurrentActorCardGlow.d.ts

@@ -0,0 +1,37 @@
+import type { Container, Mesh, MeshGeometry, Shader } from 'pixi.js';
+type PixiContainer = Container;
+type PixiMesh = Mesh<MeshGeometry, Shader>;
+export interface PixiCurrentActorCardGlowConstructors {
+    Mesh?: typeof import('pixi.js').Mesh;
+    MeshGeometry?: typeof import('pixi.js').MeshGeometry;
+    Shader?: typeof import('pixi.js').Shader;
+    UniformGroup?: typeof import('pixi.js').UniformGroup;
+}
+export interface CurrentActorCardGlowLayout {
+    readonly width: number;
+    readonly height: number;
+    readonly intensity: number;
+    readonly softness: number;
+    readonly color: string;
+}
+/** One retained rounded-rectangle shader surface for the active roster card. */
+export declare class PixiCurrentActorCardGlow {
+    private readonly constructors;
+    private mesh;
+    private geometry;
+    private shader;
+    private uniformGroup;
+    constructor(constructors: PixiCurrentActorCardGlowConstructors);
+    configure(parent: PixiContainer, before: PixiContainer, layout: CurrentActorCardGlowLayout): void;
+    setFrame(progress: number, staticPresentation?: boolean): void;
+    hide(): void;
+    hideIfAttachedTo(parent: PixiContainer): void;
+    detachFrom(parent?: PixiContainer): void;
+    destroy(): void;
+    getMesh(): PixiMesh | null;
+    getProgress(): number | null;
+    private ensureMesh;
+    private attachBefore;
+    private getUniformValues;
+}
+export {};

package/dist/PixiCurrentActorHalo.d.ts

@@ -0,0 +1,55 @@
+import type { Container, Mesh, MeshGeometry, Shader } from 'pixi.js';
+type PixiContainer = Container;
+type PixiMesh = Mesh<MeshGeometry, Shader>;
+export interface PixiCurrentActorHaloConstructors {
+    Mesh?: typeof import('pixi.js').Mesh;
+    MeshGeometry?: typeof import('pixi.js').MeshGeometry;
+    Shader?: typeof import('pixi.js').Shader;
+    UniformGroup?: typeof import('pixi.js').UniformGroup;
+}
+export interface CurrentActorHaloLayout {
+    readonly ringDiameter: number;
+    readonly avatarAperture: number;
+    readonly range: number;
+    readonly brightness: number;
+    readonly innerBrightness: number;
+    readonly innerThickness: number;
+    readonly innerSoftness: number;
+    readonly waveScale: number;
+    readonly color: string;
+}
+export declare const resolveCurrentActorHaloSoftness: (range: number) => number;
+export declare const resolveCurrentActorHaloBrightness: (brightness: number) => number;
+export declare const resolveCurrentActorHaloEnvelope: (progress: number) => number;
+export declare const resolveCurrentActorHaloPeakRadius: (tokenRadius: number, waveScale: number, progress: number) => number;
+/** One retained, local shader surface for the active battle Token. */
+export declare class PixiCurrentActorHalo {
+    private readonly constructors;
+    private mesh;
+    private geometry;
+    private shader;
+    private innerMesh;
+    private innerGeometry;
+    private innerShader;
+    private uniformGroup;
+    private presentationAlpha;
+    private highlightMultiplier;
+    constructor(constructors: PixiCurrentActorHaloConstructors);
+    configure(parent: PixiContainer, shadow: PixiContainer, avatarLayer: PixiContainer, layout: CurrentActorHaloLayout): void;
+    setProgress(progress: number): void;
+    setStaticPresentation(): void;
+    setAnimatedPresentation(): void;
+    setHighlightMultiplier(multiplier: number): void;
+    hide(): void;
+    detachFrom(parent?: PixiContainer): void;
+    isAttachedTo(parent: PixiContainer): boolean;
+    destroy(): void;
+    getMesh(): PixiMesh | null;
+    getInnerMesh(): PixiMesh | null;
+    private ensureMesh;
+    private ensureInnerMesh;
+    private attachBehindShadow;
+    private attachAfterAvatar;
+    private getUniformValues;
+}
+export {};

package/dist/PixiDirectionalMotionBlur.d.ts

@@ -0,0 +1,12 @@
+import type { Filter } from 'pixi.js';
+export interface PixiDirectionalMotionBlur {
+    readonly filter: Filter;
+    update(velocityX: number, velocityY: number): void;
+    reset(): void;
+    destroy(): void;
+}
+/** Retained, single-pass directional trail. Mutates the original typed uniform without allocation. */
+export declare const createPixiDirectionalMotionBlur: (FilterConstructor: typeof Filter, options?: {
+    resolution?: number;
+    padding?: number;
+}) => PixiDirectionalMotionBlur;

package/dist/PixiDisplayRenderer.d.ts

@@ -0,0 +1,85 @@
+import type { Application } from 'pixi.js';
+import { type DisplaySnapshot, type PresentationEvent } from '@bardway/trpg-display';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import { type StageRenderQuality } from './PixiApplicationFactory.js';
+import { type PixiAnimationActivity } from './PixiAnimationActivity.js';
+import { type PixiAnimationDirector } from './PixiAnimationDirector.js';
+import { PixiAssetManager } from './PixiAssetManager.js';
+import { type PixiSceneGraph } from './PixiSceneGraph.js';
+import { PixiVideoRuntime } from './PixiVideoRuntime.js';
+import { StoryTimelineClock } from './story/StoryTimelineClock.js';
+export interface PixiDisplayContext {
+    readonly app: Application;
+    readonly pixi: typeof import('pixi.js');
+    readonly scene: PixiSceneGraph;
+    readonly assets: PixiAssetManager;
+    readonly animation: PixiAnimationDirector;
+    readonly activity: PixiAnimationActivity;
+    readonly video: PixiVideoRuntime;
+    readonly clock: StoryTimelineClock;
+    readonly stage: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly signal: AbortSignal;
+    readonly logger: RuntimeLogger;
+    requestRender(): void;
+}
+/** The host owns the visual policy and exposes already adjudicated public data. */
+export interface PixiDisplaySurface {
+    applySnapshot(snapshot: DisplaySnapshot, signal: AbortSignal): void | Promise<void>;
+    play(event: PresentationEvent, signal: AbortSignal): Promise<void>;
+    setPaused?(paused: boolean): void;
+    setReducedMotion?(reducedMotion: boolean): void;
+    resize?(): void;
+    reset(): void;
+    destroy(): void;
+}
+export interface PixiDisplayRendererOptions {
+    readonly logger: RuntimeLogger;
+    readonly stage: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly quality?: StageRenderQuality;
+    readonly resolveAssetUrl: (uri: string) => string;
+    readonly createSurface: (context: PixiDisplayContext) => PixiDisplaySurface;
+    readonly blocking?: (event: PresentationEvent) => boolean;
+    readonly onCommitted?: (snapshot: DisplaySnapshot) => void;
+}
+/** One Application, one private ticker and a renderer-owned logical animation clock. */
+export declare class PixiDisplayRenderer {
+    private readonly options;
+    private app;
+    private mountPromise;
+    private viewport;
+    private context;
+    private surface;
+    private queue;
+    private lifecycle;
+    private snapshotController;
+    private latest;
+    private committed;
+    private seen;
+    private pendingApply;
+    private paused;
+    private reducedMotion;
+    private lost;
+    private destroyed;
+    private epoch;
+    constructor(options: PixiDisplayRendererOptions);
+    mount(host: HTMLElement): Promise<void>;
+    private initialize;
+    private createRuntime;
+    applySnapshot(input: unknown): Promise<void>;
+    play(input: unknown): Promise<'completed' | 'aborted' | 'ignored'>;
+    pause(paused?: boolean): void;
+    setReducedMotion(reduced: boolean): void;
+    resize(width: number, height: number): void;
+    reset(): Promise<void>;
+    destroy(): Promise<void>;
+    private disposeRuntime;
+    private readonly advanceClock;
+    private readonly onContextLost;
+    private readonly onContextRestored;
+}

package/dist/PixiEffectPlugin.d.ts

@@ -0,0 +1,25 @@
+import type { PresentationEvent, DisplaySnapshot } from '@bardway/trpg-display';
+/**
+ * Renderer-local effect boundary. Plugins receive only already-adjudicated
+ * events and must resolve after abort so the shared display queue can advance.
+ */
+export interface PixiEffectPlugin<TEvent = PresentationEvent, TSnapshot = DisplaySnapshot> {
+    readonly id: string;
+    canPlay(event: TEvent): boolean;
+    play(event: TEvent, signal: AbortSignal): Promise<void>;
+    applySnapshot?(snapshot: TSnapshot): void;
+    setPaused(paused: boolean): void;
+    reset(): void;
+    abortSceneTransients?(): void;
+    destroy(): void;
+}
+export declare class PixiEffectRegistry<TEvent = PresentationEvent, TSnapshot = DisplaySnapshot> {
+    private readonly plugins;
+    constructor(plugins: readonly PixiEffectPlugin<TEvent, TSnapshot>[]);
+    play(event: TEvent, signal: AbortSignal): Promise<boolean>;
+    setPaused(paused: boolean): void;
+    applySnapshot(snapshot: TSnapshot): void;
+    reset(): void;
+    abortSceneTransients(): void;
+    destroy(): void;
+}

package/dist/PixiEndingSurface.d.ts

@@ -0,0 +1,104 @@
+import type { Container, Graphics, Mesh, MeshGeometry, Shader, Sprite, Texture, Ticker, UniformGroup } from 'pixi.js';
+import type { RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+import type { PixiVideoRuntime } from './PixiVideoRuntime.js';
+interface Constructors {
+    Container: typeof Container;
+    Graphics: typeof Graphics;
+    Mesh: typeof Mesh;
+    MeshGeometry: typeof MeshGeometry;
+    Shader: typeof Shader;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    UniformGroup: typeof UniformGroup;
+}
+export declare const DEFAULT_ENDING_TIMELINE: {
+    readonly veilInDuration: 0.65;
+    readonly photoAppearDuration: 0.12;
+    readonly fullscreenHoldDuration: 2.77;
+    readonly photoSettleDuration: 3.85;
+    readonly backgroundRevealDuration: 3.35;
+    readonly veilOutDuration: 1.25;
+};
+interface EndingLayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export declare class PixiEndingSurface {
+    private readonly assets;
+    private readonly constructors;
+    private readonly requestRender;
+    private readonly ports;
+    private tuning?;
+    private readonly ticker?;
+    private readonly activity?;
+    private readonly mediaBreath?;
+    private readonly videoRuntime?;
+    private disposed;
+    private readonly resourceScope;
+    readonly node: Container;
+    private readonly photoAnchor;
+    private readonly photoFrame;
+    private readonly photoMask;
+    private readonly photoGlow;
+    private readonly dust;
+    private active;
+    private elapsed;
+    private releaseActivity;
+    private photoImage;
+    private photoMediaBreath;
+    private photoVideoBinding;
+    private photoMediaReady;
+    private photoMediaFailed;
+    private photoKey;
+    private photoVideoUrl;
+    private photoReadyKey;
+    private readonly photoReadyWaiters;
+    private photoVersion;
+    private timelineActive;
+    private activeProxy;
+    private activeProxyMediaBreath;
+    private uiHighlightMultiplier;
+    private readonly releaseUiHighlight;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, constructors: Constructors, skinTexture: Texture | null, photoFrameTexture: Texture | null, requestRender: () => void, ports: {
+        logger: RuntimeLogger;
+        stage: {
+            width: number;
+            height: number;
+        };
+        layout: {
+            photoFrame: EndingLayoutRect;
+            photoImageRect: EndingLayoutRect;
+        };
+        stageColor: string;
+        paperColor: string;
+        paperEdgeColor: string;
+    }, tuning?: SessionTuningResolver | undefined, ticker?: Ticker | undefined, activity?: PixiAnimationActivity | undefined, mediaBreath?: PixiMediaBreathRuntime | undefined, videoRuntime?: PixiVideoRuntime | undefined);
+    sync(imageUrl: string | null, videoUrlOrVisible: string | null | boolean, visibleValue?: boolean): void;
+    playTimeline(animation: PixiAnimationDirector, signal: AbortSignal, reducedMotion: boolean, overlayLayer: Container): Promise<void>;
+    waitForPhotoReady(imageUrl: string | null, signal: AbortSignal): Promise<boolean>;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    reset(): void;
+    private loadPhoto;
+    waitForVideoReady(imageUrl: string | null, videoUrl: string, signal: AbortSignal): Promise<boolean>;
+    private upgradePhotoToVideo;
+    private clearPhoto;
+    private clearPhotoProxy;
+    private settlePhotoReadyWaiters;
+    private createPhotoProxy;
+    private syncLayout;
+    private syncPhotoImageLayout;
+    private resolveTuningNumber;
+    private resolveTuningRect;
+    private configurePhotoGlow;
+    private syncActivity;
+    private update;
+    destroy(): void;
+}
+export {};

package/dist/PixiInvestigatorDossierInsanityFilter.d.ts

@@ -0,0 +1,14 @@
+import type { Filter, UniformGroup } from 'pixi.js';
+export declare const DOSSIER_INSANITY_MODES: readonly ["mosaic", "ripple", "chromatic", "shatter"];
+export type DossierInsanityMode = (typeof DOSSIER_INSANITY_MODES)[number];
+export interface DossierInsanityFilter {
+    readonly filter: Filter;
+    update(mode: DossierInsanityMode, intensity: number, seed: number): void;
+    destroy(): void;
+}
+export interface DossierInsanityFilterConstructors {
+    Filter: typeof Filter;
+    UniformGroup: typeof UniformGroup;
+    tearGapColor: Float32Array;
+}
+export declare const createDossierInsanityFilter: ({ Filter, UniformGroup, tearGapColor, }: DossierInsanityFilterConstructors) => DossierInsanityFilter;

package/dist/PixiLocalGlowMesh.d.ts

@@ -0,0 +1,38 @@
+import type { Container, Mesh, MeshGeometry, Shader } from 'pixi.js';
+type PixiMesh = Mesh<MeshGeometry, Shader>;
+export interface PixiLocalGlowConstructors {
+    Mesh?: typeof import('pixi.js').Mesh;
+    MeshGeometry?: typeof import('pixi.js').MeshGeometry;
+    Shader?: typeof import('pixi.js').Shader;
+    UniformGroup?: typeof import('pixi.js').UniformGroup;
+}
+export interface PixiLocalGlowLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    intensity: number;
+    softness: number;
+    edge: number;
+    edgeIntensity?: number;
+    shape: 'ellipse' | 'rounded-rect';
+}
+/** Retained, tightly bounded glow surface shared by non-battle scene composition. */
+export declare class PixiLocalGlowMesh {
+    private readonly constructors;
+    private readonly label;
+    private mesh;
+    private geometry;
+    private shader;
+    private uniforms;
+    constructor(constructors: PixiLocalGlowConstructors, label: string);
+    configure(parent: Container, layout: PixiLocalGlowLayout): PixiMesh | null;
+    setProgress(progress: number): void;
+    setIntensity(intensity: number): void;
+    setVisible(visible: boolean): void;
+    destroy(): void;
+    get node(): PixiMesh | null;
+    private ensureMesh;
+}
+export {};

package/dist/PixiMapEdgeShadow.d.ts

@@ -0,0 +1,36 @@
+import type { Container } from 'pixi.js';
+import type { PixiBattleFxCapabilities } from './PixiBattleFxResources.js';
+export interface MapEdgeShadowStyle {
+    color: string;
+    top: {
+        depth: number;
+        alpha: number;
+        power: number;
+    };
+    side: {
+        depth: number;
+        alpha: number;
+        power: number;
+    };
+    bottom: {
+        depth: number;
+        alpha: number;
+        power: number;
+    };
+}
+export declare class PixiMapEdgeShadow {
+    private readonly constructors;
+    private mesh;
+    private geometry;
+    private shader;
+    private uniforms;
+    constructor(constructors: PixiBattleFxCapabilities);
+    sync(parent: Container, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, style: MapEdgeShadowStyle): void;
+    destroy(): void;
+    private ensure;
+}