pixifact 0.1.3 → 0.1.5

package/dist/runtime/Application.js

@@ -1,67 +0,0 @@
-import * as PIXI from 'pixi.js';
-import { UPDATE_PRIORITY } from 'pixi.js';
-import { GameObject } from './GameObject.js';
-import { Group } from './group/index.js';
-export class Application extends PIXI.Application {
-    root;
-    updateTargets = new Set();
-    isUpdateTickerRegistered = false;
-    updateGameObjects = (ticker) => {
-        const dt = ticker.deltaTime;
-        for (const target of [...this.updateTargets]) {
-            if (target.app !== this || !target.hasUpdateWork()) {
-                this.unregisterUpdateTarget(target);
-                continue;
-            }
-            target.emitter.emit(GameObject.Event.TICKER_BEFORE, dt);
-            target.update?.(dt);
-            target.emitter.emit(GameObject.Event.TICKER_AFTER, dt);
-        }
-    };
-    async init(options) {
-        await super.init(options);
-        this.root = new Group();
-        this.root.display = this.stage;
-        this.root.width = this.screen.width;
-        this.root.height = this.screen.height;
-        this.root.setApplication(this);
-    }
-    registerUpdateTarget(target) {
-        if (target.app !== this || !target.hasUpdateWork()) {
-            return;
-        }
-        this.updateTargets.add(target);
-        this.syncUpdateTicker();
-    }
-    unregisterUpdateTarget(target) {
-        if (!this.updateTargets.delete(target)) {
-            return;
-        }
-        this.syncUpdateTicker();
-    }
-    syncUpdateTicker() {
-        if (!this.ticker) {
-            return;
-        }
-        if (this.updateTargets.size > 0) {
-            if (!this.isUpdateTickerRegistered) {
-                this.ticker.add(this.updateGameObjects, undefined, UPDATE_PRIORITY.NORMAL);
-                this.isUpdateTickerRegistered = true;
-            }
-            return;
-        }
-        if (this.isUpdateTickerRegistered) {
-            this.ticker.remove(this.updateGameObjects);
-            this.isUpdateTickerRegistered = false;
-        }
-    }
-    destroy(rendererDestroyOptions, options) {
-        this.updateTargets.clear();
-        if (this.isUpdateTickerRegistered && this.ticker) {
-            this.ticker.remove(this.updateGameObjects);
-            this.isUpdateTickerRegistered = false;
-        }
-        this.root?.setApplication(undefined);
-        super.destroy(rendererDestroyOptions, options);
-    }
-}

package/dist/runtime/GameObject.d.ts

@@ -1,100 +0,0 @@
-import { Container } from "pixi.js";
-import { Transform } from "./Transform.js";
-import { Vector2 } from "@math.gl/core";
-import EventEmitter from "eventemitter3";
-import { Component } from "./component/Component.js";
-import type { GameObjectEventMap } from "./GameObjectEvent.js";
-import type { Group } from "./group/index.js";
-import type { Application } from "./Application.js";
-export type Constructor<T = unknown> = new (...args: any[]) => T;
-export { GameObjectEvent } from "./GameObjectEvent.js";
-export type { GameObjectEventMap } from "./GameObjectEvent.js";
-declare class GameObjectEmitter extends EventEmitter<GameObjectEventMap> {
-    private gameObject;
-    constructor(gameObject: GameObject);
-    private syncUpdateRegistration;
-    on<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, fn: EventEmitter.EventListener<GameObjectEventMap, T>, context?: unknown): this;
-    addListener<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, fn: EventEmitter.EventListener<GameObjectEventMap, T>, context?: unknown): this;
-    once<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, fn: EventEmitter.EventListener<GameObjectEventMap, T>, context?: unknown): this;
-    off<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, fn?: EventEmitter.EventListener<GameObjectEventMap, T>, context?: unknown, once?: boolean): this;
-    removeListener<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, fn?: EventEmitter.EventListener<GameObjectEventMap, T>, context?: unknown, once?: boolean): this;
-    removeAllListeners(event?: EventEmitter.EventNames<GameObjectEventMap>): this;
-    emit<T extends EventEmitter.EventNames<GameObjectEventMap>>(event: T, ...args: EventEmitter.EventArgs<GameObjectEventMap, T>): boolean;
-}
-export declare abstract class BaseGameObject<T extends Container> {
-    abstract display: T;
-    abstract get width(): number;
-    abstract set width(val: number);
-    abstract get height(): number;
-    abstract set height(val: number);
-    abstract get anchor(): Vector2;
-    abstract set anchor(val: Vector2);
-    protected refreshPivot(): void;
-}
-export declare abstract class GameObject<T extends Container = Container> extends BaseGameObject<T> {
-    static Event: {
-        readonly ADDED: "added";
-        readonly CHILD_ADDED: "childAdded";
-        readonly REMOVED: "removed";
-        readonly CHILD_REMOVED: "childRemoved";
-        readonly RESIZE: "resize";
-        readonly REPOSITION: "reposition";
-        readonly TRANSFORM_CHANGE: "transformChange";
-        readonly TICKER_BEFORE: "tickerBefore";
-        readonly TICKER_AFTER: "tickerAfter";
-    };
-    emitter: GameObjectEmitter;
-    display: T;
-    transform: Transform;
-    app?: Application;
-    parent?: Group;
-    components: Component[];
-    private componentTickerHandlers;
-    private _destroying;
-    get visible(): boolean;
-    set visible(val: boolean);
-    get x(): number;
-    set x(val: number);
-    get y(): number;
-    set y(val: number);
-    get scaleX(): number;
-    set scaleX(val: number);
-    get scaleY(): number;
-    set scaleY(val: number);
-    get width(): number;
-    set width(val: number);
-    get height(): number;
-    set height(val: number);
-    protected _anchor: Vector2;
-    get anchor(): Vector2;
-    set anchor(value: Vector2);
-    get anchorX(): number;
-    set anchorX(value: number);
-    get anchorY(): number;
-    set anchorY(value: number);
-    get rotation(): number;
-    set rotation(val: number);
-    get skewX(): number;
-    set skewX(val: number);
-    get skewY(): number;
-    set skewY(val: number);
-    /**
-     * 透明度
-     */
-    get alpha(): number;
-    set alpha(val: number);
-    start?(): void;
-    hasUpdateWork(): boolean;
-    syncUpdateRegistration(): void;
-    setApplication(app?: Application): void;
-    addComponent<T extends Component>(component: Constructor<T>, props?: Partial<T>): T;
-    removeComponent<T extends Component>(component: T): T | undefined;
-    getComponent<T extends Component>(component: Constructor<T>): T | undefined;
-    getComponents<T extends Component>(component: Constructor<T>): T[] | undefined;
-    private setDisplay;
-    update?(dt: number): void;
-    render?(): void;
-    onDestroy?(): void;
-    static instantiate<T extends GameObject = GameObject>(gameObject: Constructor<T>, parent?: Group, props?: Partial<T>): T;
-    static destroy(go: GameObject): Promise<void>;
-}

package/dist/runtime/GameObject.js

@@ -1,297 +0,0 @@
-import { Transform } from "./Transform.js";
-import { Vector2 } from "@math.gl/core";
-import EventEmitter from "eventemitter3";
-import { setProps } from "./utils/setProps.js";
-import { GameObjectEvent } from "./GameObjectEvent.js";
-export { GameObjectEvent } from "./GameObjectEvent.js";
-function hasChildren(go) {
-    return 'children' in go && Array.isArray(go.children);
-}
-class GameObjectEmitter extends EventEmitter {
-    gameObject;
-    constructor(gameObject) {
-        super();
-        this.gameObject = gameObject;
-    }
-    syncUpdateRegistration() {
-        this.gameObject.syncUpdateRegistration();
-    }
-    on(event, fn, context) {
-        super.on(event, fn, context);
-        this.syncUpdateRegistration();
-        return this;
-    }
-    addListener(event, fn, context) {
-        return this.on(event, fn, context);
-    }
-    once(event, fn, context) {
-        super.once(event, fn, context);
-        this.syncUpdateRegistration();
-        return this;
-    }
-    off(event, fn, context, once) {
-        super.off(event, fn, context, once);
-        this.syncUpdateRegistration();
-        return this;
-    }
-    removeListener(event, fn, context, once) {
-        return this.off(event, fn, context, once);
-    }
-    removeAllListeners(event) {
-        super.removeAllListeners(event);
-        this.syncUpdateRegistration();
-        return this;
-    }
-    emit(event, ...args) {
-        const result = super.emit(event, ...args);
-        if (event === GameObject.Event.TICKER_BEFORE || event === GameObject.Event.TICKER_AFTER) {
-            this.syncUpdateRegistration();
-        }
-        return result;
-    }
-}
-export class BaseGameObject {
-    refreshPivot() {
-        // console.log(Object.getPrototypeOf(this));
-        // console.log(this.width);
-        this.display.pivot.x = this.width * this.anchor.x;
-        this.display.pivot.y = this.height * this.anchor.y;
-    }
-}
-export class GameObject extends BaseGameObject {
-    static Event = GameObjectEvent;
-    emitter = new GameObjectEmitter(this);
-    display;
-    transform = new Transform(this);
-    app;
-    parent;
-    components = [];
-    componentTickerHandlers = new Map();
-    _destroying = false;
-    get visible() {
-        return this.display.visible;
-    }
-    set visible(val) {
-        this.display.visible = val;
-    }
-    get x() {
-        return this.transform.x;
-    }
-    set x(val) {
-        this.transform.x = val;
-    }
-    get y() {
-        return this.transform.y;
-    }
-    set y(val) {
-        this.transform.y = val;
-    }
-    get scaleX() {
-        return this.transform.scaleX;
-    }
-    set scaleX(val) {
-        this.transform.scaleX = val;
-    }
-    get scaleY() {
-        return this.transform.scaleY;
-    }
-    set scaleY(val) {
-        this.transform.scaleY = val;
-    }
-    get width() {
-        return this.display.width;
-    }
-    set width(val) {
-        this.display.width = val;
-        this.refreshPivot();
-        this.emitter.emit(GameObject.Event.RESIZE);
-    }
-    get height() {
-        return this.display.height;
-    }
-    set height(val) {
-        this.display.height = val;
-        this.refreshPivot();
-        this.emitter.emit(GameObject.Event.RESIZE);
-    }
-    _anchor = new Vector2();
-    get anchor() {
-        return this._anchor;
-    }
-    set anchor(value) {
-        this.anchorX = value.x;
-        this.anchorY = value.y;
-    }
-    get anchorX() {
-        return this._anchor.x;
-    }
-    set anchorX(value) {
-        this.anchor.x = value;
-        this.refreshPivot();
-    }
-    get anchorY() {
-        return this._anchor.y;
-    }
-    set anchorY(value) {
-        this.anchor.y = value;
-        this.refreshPivot();
-    }
-    get rotation() {
-        return this.transform.rotation;
-    }
-    set rotation(val) {
-        this.transform.rotation = val;
-    }
-    get skewX() {
-        return this.transform.skewX;
-    }
-    set skewX(val) {
-        this.transform.skewX = val;
-    }
-    get skewY() {
-        return this.transform.skewY;
-    }
-    set skewY(val) {
-        this.transform.skewY = val;
-    }
-    /**
-     * 透明度
-     */
-    get alpha() {
-        return this.display.alpha;
-    }
-    set alpha(val) {
-        this.display.alpha = val;
-    }
-    hasUpdateWork() {
-        return !!this.update
-            || this.emitter.listenerCount(GameObject.Event.TICKER_BEFORE) > 0
-            || this.emitter.listenerCount(GameObject.Event.TICKER_AFTER) > 0;
-    }
-    syncUpdateRegistration() {
-        if (this._destroying || !this.app) {
-            return;
-        }
-        if (this.hasUpdateWork()) {
-            this.app.registerUpdateTarget(this);
-        }
-        else {
-            this.app.unregisterUpdateTarget(this);
-        }
-    }
-    setApplication(app) {
-        if (this.app === app) {
-            return;
-        }
-        const previousApp = this.app;
-        this.app = app;
-        if (previousApp) {
-            previousApp.unregisterUpdateTarget(this);
-        }
-        if (hasChildren(this)) {
-            for (const child of this.children) {
-                child.setApplication(app);
-            }
-        }
-        if (app && this.hasUpdateWork()) {
-            app.registerUpdateTarget(this);
-        }
-    }
-    addComponent(component, props) {
-        const _component = new component(this);
-        this.components.push(_component);
-        props && setProps(_component, props);
-        _component.awake && _component.awake();
-        if (_component.update) {
-            let started = false;
-            const tickerHandler = (dt) => {
-                if (!started) {
-                    started = true;
-                    _component.start?.();
-                }
-                if (!this.components.includes(_component)) {
-                    return;
-                }
-                _component.update?.(dt);
-            };
-            this.componentTickerHandlers.set(_component, tickerHandler);
-            this.emitter.on(GameObject.Event.TICKER_BEFORE, tickerHandler, _component);
-        }
-        else if (_component.start) {
-            const tickerHandler = () => {
-                this.componentTickerHandlers.delete(_component);
-                _component.start?.();
-            };
-            this.componentTickerHandlers.set(_component, tickerHandler);
-            this.emitter.once(GameObject.Event.TICKER_BEFORE, tickerHandler, _component);
-        }
-        this.syncUpdateRegistration();
-        return _component;
-    }
-    removeComponent(component) {
-        const index = this.components.indexOf(component);
-        if (index == -1) {
-            return;
-        }
-        this.components.splice(index, 1);
-        const tickerHandler = this.componentTickerHandlers.get(component);
-        if (tickerHandler) {
-            this.emitter.off(GameObject.Event.TICKER_BEFORE, tickerHandler, component);
-            this.componentTickerHandlers.delete(component);
-        }
-        component.gameObject.display.off('destroyed', component.destroy, component);
-        component.onDestroy && component.onDestroy();
-        this.syncUpdateRegistration();
-        return component;
-    }
-    getComponent(component) {
-        return this.components.find(val => val instanceof component);
-    }
-    getComponents(component) {
-        return this.components.filter(val => val instanceof component);
-    }
-    setDisplay(display) {
-        this.display = display;
-        if (this.start) {
-            if (this.display.parent) {
-                this.start.call(this);
-            }
-            else {
-                this.display.once('added', this.start, this);
-            }
-        }
-        this.display.once('destroyed', () => {
-            this._destroying = true;
-            this.setApplication(undefined);
-            queueMicrotask(() => {
-                this.emitter.removeAllListeners();
-            });
-        });
-    }
-    // destroy() {
-    //     this.parent?.removeChild(this);
-    //     this.onDestroy && this.onDestroy();
-    // }
-    static instantiate(gameObject, parent, props) {
-        const go = new gameObject();
-        props && setProps(go, props);
-        go.setDisplay(go.display);
-        go.render?.();
-        parent?.addChild(go);
-        return go;
-    }
-    static async destroy(go) {
-        go._destroying = true;
-        go.setApplication(undefined);
-        if (hasChildren(go)) {
-            for (let i = go.children.length - 1; i >= 0; i--) {
-                GameObject.destroy(go.children[i]);
-            }
-        }
-        go.parent?.removeChild(go);
-        go.onDestroy && go.onDestroy();
-        go.display.destroy();
-        go.emitter.removeAllListeners();
-        go.components.length = 0;
-    }
-}

package/dist/runtime/GameObjectEvent.d.ts

@@ -1,52 +0,0 @@
-import type { GameObject } from "./GameObject.js";
-import type { Group } from "./group/index.js";
-export declare const GameObjectEvent: {
-    /**
-     * 当添加到显示舞台时
-     */
-    readonly ADDED: "added";
-    /**
-     * 当添加新的子节点时
-     */
-    readonly CHILD_ADDED: "childAdded";
-    /**
-     * 移除时
-     */
-    readonly REMOVED: "removed";
-    /**
-     * 移除子元素时
-     */
-    readonly CHILD_REMOVED: "childRemoved";
-    /**
-     * 尺寸发生变化时
-     */
-    readonly RESIZE: "resize";
-    /**
-     * 位置发生变化
-     */
-    readonly REPOSITION: "reposition";
-    /**
-     * 变换发生变化
-     */
-    readonly TRANSFORM_CHANGE: "transformChange";
-    /**
-     * 帧刷新前
-     */
-    readonly TICKER_BEFORE: "tickerBefore";
-    /**
-     * 帧刷新后
-     */
-    readonly TICKER_AFTER: "tickerAfter";
-};
-export interface GameObjectEventMap {
-    [event: string]: any[];
-    [GameObjectEvent.ADDED]: [parent: Group];
-    [GameObjectEvent.CHILD_ADDED]: [child: GameObject];
-    [GameObjectEvent.REMOVED]: [parent: Group];
-    [GameObjectEvent.CHILD_REMOVED]: [child: GameObject];
-    [GameObjectEvent.RESIZE]: [];
-    [GameObjectEvent.REPOSITION]: [];
-    [GameObjectEvent.TRANSFORM_CHANGE]: [];
-    [GameObjectEvent.TICKER_BEFORE]: [dt: number];
-    [GameObjectEvent.TICKER_AFTER]: [dt: number];
-}

package/dist/runtime/GameObjectEvent.js

@@ -1,38 +0,0 @@
-export const GameObjectEvent = {
-    /**
-     * 当添加到显示舞台时
-     */
-    ADDED: 'added',
-    /**
-     * 当添加新的子节点时
-     */
-    CHILD_ADDED: 'childAdded',
-    /**
-     * 移除时
-     */
-    REMOVED: 'removed',
-    /**
-     * 移除子元素时
-     */
-    CHILD_REMOVED: 'childRemoved',
-    /**
-     * 尺寸发生变化时
-     */
-    RESIZE: 'resize',
-    /**
-     * 位置发生变化
-     */
-    REPOSITION: 'reposition',
-    /**
-     * 变换发生变化
-     */
-    TRANSFORM_CHANGE: 'transformChange',
-    /**
-     * 帧刷新前
-     */
-    TICKER_BEFORE: 'tickerBefore',
-    /**
-     * 帧刷新后
-     */
-    TICKER_AFTER: 'tickerAfter'
-};

package/dist/runtime/Transform.d.ts

@@ -1,32 +0,0 @@
-import { Vector2 } from '@math.gl/core';
-import type { GameObject } from './GameObject.js';
-export declare class Transform {
-    gameObject: GameObject;
-    constructor(gameObject: GameObject);
-    private _position;
-    get position(): Vector2;
-    set position(val: Vector2);
-    get x(): number;
-    set x(val: number);
-    get y(): number;
-    set y(val: number);
-    setPosition(x: number, y: number): void;
-    private emitTransformChange;
-    private _scale;
-    get scale(): Vector2;
-    set scale(val: Vector2);
-    get scaleX(): number;
-    set scaleX(val: number);
-    get scaleY(): number;
-    set scaleY(val: number);
-    get pivotX(): number;
-    set pivotX(val: number);
-    get pivotY(): number;
-    set pivotY(val: number);
-    get rotation(): number;
-    set rotation(val: number);
-    get skewX(): number;
-    set skewX(val: number);
-    get skewY(): number;
-    set skewY(val: number);
-}