@agrhub/engine-pixi 0.0.0-stage → 1.3.3

package/dist/effect/glsl/gl-effect.d.ts

@@ -0,0 +1,38 @@
+export interface GlEffect {
+    label: string;
+    fragment: string;
+    uniforms?: Record<string, {
+        value: any;
+        type: string;
+    }>;
+    previewStatic?: string;
+    previewDynamic?: string;
+}
+/**
+ * Register a custom effect at runtime
+ */
+export declare function registerCustomEffect(name: string, effect: GlEffect): void;
+/**
+ * Unregister a custom effect at runtime
+ */
+export declare function unregisterCustomEffect(name: string): void;
+/**
+ * Get all available effects, including library and runtime registered ones
+ */
+export declare function getAllEffects(): Record<string, GlEffect>;
+export declare const GL_EFFECTS: Record<string, GlEffect>;
+export type EffectKey = string;
+export declare function getEffectOptions(): {
+    key: EffectKey;
+    label: string;
+    isCustom: boolean;
+    previewStatic: string;
+    previewDynamic: string;
+}[];
+export declare const GL_EFFECT_OPTIONS: {
+    key: EffectKey;
+    label: string;
+    isCustom: boolean;
+    previewStatic: string;
+    previewDynamic: string;
+}[];

package/dist/effect/interface/index.d.ts

@@ -0,0 +1,25 @@
+import { AdjustmentFilterOptions, AdvancedBloomFilterOptions, BloomFilterOptions, ColorOverlayFilterOptions, ConvolutionFilterOptions, DotFilterOptions, DropShadowFilterOptions, GlitchFilterOptions, GlowFilterOptions, GodrayFilterOptions, HslAdjustmentFilterOptions, KawaseBlurFilterOptions, MotionBlurFilterOptions, OldFilmFilterOptions, RadialBlurFilterOptions, ReflectionFilterOptions, RGBSplitFilterOptions, TiltShiftFilterOptions } from 'pixi-filters';
+export type FilterOptionsMap = {
+    adjustmentFilter: AdjustmentFilterOptions;
+    advancedBloomFilter: AdvancedBloomFilterOptions;
+    backdropBlurFilter: any;
+    bloomFilter: BloomFilterOptions;
+    colorMapFilter: any;
+    colorOverlayFilter: ColorOverlayFilterOptions;
+    convolutionFilter: ConvolutionFilterOptions;
+    dotFilter: DotFilterOptions;
+    dropShadowFilter: DropShadowFilterOptions;
+    glitchFilter: GlitchFilterOptions;
+    glowFilter: GlowFilterOptions;
+    godrayFilter: GodrayFilterOptions;
+    grayscaleFilter: any;
+    hslAdjustmentFilter: HslAdjustmentFilterOptions;
+    kawaseBlurFilter: KawaseBlurFilterOptions;
+    motionBlurFilter: MotionBlurFilterOptions;
+    oldFilmFilter: OldFilmFilterOptions;
+    pixelateFilter: any;
+    radialBlurFilter: RadialBlurFilterOptions;
+    reflectionFilter: ReflectionFilterOptions;
+    rgbSplitFilter: RGBSplitFilterOptions;
+    tiltShiftFilter: TiltShiftFilterOptions;
+};

package/dist/effect/types.d.ts

@@ -0,0 +1,26 @@
+import { Renderer, RenderTexture } from 'pixi.js';
+import { EffectKey } from './glsl/gl-effect';
+export interface EffectOptions {
+    name: EffectKey;
+    renderer: Renderer;
+    values?: Record<string, any>;
+}
+export interface EffectRendererOptions {
+    canvasTexture: HTMLCanvasElement | ImageBitmap | HTMLImageElement | HTMLVideoElement | RenderTexture;
+    progress: number;
+    width: number;
+    height: number;
+    values?: Record<string, any>;
+}
+export interface GLEffect {
+    author?: string;
+    createdAt?: string;
+    glsl: string;
+    license?: string;
+    name: EffectKey;
+    updatedAt?: string;
+    defaultParams?: any;
+    paramsTypes?: any;
+    fragment?: string;
+    label?: string;
+}

package/dist/effect/vertex.d.ts

@@ -0,0 +1 @@
+export declare const vertex = "\nin vec2 aPosition;\nout vec2 vTextureCoord;\n\nuniform vec4 uInputSize;\nuniform vec4 uOutputFrame;\nuniform vec4 uOutputTexture;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;\n\n    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;\n    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;\n\n    return vec4(position, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aPosition * (uOutputFrame.zw * uInputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";

package/dist/event-emitter.d.ts

@@ -0,0 +1,55 @@
+export type EventType = string | symbol;
+export type Handler<T = unknown> = (event: T) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | "*", EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+export interface Emitter<Events extends Record<EventType, unknown>> {
+    all: EventHandlerMap<Events>;
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: "*", handler: WildcardHandler<Events>): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: "*", handler: WildcardHandler<Events>): void;
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * EventEmitter: A class-based event emitter for inheritance
+ */
+export default class EventEmitter<Events extends Record<EventType, unknown>> implements Emitter<Events> {
+    all: EventHandlerMap<Events>;
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @returns {Function} A function to unregister the handler
+     */
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): () => void;
+    on(type: "*", handler: WildcardHandler<Events>): () => void;
+    /**
+     * Register a one-time event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for
+     * @param {Function} handler Function to call in response to given event
+     * @returns {Function} A function to unregister the handler
+     */
+    once<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): () => void;
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     */
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: "*", handler: WildcardHandler<Events>): void;
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     */
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}

package/dist/filters/outline-filter.d.ts

@@ -0,0 +1,28 @@
+import { Filter } from 'pixi.js';
+/**
+ * OutlineFilter creates outline/stroke effects for text.
+ * Replaces default PixiJS stroke option with a custom shader implementation.
+ *
+ * @example
+ * ```js
+ * import { OutlineFilter } from './outline-filter';
+ *
+ * const outlineFilter = new OutlineFilter({
+ *   thickness: 2.0,
+ *   borderColor: 0x000000
+ * });
+ * text.filters = [outlineFilter];
+ * ```
+ */
+export declare class OutlineFilter extends Filter {
+    constructor(options: {
+        thickness?: number;
+        borderColor?: number;
+    });
+    /**
+     * The thickness of the outline effect.
+     * @default 2.0
+     */
+    get thickness(): any;
+    set thickness(value: any);
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export { fastConcatMP4, fixFMP4Duration, mixinMP4AndAudio } from './mp4-utils';
+export { createChromakey } from './utils/chromakey';
+export { renderTxt2ImgBitmap } from './utils/dom';
+export { Audio, Caption, Image, Video, Text, Effect, Transition, Placeholder, ShapeClip, Backdrop, ClipRegistry, } from './clips';
+export type { IClip, IMP4ClipOpts } from './clips';
+export { DEFAULT_AUDIO_CONF } from './clips/iclip';
+export { Video as MP4Clip } from './clips';
+export { Compositor } from './compositor';
+export type { ICompositorOpts } from './compositor';
+export { Studio, Studio as PixiEngine } from './studio';
+export type { IStudioOpts, IStudioOpts as IPixiEngineOpts } from './studio';
+export { Log } from './utils/log';
+export { clipToJSON, jsonToClip, type ClipJSON, type ProjectJSON } from './json-serialization';
+export { fontManager, FontManager } from './utils/fonts';
+export { mediaCache, MediaCache } from './utils/media-cache';
+export type { MediaCacheOptions } from './utils/media-cache';
+export { AssetManager } from './utils/asset-manager';
+export { ResourceManager, ResourceStatus } from './studio/resource-manager';
+export { makeEffect } from './effect/effect';
+export { VALUES_FILTER_SPECIAL, VALUES_FILTER_SPECIAL_LIMITS } from './effect/constant';
+export type { FilterOptionsMap } from './effect/interface';
+export { registerCustomEffect, unregisterCustomEffect, getAllEffects, getEffectOptions, GL_EFFECT_OPTIONS, type GlEffect, } from './effect/glsl/gl-effect';
+export type { EffectKey } from './effect/glsl/gl-effect';
+export { makeTransition } from './transition/transition';
+export { registerCustomTransition, unregisterCustomTransition, getAllTransitions, getTransitionOptions, GL_TRANSITION_OPTIONS, type GlTransition, } from './transition/glsl/gl-transition';
+export type { TransitionKey } from './transition/glsl/gl-transition';
+export * from './animation';