bard-legends-framework 0.12.1 → 1.0.0-rc0

package/dist/pixi/display-object/objects/graphics/graphics.js

@@ -1,201 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Graphics = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const Pixi = __importStar(require("pixi.js"));
-const game_1 = require("../../../game");
-const game_assets_1 = require("../../../helpers/game-assets");
-const container_1 = require("../../container");
-const sprite_1 = require("../sprite/sprite");
-const dashed_line_helper_1 = require("./helpers/dashed-line.helper");
-class Graphics extends container_1.Container {
-    static { this._drawnTextureCache = new Map(); }
-    static createArrow(size, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        let polygon = [
-            [
-                { x: 0, y: -size / 2 },
-                { x: (size * 3) / 8, y: -size / 8 },
-                { x: size / 4, y: 0 },
-                { x: 0, y: -size / 4 },
-                { x: -size / 4, y: 0 },
-                { x: (-size * 3) / 8, y: -size / 8 }
-            ],
-            [
-                { x: 0, y: -size / 4 },
-                { x: size / 8 - size / 30, y: -size / 8 - size / 30 },
-                { x: size / 8 - size / 30, y: (size * 7) / 16 },
-                { x: -size / 8 + size / 30, y: (size * 7) / 16 },
-                { x: -size / 8 + size / 30, y: -size / 8 - size / 30 }
-            ]
-        ];
-        pixiGraphics.beginFill(color);
-        polygon.forEach(vertices => {
-            pixiGraphics.drawPolygon(vertices.map(vertex => new Pixi.Point(vertex.x, vertex.y)));
-        });
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'arrow', size, color }));
-    }
-    static createDashedLine(from, to, partialOptions) {
-        let options = {
-            width: 2,
-            dashLength: 10,
-            dashGap: 4,
-            lineStartGap: 0,
-            lineEndGap: 0,
-            color: helpers_lib_1.ColorHelper.white,
-            ...partialOptions
-        };
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.lineStyle(options.width, options.color);
-        let lines = dashed_line_helper_1.DashedLineHelper.getLines(from, to, options);
-        lines.forEach(line => {
-            pixiGraphics.moveTo(line.from.x, line.from.y).lineTo(line.to.x, line.to.y);
-        });
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'dashedLine', from, to, options }));
-    }
-    static createVector(from, to, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.lineStyle(2, color);
-        pixiGraphics.moveTo(from.x, from.y);
-        pixiGraphics.lineTo(to.x, to.y);
-        pixiGraphics.lineStyle(1, color);
-        pixiGraphics.beginFill(helpers_lib_1.ColorHelper.white);
-        pixiGraphics.drawCircle(from.x, from.y, 3);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'line', start: from, end: to, color }));
-    }
-    static createRectangleBorders(size, borderSize, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawRect(0, 0, size.x, borderSize);
-        pixiGraphics.drawRect(0, borderSize, borderSize, size.y - borderSize * 2);
-        pixiGraphics.drawRect(size.x - borderSize, borderSize, borderSize, size.y - borderSize * 2);
-        pixiGraphics.drawRect(0, size.y - borderSize, size.x, borderSize);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle-borders', size, borderSize, color }));
-    }
-    static createRectangle(size, color = helpers_lib_1.ColorHelper.white) {
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawRect(0, 0, size.x, size.y);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle', size, color }));
-    }
-    static createCircle(radius, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawCircle(0, 0, radius);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'circle', radius, color }));
-    }
-    static createElipse(size, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawEllipse(0, 0, size.x, size.y);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'elipse', size, color }));
-    }
-    static createPolygon(polygon, color) {
-        let pixiGraphics = new Pixi.Graphics();
-        let cacheName = JSON.stringify({ type: 'polygon', polygon, color });
-        pixiGraphics.beginFill(color);
-        polygon.forEach(vertices => {
-            pixiGraphics.drawPolygon(vertices.map(vertex => new Pixi.Point(vertex.x, vertex.y)));
-        });
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, cacheName);
-    }
-    static createRegularPolygon(sides, radius, color) {
-        let polygon = new Pixi.Graphics();
-        let anglePerStep = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / sides);
-        polygon.beginFill(color);
-        polygon.moveTo(radius, 0);
-        for (let i = 1; i <= sides; i++) {
-            let angle = anglePerStep.multiply(i);
-            let angleVector = angle.vector.normalize(radius);
-            let nextX = radius + angleVector.x;
-            let nextY = radius + angleVector.y;
-            polygon.lineTo(nextX, nextY);
-        }
-        polygon.endFill();
-        return new Graphics(polygon, JSON.stringify({ type: 'regular-polygon', sides, radius, color }));
-    }
-    constructor(pixiGraphics, cacheName) {
-        super();
-        this.pixiContainer.addChild(pixiGraphics);
-        this.pixiGraphics = pixiGraphics;
-        this._cacheName = cacheName;
-    }
-    destroy() {
-        if (!this.destroyed) {
-            super.destroy();
-            !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
-        }
-    }
-    toSprite(partialOptions) {
-        let options = {
-            cacheName: this._cacheName,
-            keepBounds: true,
-            cache: false,
-            ...partialOptions
-        };
-        let textureConversion = this._getTexture(options.cacheName, options.cache);
-        let spriteDefinition = {
-            id: textureConversion.assetID,
-            scale: 1,
-            size: textureConversion.bounds,
-            anchor: { x: 0, y: 0 },
-            boundingShapes: undefined,
-            destroyAssetOnDestroy: !options.cache
-        };
-        let sprite = new sprite_1.Sprite(spriteDefinition, { texturePosition: textureConversion.bounds, ignoreAnchor: true });
-        this.attachToRoot();
-        this.destroy();
-        return sprite;
-    }
-    _getTexture(cacheName, cache) {
-        if (cache) {
-            let textureOfGraphics = Graphics._drawnTextureCache.get(cacheName);
-            if (!textureOfGraphics) {
-                textureOfGraphics = this._createTextureFromGraphics();
-                Graphics._drawnTextureCache.set(cacheName, textureOfGraphics);
-            }
-            return textureOfGraphics;
-        }
-        else {
-            return this._createTextureFromGraphics();
-        }
-    }
-    _createTextureFromGraphics() {
-        let texture = game_1.Game.instance.renderer.generateTexture(this.pixiGraphics);
-        texture.id = game_assets_1.GameAssets.insertAsset(texture);
-        let graphicsBounds = this.pixiGraphics.getBounds();
-        return { assetID: texture.id, bounds: new helpers_lib_1.Vector(graphicsBounds.x, graphicsBounds.y) };
-    }
-}
-exports.Graphics = Graphics;
-//# sourceMappingURL=graphics.js.map

package/dist/pixi/display-object/objects/graphics/helpers/dashed-line.helper.d.ts

@@ -1,16 +0,0 @@
-import { RGBColor, Vector } from 'helpers-lib';
-export interface CreateDashedLineOptions {
-    readonly color: RGBColor;
-    readonly width: number;
-    readonly dashLength: number;
-    readonly dashGap: number;
-    readonly lineStartGap: number;
-    readonly lineEndGap: number;
-}
-export interface Line {
-    readonly from: Vector;
-    readonly to: Vector;
-}
-export declare class DashedLineHelper {
-    static getLines(from: Vector, to: Vector, options: CreateDashedLineOptions): Line[];
-}

package/dist/pixi/display-object/objects/graphics/helpers/dashed-line.helper.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DashedLineHelper = void 0;
-const helpers_lib_1 = require("helpers-lib");
-class DashedLineHelper {
-    static getLines(from, to, options) {
-        let fromTo = helpers_lib_1.Vector.fromTo(from, to);
-        let direction = fromTo.normalize();
-        let availableSpace = fromTo.length - options.lineStartGap - options.lineEndGap;
-        let lines = [];
-        if (availableSpace <= 0) {
-            return lines;
-        }
-        let penPosition = from.add(direction.normalize(options.lineStartGap));
-        if (availableSpace <= options.dashGap + options.dashLength * 0.5) {
-            lines.push({ from: penPosition, to: penPosition.add(direction.normalize(availableSpace)) });
-            return lines;
-        }
-        let regularlySplitSpace = availableSpace - options.dashGap;
-        let iterationLength = options.dashLength + options.dashGap;
-        let regularDashCount = Math.floor(regularlySplitSpace / iterationLength);
-        let leftOverDistance = regularlySplitSpace - iterationLength * regularDashCount;
-        if (regularDashCount >= 1 && leftOverDistance < options.dashLength) {
-            leftOverDistance += iterationLength;
-            regularDashCount--;
-        }
-        let startEndVector = direction.normalize(leftOverDistance / 2);
-        let gapVector = direction.normalize(options.dashGap);
-        lines.push({ from: penPosition, to: penPosition.add(startEndVector) });
-        penPosition = penPosition.add(startEndVector);
-        if (regularDashCount > 0) {
-            let dashVector = direction.normalize(options.dashLength);
-            helpers_lib_1.ArrayHelper.createEmptyArray(regularDashCount).forEach(() => {
-                penPosition = penPosition.add(gapVector);
-                lines.push({ from: penPosition, to: penPosition.add(dashVector) });
-                penPosition = penPosition.add(dashVector);
-            });
-        }
-        penPosition = penPosition.add(gapVector);
-        lines.push({ from: penPosition, to: penPosition.add(startEndVector) });
-        return lines;
-    }
-}
-exports.DashedLineHelper = DashedLineHelper;
-//# sourceMappingURL=dashed-line.helper.js.map

package/dist/pixi/display-object/objects/graphics.d.ts

@@ -1,40 +0,0 @@
-import { RGBColor, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-import { PolygonDefinition, Sprite } from '../..';
-import { ContainerAttributes } from '../container-attributes';
-export interface TextureOfGraphics {
-  readonly assetId: string;
-  readonly bounds: Vector;
-}
-export interface ToSpriteOptions {
-  readonly cache: boolean;
-  readonly cacheName: string;
-  readonly keepBounds: boolean;
-}
-export interface CreateDashedLineOptions {
-  readonly color: RGBColor;
-  readonly width: number;
-  readonly dashLength: number;
-  readonly dashGap: number;
-  readonly lineStartGap: number;
-  readonly lineEndGap: number;
-}
-export declare class Graphics extends ContainerAttributes {
-  private static drawnTextureCache;
-  static createArrow(size: number, color: RGBColor): Graphics;
-  static createDashedLine(from: Vector, to: Vector, partialOptions?: Partial<CreateDashedLineOptions>): Graphics;
-  static createVector(from: Vector, to: Vector, color: RGBColor): Graphics;
-  static createRectangleBorders(size: Vector, borderSize: number, color: RGBColor): Graphics;
-  static createRectangle(size: Vector, color?: RGBColor): Graphics;
-  static createCircle(radius: number, color: RGBColor): Graphics;
-  static createElipse(size: Vector, color: RGBColor): Graphics;
-  static createPolygon(polygon: PolygonDefinition, color: RGBColor): Graphics;
-  static createRegularPolygon(sides: number, radius: number, color: RGBColor): Graphics;
-  readonly pixiGraphics: PIXI.Graphics;
-  private cacheName;
-  protected constructor(pixiGraphics: PIXI.Graphics, cacheName: string);
-  protected destroySelf(): void;
-  toSprite(partialOptions?: Partial<ToSpriteOptions>): Sprite;
-  private getTexture;
-  private createTextureFromGraphics;
-}

package/dist/pixi/display-object/objects/graphics.js

@@ -1,229 +0,0 @@
-var __createBinding =
-  (this && this.__createBinding) ||
-  (Object.create
-    ? (o, m, k, k2) => {
-        if (k2 === undefined) k2 = k;
-        var desc = Object.getOwnPropertyDescriptor(m, k);
-        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-          desc = { enumerable: true, get: () => m[k] };
-        }
-        Object.defineProperty(o, k2, desc);
-      }
-    : (o, m, k, k2) => {
-        if (k2 === undefined) k2 = k;
-        o[k2] = m[k];
-      });
-var __setModuleDefault =
-  (this && this.__setModuleDefault) ||
-  (Object.create
-    ? (o, v) => {
-        Object.defineProperty(o, 'default', { enumerable: true, value: v });
-      }
-    : (o, v) => {
-        o['default'] = v;
-      });
-var __importStar =
-  (this && this.__importStar) ||
-  (mod => {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== 'default' && Object.hasOwn(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-  });
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Graphics = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const PIXI = __importStar(require('pixi.js'));
-const __1 = require('../..');
-const game_1 = require('../../game');
-const game_assets_1 = require('../../helpers/game-assets');
-const container_attributes_1 = require('../container-attributes');
-class Graphics extends container_attributes_1.ContainerAttributes {
-  static {
-    Graphics.drawnTextureCache = new Map();
-  }
-  static createArrow(size, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    const polygon = [
-      [
-        { x: 0, y: -size / 2 },
-        { x: (size * 3) / 8, y: -size / 8 },
-        { x: size / 4, y: 0 },
-        { x: 0, y: -size / 4 },
-        { x: -size / 4, y: 0 },
-        { x: (-size * 3) / 8, y: -size / 8 }
-      ],
-      [
-        { x: 0, y: -size / 4 },
-        { x: size / 8 - size / 30, y: -size / 8 - size / 30 },
-        { x: size / 8 - size / 30, y: (size * 7) / 16 },
-        { x: -size / 8 + size / 30, y: (size * 7) / 16 },
-        { x: -size / 8 + size / 30, y: -size / 8 - size / 30 }
-      ]
-    ];
-    pixiGraphics.beginFill(color);
-    polygon.forEach(vertices => {
-      pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
-    });
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'arrow', size, color }));
-  }
-  static createDashedLine(from, to, partialOptions) {
-    const options = {
-      width: 2,
-      dashLength: 10,
-      dashGap: 4,
-      lineStartGap: 0,
-      lineEndGap: 0,
-      color: helpers_lib_1.ColorHelper.white,
-      ...partialOptions
-    };
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.lineStyle(options.width, options.color);
-    const fromTo = helpers_lib_1.Vector.fromTo(from, to);
-    const direction = fromTo.normalize();
-    const totalDistance = fromTo.length;
-    const availableDistance = totalDistance - options.lineStartGap - options.lineEndGap;
-    if (availableDistance > 0) {
-      const dashCycle = options.dashLength + options.dashGap;
-      const dashCount = Math.floor(availableDistance / dashCycle);
-      let penPosition = from.add(direction.normalize(options.lineStartGap));
-      for (let i = 0; i < dashCount; i++) {
-        const drawTo = penPosition.add(direction.normalize(options.dashLength));
-        pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
-        penPosition = drawTo.add(direction.normalize(options.dashGap));
-      }
-      const remainingDistance = totalDistance - options.lineEndGap - helpers_lib_1.Vector.fromTo(from, penPosition).length;
-      if (remainingDistance > 0) {
-        const drawTo = penPosition.add(direction.normalize(remainingDistance));
-        pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
-      }
-    }
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'dashedLine', from, to, options }));
-  }
-  static createVector(from, to, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.lineStyle(2, color);
-    pixiGraphics.moveTo(from.x, from.y);
-    pixiGraphics.lineTo(to.x, to.y);
-    pixiGraphics.lineStyle(1, color);
-    pixiGraphics.beginFill(helpers_lib_1.ColorHelper.white);
-    pixiGraphics.drawCircle(from.x, from.y, 3);
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'line', start: from, end: to, color }));
-  }
-  static createRectangleBorders(size, borderSize, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.beginFill(color);
-    pixiGraphics.drawRect(0, 0, size.x, borderSize);
-    pixiGraphics.drawRect(0, borderSize, borderSize, size.y - borderSize * 2);
-    pixiGraphics.drawRect(size.x - borderSize, borderSize, borderSize, size.y - borderSize * 2);
-    pixiGraphics.drawRect(0, size.y - borderSize, size.x, borderSize);
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle-borders', size, borderSize, color }));
-  }
-  static createRectangle(size, color = helpers_lib_1.ColorHelper.white) {
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.beginFill(color);
-    pixiGraphics.drawRect(0, 0, size.x, size.y);
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle', size, color }));
-  }
-  static createCircle(radius, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.beginFill(color);
-    pixiGraphics.drawCircle(0, 0, radius);
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'circle', radius, color }));
-  }
-  static createElipse(size, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    pixiGraphics.beginFill(color);
-    pixiGraphics.drawEllipse(0, 0, size.x, size.y);
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, JSON.stringify({ type: 'elipse', size, color }));
-  }
-  static createPolygon(polygon, color) {
-    const pixiGraphics = new PIXI.Graphics();
-    const cacheName = JSON.stringify({ type: 'polygon', polygon, color });
-    pixiGraphics.beginFill(color);
-    polygon.forEach(vertices => {
-      pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
-    });
-    pixiGraphics.endFill();
-    return new Graphics(pixiGraphics, cacheName);
-  }
-  static createRegularPolygon(sides, radius, color) {
-    const polygon = new PIXI.Graphics();
-    const anglePerStep = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / sides);
-    polygon.beginFill(color);
-    polygon.moveTo(radius, 0);
-    for (let i = 1; i <= sides; i++) {
-      const angle = anglePerStep.multiply(i);
-      const angleVector = angle.vector.normalize(radius);
-      const nextX = radius + angleVector.x;
-      const nextY = radius + angleVector.y;
-      polygon.lineTo(nextX, nextY);
-    }
-    polygon.endFill();
-    return new Graphics(polygon, JSON.stringify({ type: 'regular-polygon', sides, radius, color }));
-  }
-  constructor(pixiGraphics, cacheName) {
-    super();
-    this.pixiContainer.addChild(pixiGraphics);
-    this.pixiGraphics = pixiGraphics;
-    this.cacheName = cacheName;
-  }
-  destroySelf() {
-    super.destroySelf();
-    !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
-  }
-  toSprite(partialOptions) {
-    const options = {
-      cacheName: this.cacheName,
-      keepBounds: true,
-      cache: false,
-      ...partialOptions
-    };
-    const textureConversion = this.getTexture(options.cacheName, options.cache);
-    const spriteDefinition = {
-      id: textureConversion.assetId,
-      scale: 1,
-      size: textureConversion.bounds,
-      anchor: { x: 0, y: 0 },
-      boundingShapes: undefined,
-      destroyAssetOnDestroy: !options.cache
-    };
-    const sprite = new __1.Sprite(spriteDefinition, {
-      texturePosition: textureConversion.bounds,
-      ignoreAnchor: true
-    });
-    this.skipAttachCheck();
-    this.destroy();
-    return sprite;
-  }
-  getTexture(cacheName, cache) {
-    if (cache) {
-      let textureOfGraphics = Graphics.drawnTextureCache.get(cacheName);
-      if (!textureOfGraphics) {
-        textureOfGraphics = this.createTextureFromGraphics();
-        Graphics.drawnTextureCache.set(cacheName, textureOfGraphics);
-      }
-      return textureOfGraphics;
-    } else {
-      return this.createTextureFromGraphics();
-    }
-  }
-  createTextureFromGraphics() {
-    const texture = game_1.Game.instance.renderer.generateTexture(this.pixiGraphics);
-    texture.id = game_assets_1.GameAssets.insertAsset(texture);
-    const graphicsBounds = this.pixiGraphics.getBounds();
-    return {
-      assetId: texture.id,
-      bounds: new helpers_lib_1.Vector(graphicsBounds.x, graphicsBounds.y)
-    };
-  }
-}
-exports.Graphics = Graphics;
-//# sourceMappingURL=graphics.js.map

package/dist/pixi/display-object/objects/helpers/filters.d.ts

@@ -1,29 +0,0 @@
-import { Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-export declare class Filters {
-  private container;
-  private colorMatrix;
-  private _red;
-  get red(): number;
-  set red(value: number);
-  private _green;
-  get green(): number;
-  set green(value: number);
-  private _blue;
-  get blue(): number;
-  set blue(value: number);
-  private _brightness;
-  get brightness(): number;
-  set brightness(value: number);
-  private _contrast;
-  get contrast(): number;
-  set contrast(value: number);
-  private blurFilter;
-  private _blur;
-  get blur(): Vector | undefined;
-  set blur(value: Vector | number | undefined);
-  constructor(container: PIXI.Container);
-  removeColorFilter(): void;
-  private refreshColorMatrix;
-  private onFilterChange;
-}