bard-legends-framework 0.11.0 → 0.12.0

package/dist/pixi/display-object/filters/base-filters/blur.filter.js

@@ -25,11 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlurFilter = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const game_1 = require("../../../game");
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../../../pixi-definitions");
 const gaussian_values_helper_1 = require("../helpers/gaussian-values.helper");
-class BlurFilterPass extends PIXI.Filter {
-    static getVertexShader() {
+class BlurFilterPass extends Pixi.Filter {
+    static _getVertexShader() {
         return `
       attribute vec2 aVertexPosition;
       attribute vec2 aTextureCoord;
@@ -44,7 +44,7 @@ class BlurFilterPass extends PIXI.Filter {
       }
     `;
     }
-    static getFragmentShader(multipliers, isHorizontal) {
+    static _getFragmentShader(multipliers, isHorizontal) {
         let shader = `
       uniform sampler2D uSampler;
 
@@ -71,44 +71,44 @@ class BlurFilterPass extends PIXI.Filter {
     `;
         return shader;
     }
-    constructor(strength, horizontal) {
-        super(BlurFilterPass.getVertexShader(), BlurFilterPass.getFragmentShader(gaussian_values_helper_1.GaussianValuesHelper.getValuesForLinearSamplingGauss(strength), horizontal));
-        this.horizontal = horizontal;
-        this.resolution = game_1.DEFAULT_RESOLUTION;
+    constructor(strength, _horizontal) {
+        super(BlurFilterPass._getVertexShader(), BlurFilterPass._getFragmentShader(gaussian_values_helper_1.GaussianValuesHelper.getValuesForLinearSamplingGauss(strength), _horizontal));
+        this._horizontal = _horizontal;
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
     }
     apply(filterManager, input, output, clearMode) {
-        this.uniforms.pixelSize = this.horizontal ? 1 / (input.width * game_1.DEFAULT_RESOLUTION) : 1 / (input.height * game_1.DEFAULT_RESOLUTION);
+        this.uniforms.pixelSize = this._horizontal ? 1 / (input.width * pixi_definitions_1.DEFAULT_RESOLUTION) : 1 / (input.height * pixi_definitions_1.DEFAULT_RESOLUTION);
         filterManager.applyFilter(this, input, output, clearMode);
     }
 }
-class BlurFilter extends PIXI.Filter {
-    constructor(strength = new helpers_lib_1.Vector(2, 2)) {
+class BlurFilter extends Pixi.Filter {
+    constructor(_strength = new helpers_lib_1.Vector(2, 2)) {
         super();
-        this.strength = strength;
-        this.resolution = game_1.DEFAULT_RESOLUTION;
-        this.strength = strength.multiplyNumber(game_1.DEFAULT_RESOLUTION).floor();
-        if (this.strength.x < 0 || this.strength.y < 0) {
+        this._strength = _strength;
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
+        this._strength = _strength.multiplyNumber(pixi_definitions_1.DEFAULT_RESOLUTION).floor();
+        if (this._strength.x < 0 || this._strength.y < 0) {
             throw new Error('BlurFilterLinearSampling: Strength * Resolution must be greater than 0');
         }
-        else if (this.strength.x > 100 || this.strength.y > 100) {
+        else if (this._strength.x > 100 || this._strength.y > 100) {
             throw new Error('BlurFilterLinearSampling: Strength * Resolution cannot be higher than 100');
         }
-        this.horizontalFilter = new BlurFilterPass(this.strength.x, true);
-        this.verticalFilter = new BlurFilterPass(this.strength.y, false);
-        this.padding = Math.max(this.strength.x, this.strength.y);
+        this._horizontalFilter = new BlurFilterPass(this._strength.x, true);
+        this._verticalFilter = new BlurFilterPass(this._strength.y, false);
+        this.padding = Math.max(this._strength.x, this._strength.y);
     }
     apply(filterManager, input, output, clearMode) {
         let renderTarget = filterManager.getFilterTexture();
-        this.verticalFilter.apply(filterManager, input, renderTarget, PIXI.CLEAR_MODES.CLEAR);
-        this.horizontalFilter.apply(filterManager, renderTarget, output, clearMode);
+        this._verticalFilter.apply(filterManager, input, renderTarget, Pixi.CLEAR_MODES.CLEAR);
+        this._horizontalFilter.apply(filterManager, renderTarget, output, clearMode);
         filterManager.returnFilterTexture(renderTarget);
     }
     get blendMode() {
-        return this.horizontalFilter.blendMode;
+        return this._horizontalFilter.blendMode;
     }
     set blendMode(value) {
-        this.horizontalFilter.blendMode = value;
-        this.verticalFilter.blendMode = value;
+        this._horizontalFilter.blendMode = value;
+        this._verticalFilter.blendMode = value;
     }
 }
 exports.BlurFilter = BlurFilter;

package/dist/pixi/display-object/filters/base-filters/expand-with-color.filter.d.ts

@@ -1,9 +1,9 @@
 import { RGBColor } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-export declare class ExpandWithColorFilter extends PIXI.Filter {
-    private expand;
-    private static getVertexShader;
-    private static getFragmentShader;
-    constructor(expand: number, color: RGBColor);
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
+import * as Pixi from 'pixi.js';
+export declare class ExpandWithColorFilter extends Pixi.Filter {
+    private _expand;
+    private static _getVertexShader;
+    private static _getFragmentShader;
+    constructor(_expand: number, color: RGBColor);
+    apply(filterManager: Pixi.FilterSystem, input: Pixi.RenderTexture, output: Pixi.RenderTexture, clearMode: Pixi.CLEAR_MODES): void;
 }

package/dist/pixi/display-object/filters/base-filters/expand-with-color.filter.js

@@ -25,10 +25,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpandWithColorFilter = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const game_1 = require("../../../game");
-class ExpandWithColorFilter extends PIXI.Filter {
-    static getVertexShader() {
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../../../pixi-definitions");
+class ExpandWithColorFilter extends Pixi.Filter {
+    static _getVertexShader() {
         return `
       attribute vec2 aVertexPosition;
       attribute vec2 aTextureCoord;
@@ -43,7 +43,7 @@ class ExpandWithColorFilter extends PIXI.Filter {
       }
     `;
     }
-    static getFragmentShader(expand) {
+    static _getFragmentShader(expand) {
         let shader = `
       uniform sampler2D uSampler;
       uniform vec2 pixelSize;
@@ -75,27 +75,27 @@ class ExpandWithColorFilter extends PIXI.Filter {
       }`;
         return shader;
     }
-    constructor(expand, color) {
-        super(ExpandWithColorFilter.getVertexShader(), ExpandWithColorFilter.getFragmentShader(expand * game_1.DEFAULT_RESOLUTION));
-        this.expand = expand;
-        this.resolution = game_1.DEFAULT_RESOLUTION;
-        this.expand = expand * game_1.DEFAULT_RESOLUTION;
-        if (this.expand < 0) {
+    constructor(_expand, color) {
+        super(ExpandWithColorFilter._getVertexShader(), ExpandWithColorFilter._getFragmentShader(_expand * pixi_definitions_1.DEFAULT_RESOLUTION));
+        this._expand = _expand;
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
+        this._expand = _expand * pixi_definitions_1.DEFAULT_RESOLUTION;
+        if (this._expand < 0) {
             throw new Error('ExpandWithColorFilter: Expand * resolution cannot be smaller than 0');
         }
-        else if (this.expand > 10) {
+        else if (this._expand > 10) {
             throw new Error('ExpandWithColorFilter: Expand * resolution cannot be higher than 10');
         }
-        if (!helpers_lib_1.Comparator.isInteger(this.expand)) {
-            this.expand = Math.floor(this.expand);
+        if (!helpers_lib_1.Comparator.isInteger(this._expand)) {
+            this._expand = Math.floor(this._expand);
         }
         let normalizedColor = helpers_lib_1.ColorHelper.normalize(color);
         this.uniforms.color = new Float32Array([normalizedColor.red, normalizedColor.green, normalizedColor.blue]);
-        this.uniforms.expandSquared = this.expand * this.expand;
-        this.padding = this.expand;
+        this.uniforms.expandSquared = this._expand * this._expand;
+        this.padding = this._expand;
     }
     apply(filterManager, input, output, clearMode) {
-        this.uniforms.pixelSize = new Float32Array([1 / (input.width * game_1.DEFAULT_RESOLUTION), 1 / (input.height * game_1.DEFAULT_RESOLUTION)]);
+        this.uniforms.pixelSize = new Float32Array([1 / (input.width * pixi_definitions_1.DEFAULT_RESOLUTION), 1 / (input.height * pixi_definitions_1.DEFAULT_RESOLUTION)]);
         filterManager.applyFilter(this, input, output, clearMode);
     }
 }

package/dist/pixi/display-object/filters/composite-filters/glow-filter.d.ts

@@ -1,8 +1,8 @@
-import * as PIXI from 'pixi.js';
-import { GlowOptions } from '../../..';
-export declare class GlowFilter extends PIXI.Filter {
-    private expandWithColorFilter;
-    private blurFilter;
+import * as Pixi from 'pixi.js';
+import { GlowOptions } from '../../../pixi-definitions';
+export declare class GlowFilter extends Pixi.Filter {
+    private _expandWithColorFilter;
+    private _blurFilter;
     constructor(partialOptions?: Partial<GlowOptions>);
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
+    apply(filterManager: Pixi.FilterSystem, input: Pixi.RenderTexture, output: Pixi.RenderTexture, clearMode: Pixi.CLEAR_MODES): void;
 }

package/dist/pixi/display-object/filters/composite-filters/glow-filter.js

@@ -25,34 +25,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlowFilter = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const __1 = require("../../..");
-const game_1 = require("../../../game");
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../../../pixi-definitions");
 const blur_filter_1 = require("../base-filters/blur.filter");
 const expand_with_color_filter_1 = require("../base-filters/expand-with-color.filter");
-class GlowFilter extends PIXI.Filter {
+class GlowFilter extends Pixi.Filter {
     constructor(partialOptions) {
         super();
-        this.resolution = game_1.DEFAULT_RESOLUTION;
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
         let options = {
             blurRadius: 1,
             expand: 0,
             color: helpers_lib_1.ColorHelper.white,
-            blendMode: __1.BlendMode.screen,
+            blendMode: pixi_definitions_1.BlendMode.Screen,
             ...partialOptions
         };
-        this.expandWithColorFilter = new expand_with_color_filter_1.ExpandWithColorFilter(options.expand, options.color);
+        this._expandWithColorFilter = new expand_with_color_filter_1.ExpandWithColorFilter(options.expand, options.color);
         let blurRadiusVector = helpers_lib_1.Comparator.isNumber(options.blurRadius)
             ? new helpers_lib_1.Vector(options.blurRadius, options.blurRadius)
             : options.blurRadius;
-        this.blurFilter = new blur_filter_1.BlurFilter(blurRadiusVector);
+        this._blurFilter = new blur_filter_1.BlurFilter(blurRadiusVector);
         this.padding = Math.max(blurRadiusVector.x, blurRadiusVector.y) + options.expand;
-        this.blurFilter.blendMode = PIXI.BLEND_MODES.SCREEN;
+        this._blurFilter.blendMode = Pixi.BLEND_MODES.SCREEN;
     }
     apply(filterManager, input, output, clearMode) {
         let renderTarget = filterManager.getFilterTexture();
-        this.expandWithColorFilter.apply(filterManager, input, renderTarget, PIXI.CLEAR_MODES.CLEAR);
-        this.blurFilter.apply(filterManager, renderTarget, output, clearMode);
+        this._expandWithColorFilter.apply(filterManager, input, renderTarget, Pixi.CLEAR_MODES.CLEAR);
+        this._blurFilter.apply(filterManager, renderTarget, output, clearMode);
         filterManager.returnFilterTexture(renderTarget);
     }
 }

package/dist/pixi/display-object/filters/helpers/gaussian-values.helper.d.ts

@@ -3,8 +3,8 @@ export interface BlurFilterMultipliers {
     multiplier: number;
 }
 export declare class GaussianValuesHelper {
-    private static gaussianKernel;
+    private static _gaussianKernel;
     static getValuesForLinearSamplingPascal(strength: number): BlurFilterMultipliers[];
     static getValuesForLinearSamplingGauss(strength: number): BlurFilterMultipliers[];
-    private static convertValuesToDiscreteSampling;
+    private static _convertValuesToDiscreteSampling;
 }

package/dist/pixi/display-object/filters/helpers/gaussian-values.helper.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GaussianValuesHelper = void 0;
 const helpers_lib_1 = require("helpers-lib");
 class GaussianValuesHelper {
-    static gaussianKernel(x, sigma) {
+    static _gaussianKernel(x, sigma) {
         let sigmaSquared = sigma * sigma;
         let coefficient = 1 / (helpers_lib_1.PI_360 * sigmaSquared);
         let exponent = -(x * x) / (2 * sigmaSquared);
@@ -25,7 +25,7 @@ class GaussianValuesHelper {
         });
         let multiplier = 1 / sumOfRow;
         let values = acceptedValues.map(value => value * multiplier);
-        return this.convertValuesToDiscreteSampling(values);
+        return this._convertValuesToDiscreteSampling(values);
     }
     static getValuesForLinearSamplingGauss(strength) {
         if (strength === 0) {
@@ -38,14 +38,14 @@ class GaussianValuesHelper {
             ];
         }
         else {
-            let values = helpers_lib_1.ArrayHelper.createIntegerArray(Math.ceil(strength * 0.75)).map(x => this.gaussianKernel(x, strength * 0.4));
+            let values = helpers_lib_1.ArrayHelper.createIntegerArray(Math.ceil(strength * 0.75)).map(x => this._gaussianKernel(x, strength * 0.4));
             let sum = values.reduce((acc, value) => acc + value, 0);
             sum = sum * 2 - values[0];
             values = values.map(value => value / sum);
-            return this.convertValuesToDiscreteSampling(values);
+            return this._convertValuesToDiscreteSampling(values);
         }
     }
-    static convertValuesToDiscreteSampling(values) {
+    static _convertValuesToDiscreteSampling(values) {
         let result = [{ offset: 0, multiplier: values[0] }];
         for (let i = 1; i < values.length - 1; i += 2) {
             let multiplier = values[i] + values[i + 1];

package/dist/pixi/display-object/filters/templates/checking-neighbors.template.d.ts

@@ -1,7 +1,7 @@
-import * as PIXI from 'pixi.js';
-export declare class CheckingNeighborsTemplate extends PIXI.Filter {
-    private static getVertexShader;
-    private static getFragmentShader;
+import * as Pixi from 'pixi.js';
+export declare class CheckingNeighborsTemplate extends Pixi.Filter {
+    private static _getVertexShader;
+    private static _getFragmentShader;
     constructor();
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
+    apply(filterManager: Pixi.FilterSystem, input: Pixi.RenderTexture, output: Pixi.RenderTexture, clearMode: Pixi.CLEAR_MODES): void;
 }

package/dist/pixi/display-object/filters/templates/checking-neighbors.template.js

@@ -24,10 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckingNeighborsTemplate = void 0;
-const PIXI = __importStar(require("pixi.js"));
-const game_1 = require("../../../game");
-class CheckingNeighborsTemplate extends PIXI.Filter {
-    static getVertexShader() {
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../../../pixi-definitions");
+class CheckingNeighborsTemplate extends Pixi.Filter {
+    static _getVertexShader() {
         return `
       attribute vec2 aVertexPosition;
       attribute vec2 aTextureCoord;
@@ -42,7 +42,7 @@ class CheckingNeighborsTemplate extends PIXI.Filter {
       }
     `;
     }
-    static getFragmentShader() {
+    static _getFragmentShader() {
         return `
       uniform sampler2D uSampler;
       uniform vec2 pixelSize;
@@ -62,11 +62,11 @@ class CheckingNeighborsTemplate extends PIXI.Filter {
     `;
     }
     constructor() {
-        super(CheckingNeighborsTemplate.getVertexShader(), CheckingNeighborsTemplate.getFragmentShader());
-        this.resolution = game_1.DEFAULT_RESOLUTION;
+        super(CheckingNeighborsTemplate._getVertexShader(), CheckingNeighborsTemplate._getFragmentShader());
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
     }
     apply(filterManager, input, output, clearMode) {
-        this.uniforms.pixelSize = new Float32Array([1 / (input.width * game_1.DEFAULT_RESOLUTION), 1 / (input.height * game_1.DEFAULT_RESOLUTION)]);
+        this.uniforms.pixelSize = new Float32Array([1 / (input.width * pixi_definitions_1.DEFAULT_RESOLUTION), 1 / (input.height * pixi_definitions_1.DEFAULT_RESOLUTION)]);
         filterManager.applyFilter(this, input, output, clearMode);
     }
 }

package/dist/pixi/display-object/filters/templates/plane.template.d.ts

@@ -1,7 +1,7 @@
-import * as PIXI from 'pixi.js';
-export declare class PlaneTemplate extends PIXI.Filter {
-    private static getVertexShader;
-    private static getFragmentShader;
+import * as Pixi from 'pixi.js';
+export declare class PlaneTemplate extends Pixi.Filter {
+    private static _getVertexShader;
+    private static _getFragmentShader;
     constructor();
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
+    apply(filterManager: Pixi.FilterSystem, input: Pixi.RenderTexture, output: Pixi.RenderTexture, clearMode: Pixi.CLEAR_MODES): void;
 }

package/dist/pixi/display-object/filters/templates/plane.template.js

@@ -24,10 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlaneTemplate = void 0;
-const PIXI = __importStar(require("pixi.js"));
-const game_1 = require("../../../game");
-class PlaneTemplate extends PIXI.Filter {
-    static getVertexShader() {
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../../../pixi-definitions");
+class PlaneTemplate extends Pixi.Filter {
+    static _getVertexShader() {
         return `
       attribute vec2 aVertexPosition;
       attribute vec2 aTextureCoord;
@@ -42,7 +42,7 @@ class PlaneTemplate extends PIXI.Filter {
       }
     `;
     }
-    static getFragmentShader() {
+    static _getFragmentShader() {
         return `
       uniform sampler2D uSampler;
 
@@ -54,8 +54,8 @@ class PlaneTemplate extends PIXI.Filter {
     `;
     }
     constructor() {
-        super(PlaneTemplate.getVertexShader(), PlaneTemplate.getFragmentShader());
-        this.resolution = game_1.DEFAULT_RESOLUTION;
+        super(PlaneTemplate._getVertexShader(), PlaneTemplate._getFragmentShader());
+        this.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
     }
     apply(filterManager, input, output, clearMode) {
         filterManager.applyFilter(this, input, output, clearMode);

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

@@ -1,8 +1,8 @@
 import { Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
+import * as Pixi from 'pixi.js';
 export declare class Filters {
-    private container;
-    private colorMatrix;
+    private _container;
+    private _colorMatrix;
     private _red;
     get red(): number;
     set red(value: number);
@@ -18,12 +18,12 @@ export declare class Filters {
     private _contrast;
     get contrast(): number;
     set contrast(value: number);
-    private blurFilter;
+    private _blurFilter;
     private _blur;
     get blur(): Vector | undefined;
     set blur(value: Vector | number | undefined);
-    constructor(container: PIXI.Container);
+    constructor(_container: Pixi.Container);
     removeColorFilter(): void;
-    private refreshColorMatrix;
-    private onFilterChange;
+    private _refreshColorMatrix;
+    private _onFilterChange;
 }

package/dist/pixi/display-object/filters.js

@@ -25,8 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Filters = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const game_1 = require("../game");
+const Pixi = __importStar(require("pixi.js"));
+const pixi_definitions_1 = require("../pixi-definitions");
 const blur_filter_1 = require("./filters/base-filters/blur.filter");
 class Filters {
     get red() {
@@ -34,35 +34,35 @@ class Filters {
     }
     set red(value) {
         this._red = value;
-        this.refreshColorMatrix();
+        this._refreshColorMatrix();
     }
     get green() {
         return this._green;
     }
     set green(value) {
         this._green = value;
-        this.refreshColorMatrix();
+        this._refreshColorMatrix();
     }
     get blue() {
         return this._blue;
     }
     set blue(value) {
         this._blue = value;
-        this.refreshColorMatrix();
+        this._refreshColorMatrix();
     }
     get brightness() {
         return this._brightness;
     }
     set brightness(value) {
         this._brightness = value;
-        this.refreshColorMatrix();
+        this._refreshColorMatrix();
     }
     get contrast() {
         return this._contrast;
     }
     set contrast(value) {
         this._contrast = value;
-        this.refreshColorMatrix();
+        this._refreshColorMatrix();
     }
     get blur() {
         return this._blur;
@@ -73,46 +73,46 @@ class Filters {
             (this._blur && !blurVector) ||
             (!this._blur && blurVector)) {
             this._blur = blurVector;
-            if (this.blurFilter) {
-                this.blurFilter.destroy();
-                this.blurFilter = undefined;
+            if (this._blurFilter) {
+                this._blurFilter.destroy();
+                this._blurFilter = undefined;
             }
             if (blurVector) {
-                this.blurFilter = new blur_filter_1.BlurFilter(blurVector);
-                this.onFilterChange();
+                this._blurFilter = new blur_filter_1.BlurFilter(blurVector);
+                this._onFilterChange();
             }
         }
     }
-    constructor(container) {
-        this.container = container;
+    constructor(_container) {
+        this._container = _container;
         this._red = 1;
         this._green = 1;
         this._blue = 1;
         this._brightness = 1;
         this._contrast = 1;
-        this.onFilterChange();
+        this._onFilterChange();
     }
     removeColorFilter() {
-        this.colorMatrix?.destroy();
-        this.colorMatrix = undefined;
-        this.onFilterChange();
+        this._colorMatrix?.destroy();
+        this._colorMatrix = undefined;
+        this._onFilterChange();
     }
-    refreshColorMatrix() {
+    _refreshColorMatrix() {
         if (this._red === 1 && this._green === 1 && this._blue === 1 && this._brightness === 1 && this._contrast === 1) {
-            if (this.colorMatrix) {
-                this.colorMatrix.destroy();
-                this.colorMatrix = undefined;
-                this.onFilterChange();
+            if (this._colorMatrix) {
+                this._colorMatrix.destroy();
+                this._colorMatrix = undefined;
+                this._onFilterChange();
             }
         }
         else {
-            if (!this.colorMatrix) {
-                this.colorMatrix = new PIXI.ColorMatrixFilter();
-                this.colorMatrix.resolution = game_1.DEFAULT_RESOLUTION;
-                this.onFilterChange();
+            if (!this._colorMatrix) {
+                this._colorMatrix = new Pixi.ColorMatrixFilter();
+                this._colorMatrix.resolution = pixi_definitions_1.DEFAULT_RESOLUTION;
+                this._onFilterChange();
             }
             // prettier-ignore
-            this.colorMatrix.matrix = [
+            this._colorMatrix.matrix = [
                 this._red * this._contrast,
                 0,
                 0,
@@ -136,15 +136,15 @@ class Filters {
             ];
         }
     }
-    onFilterChange() {
+    _onFilterChange() {
         let filters = [];
-        if (this.blurFilter) {
-            filters.push(this.blurFilter);
+        if (this._blurFilter) {
+            filters.push(this._blurFilter);
         }
-        if (this.colorMatrix) {
-            filters.push(this.colorMatrix);
+        if (this._colorMatrix) {
+            filters.push(this._colorMatrix);
         }
-        this.container.filters = filters;
+        this._container.filters = filters;
     }
 }
 exports.Filters = Filters;

package/dist/pixi/display-object/index.d.ts

@@ -4,6 +4,6 @@ export { Graphics } from './objects/graphics/graphics';
 export { CreateDashedLineOptions } from './objects/graphics/helpers/dashed-line.helper';
 export { Placeholder } from './objects/placeholder';
 export { Sprite } from './objects/sprite/sprite';
-export { DropShadowOptions, PartialTextOptions, TextOptions } from './objects/text/helpers/process-steps/1-data-in-converter/pixi-text-style-converter';
+export { DropShadowOptions, PartialTextOptions, TextAlignment, TextOptions } from './objects/text/helpers/process-steps/1-data-in-converter/pixi-text-style-converter';
 export { RichText, RichTextOptions, RichTextRectangleCut, RichTextStyles } from './objects/text/rich-text';
 export { Text } from './objects/text/text';

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

@@ -1,11 +1,11 @@
 import { RGBColor, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-import { PolygonDefinition } from '../../..';
+import * as Pixi from 'pixi.js';
+import { PolygonDefinition } from '../../../pixi-definitions';
 import { Container } from '../../container';
 import { Sprite } from '../sprite/sprite';
 import { CreateDashedLineOptions } from './helpers/dashed-line.helper';
 export interface TextureOfGraphics {
-    readonly assetId: string;
+    readonly assetID: string;
     readonly bounds: Vector;
 }
 export interface ToSpriteOptions {
@@ -14,7 +14,7 @@ export interface ToSpriteOptions {
     readonly keepBounds: boolean;
 }
 export declare class Graphics extends Container {
-    private static drawnTextureCache;
+    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;
@@ -24,11 +24,11 @@ export declare class Graphics extends Container {
     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);
+    readonly pixiGraphics: Pixi.Graphics;
+    private _cacheName;
+    protected constructor(pixiGraphics: Pixi.Graphics, cacheName: string);
     destroy(): void;
     toSprite(partialOptions?: Partial<ToSpriteOptions>): Sprite;
-    private getTexture;
-    private createTextureFromGraphics;
+    private _getTexture;
+    private _createTextureFromGraphics;
 }