dacha 0.17.0 → 0.17.2

package/build/contrib/components/index.d.ts

@@ -1,23 +1,14 @@
-export { Camera } from './camera';
-export type { CameraConfig } from './camera';
-export { KeyboardControl } from './keyboard-control';
-export type { KeyboardControlConfig } from './keyboard-control';
-export { Collider } from './collider';
-export type { ColliderConfig } from './collider';
-export { RigidBody } from './rigid-body';
-export type { RigidBodyConfig } from './rigid-body';
-export { Animatable } from './animatable';
-export type { AnimatableConfig } from './animatable';
-export { Sprite } from './sprite';
-export type { SpriteConfig } from './sprite';
-export { Transform } from './transform';
-export type { TransformConfig } from './transform';
-export { MouseControl } from './mouse-control';
-export type { MouseControlConfig } from './mouse-control';
-export { Behaviors } from './behaviors';
-export type { BehaviorsConfig } from './behaviors';
-export { AudioSource } from './audio-source';
-export type { AudioSourceConfig } from './audio-source';
+export { Camera, type CameraConfig } from './camera';
+export { KeyboardControl, type KeyboardControlConfig, } from './keyboard-control';
+export { Collider, type ColliderConfig } from './collider';
+export { RigidBody, type RigidBodyConfig } from './rigid-body';
+export { Animatable, type AnimatableConfig } from './animatable';
+export { Sprite, type SpriteConfig } from './sprite';
+export { Transform, type TransformConfig } from './transform';
+export { MouseControl, type MouseControlConfig } from './mouse-control';
+export { Behaviors, type BehaviorsConfig } from './behaviors';
+export { AudioSource, type AudioSourceConfig } from './audio-source';
 export { Shape, type ShapeConfig } from './shape';
 export { PixiView } from './pixi-view';
 export { BitmapText, type BitmapTextConfig } from './bitmap-text';
+export { Mesh, type MeshConfig } from './mesh';

package/build/contrib/components/index.js

@@ -1,5 +1,5 @@
 export { Camera } from './camera';
-export { KeyboardControl } from './keyboard-control';
+export { KeyboardControl, } from './keyboard-control';
 export { Collider } from './collider';
 export { RigidBody } from './rigid-body';
 export { Animatable } from './animatable';
@@ -11,3 +11,4 @@ export { AudioSource } from './audio-source';
 export { Shape } from './shape';
 export { PixiView } from './pixi-view';
 export { BitmapText } from './bitmap-text';
+export { Mesh } from './mesh';

package/build/contrib/components/mesh/index.d.ts

@@ -0,0 +1,107 @@
+import type { Mesh as PixiMesh } from 'pixi.js';
+import { Component } from '../../../engine/component';
+import { type BlendingMode } from '../../types/view';
+interface RenderData {
+    view: PixiMesh;
+    textureSourceKey?: string;
+    textureArrayKey?: string;
+}
+export { type BlendingMode } from '../../types/view';
+export interface MaterialConfig {
+    name: string;
+    options: Record<string, unknown>;
+}
+export interface MeshConfig {
+    src: string;
+    width: number;
+    height: number;
+    slice: number;
+    flipX: boolean;
+    flipY: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    color: string;
+    blending: BlendingMode;
+    opacity: number;
+    material?: MaterialConfig;
+    disabled: boolean;
+}
+/**
+ * Mesh component for rendering 2D textures with a custom shader.
+ *
+ * Handles the visual representation of an actor using a texture.
+ * The material field specifies a shader and its options for the mesh.
+ * Similar to Sprite component,
+ * it can render a single texture or a frame from a sprite sheet.
+ * When a material is not provided, the default shader is used.
+ *
+ * @example
+ * ```typescript
+ * // Create a mesh with a custom material shader
+ * const mesh = new Mesh({
+ *   src: 'assets/flame.png',
+ *   width: 64,
+ *   height: 64,
+ *   slice: 4,
+ *   flipX: false,
+ *   flipY: false,
+ *   sortingLayer: 'units',
+ *   sortCenter: [0, 0],
+ *   color: '#ffffff',
+ *   blending: 'normal',
+ *   opacity: 1,
+ *   disabled: false,
+ *   material: {
+ *     name: 'HeatDistort',
+ *     options: { strength: 0.2 }
+ *   }
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(mesh);
+ *
+ * // Modify properties
+ * mesh.material = undefined; // Remove the heat-distort shader and apply the default one instead
+ * ```
+ *
+ * @category Components
+ */
+export declare class Mesh extends Component {
+    /** Path to the texture image file */
+    src: string;
+    /** Width of the mesh in pixels */
+    width: number;
+    /** Height of the mesh in pixels */
+    height: number;
+    /** Amount of frames in the sprite sheet */
+    slice: number;
+    /** Whether to flip the mesh horizontally */
+    flipX: boolean;
+    /** Whether to flip the mesh vertically */
+    flipY: boolean;
+    /** Whether the mesh is disabled and should not render */
+    disabled: boolean;
+    /** Sorting layer name for rendering order */
+    sortingLayer: string;
+    /** Center point for sorting calculations */
+    sortCenter: [number, number];
+    /** Current frame to render */
+    currentFrame: number;
+    /** Color tint applied to the mesh */
+    color: string;
+    /** Blending mode for rendering */
+    blending: BlendingMode;
+    /** Opacity from 0 (transparent) to 1 (opaque) */
+    opacity: number;
+    /** Material describes a shader and its options applied to a texture (optional). */
+    material?: MaterialConfig;
+    /** Internal rendering data */
+    renderData?: RenderData;
+    /**
+     * Creates a new Mesh component.
+     *
+     * @param config - Configuration for the sprite
+     */
+    constructor(config: MeshConfig);
+    clone(): Mesh;
+}

package/build/contrib/components/mesh/index.js

@@ -0,0 +1,115 @@
+import { Component } from '../../../engine/component';
+/**
+ * Mesh component for rendering 2D textures with a custom shader.
+ *
+ * Handles the visual representation of an actor using a texture.
+ * The material field specifies a shader and its options for the mesh.
+ * Similar to Sprite component,
+ * it can render a single texture or a frame from a sprite sheet.
+ * When a material is not provided, the default shader is used.
+ *
+ * @example
+ * ```typescript
+ * // Create a mesh with a custom material shader
+ * const mesh = new Mesh({
+ *   src: 'assets/flame.png',
+ *   width: 64,
+ *   height: 64,
+ *   slice: 4,
+ *   flipX: false,
+ *   flipY: false,
+ *   sortingLayer: 'units',
+ *   sortCenter: [0, 0],
+ *   color: '#ffffff',
+ *   blending: 'normal',
+ *   opacity: 1,
+ *   disabled: false,
+ *   material: {
+ *     name: 'HeatDistort',
+ *     options: { strength: 0.2 }
+ *   }
+ * });
+ *
+ * // Add to actor
+ * actor.setComponent(mesh);
+ *
+ * // Modify properties
+ * mesh.material = undefined; // Remove the heat-distort shader and apply the default one instead
+ * ```
+ *
+ * @category Components
+ */
+export class Mesh extends Component {
+    /** Path to the texture image file */
+    src;
+    /** Width of the mesh in pixels */
+    width;
+    /** Height of the mesh in pixels */
+    height;
+    /** Amount of frames in the sprite sheet */
+    slice;
+    /** Whether to flip the mesh horizontally */
+    flipX;
+    /** Whether to flip the mesh vertically */
+    flipY;
+    /** Whether the mesh is disabled and should not render */
+    disabled;
+    /** Sorting layer name for rendering order */
+    sortingLayer;
+    /** Center point for sorting calculations */
+    sortCenter;
+    /** Current frame to render */
+    currentFrame;
+    /** Color tint applied to the mesh */
+    color;
+    /** Blending mode for rendering */
+    blending;
+    /** Opacity from 0 (transparent) to 1 (opaque) */
+    opacity;
+    /** Material describes a shader and its options applied to a texture (optional). */
+    material;
+    /** Internal rendering data */
+    renderData;
+    /**
+     * Creates a new Mesh component.
+     *
+     * @param config - Configuration for the sprite
+     */
+    constructor(config) {
+        super();
+        this.src = config.src;
+        this.width = config.width;
+        this.height = config.height;
+        this.slice = config.slice;
+        this.currentFrame = 0;
+        this.flipX = config.flipX;
+        this.flipY = config.flipY;
+        this.disabled = config.disabled;
+        this.sortingLayer = config.sortingLayer;
+        this.sortCenter = config.sortCenter;
+        this.color = config.color ?? '#ffffff';
+        this.blending = config.blending ?? 'normal';
+        this.opacity = config.opacity ?? 1;
+        this.material = config.material;
+    }
+    clone() {
+        return new Mesh({
+            src: this.src,
+            width: this.width,
+            height: this.height,
+            slice: this.slice,
+            flipX: this.flipX,
+            flipY: this.flipY,
+            disabled: this.disabled,
+            sortingLayer: this.sortingLayer,
+            sortCenter: this.sortCenter.slice(0),
+            color: this.color,
+            blending: this.blending,
+            opacity: this.opacity,
+            material: this.material
+                ? { name: this.material.name, options: { ...this.material.options } }
+                : undefined,
+        });
+    }
+}
+Mesh.componentName = 'Mesh';

package/build/contrib/systems/behavior-system/system.js

@@ -20,7 +20,7 @@ export class BehaviorSystem extends SceneSystem {
     activeBehaviors;
     constructor(options) {
         super();
-        const { actorSpawner, world, scene, globalOptions, resources = {}, } = options;
+        const { actorSpawner, world, scene, globalOptions, resources = [], } = options;
         this.world = world;
         this.scene = scene;
         this.behaviorQuery = new ActorQuery({

package/build/contrib/systems/index.d.ts

@@ -11,4 +11,4 @@ export type { BehaviorOptions } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService } from './renderer';
+export { Renderer, RendererService, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/index.js

@@ -9,4 +9,4 @@ export { PhysicsSystem } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService } from './renderer';
+export { Renderer, RendererService, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/renderer/actor-render-tree.d.ts

@@ -1,11 +1,13 @@
-import { Container, type ViewContainer, type IRenderLayer } from 'pixi.js';
+import { Container, type ViewContainer, type RenderLayer } from 'pixi.js';
 import { type Scene } from '../../../engine/scene';
 import type { Assets } from './assets';
+import { MaterialSystem } from './material';
 interface ActorRenderTreeOptions {
     worldContainer: Container;
     scene: Scene;
     assets: Assets;
-    sortingLayers: Map<string, IRenderLayer>;
+    sortingLayers: Map<string, RenderLayer>;
+    materialSystem: MaterialSystem;
 }
 export declare class ActorRenderTree {
     private scene;
@@ -16,7 +18,7 @@ export declare class ActorRenderTree {
     private builders;
     private actorContainerMap;
     private actorParentMap;
-    constructor({ scene, worldContainer, assets, sortingLayers, }: ActorRenderTreeOptions);
+    constructor({ scene, worldContainer, assets, sortingLayers, materialSystem, }: ActorRenderTreeOptions);
     private handleAddComponent;
     private handleRemoveComponent;
     private handleAddChildEntity;

package/build/contrib/systems/renderer/actor-render-tree.js

@@ -5,9 +5,10 @@ import { Sprite } from '../../components/sprite';
 import { Shape } from '../../components/shape';
 import { PixiView } from '../../components/pixi-view';
 import { BitmapText } from '../../components/bitmap-text';
+import { Mesh } from '../../components/mesh';
 import { traverseEntity } from '../../../engine/entity';
 import { AddComponent, RemoveComponent, AddChildEntity, RemoveChildEntity, } from '../../../engine/events';
-import { SpriteBuilder, ShapeBuilder, PixiViewBuilder, BitmapTextBuilder, } from './builders';
+import { SpriteBuilder, ShapeBuilder, PixiViewBuilder, BitmapTextBuilder, MeshBuilder, } from './builders';
 import { floatEquals } from './utils';
 export class ActorRenderTree {
     scene;
@@ -18,7 +19,7 @@ export class ActorRenderTree {
     builders;
     actorContainerMap;
     actorParentMap;
-    constructor({ scene, worldContainer, assets, sortingLayers, }) {
+    constructor({ scene, worldContainer, assets, sortingLayers, materialSystem, }) {
         this.scene = scene;
         this.worldContainer = worldContainer;
         this.assets = assets;
@@ -31,6 +32,7 @@ export class ActorRenderTree {
         this.builders.set(Shape.componentName, new ShapeBuilder());
         this.builders.set(PixiView.componentName, new PixiViewBuilder());
         this.builders.set(BitmapText.componentName, new BitmapTextBuilder({ assets }));
+        this.builders.set(Mesh.componentName, new MeshBuilder({ assets, materialSystem }));
         this.scene.children.forEach((actor) => traverseEntity(actor, (entry) => this.add(entry)));
         this.scene.addEventListener(AddComponent, this.handleAddComponent);
         this.scene.addEventListener(RemoveComponent, this.handleRemoveComponent);

package/build/contrib/systems/renderer/assets/index.d.ts

@@ -3,6 +3,7 @@ import { Actor } from '../../../../engine/actor';
 import { Scene } from '../../../../engine/scene';
 import { type TemplateCollection } from '../../../../engine/template';
 import { Sprite } from '../../../components/sprite';
+import { Mesh } from '../../../components/mesh';
 import { BitmapText } from '../../../components/bitmap-text';
 import type { ViewComponent } from '../types';
 interface AssetsOptions {
@@ -14,7 +15,8 @@ export declare class Assets {
     constructor({ templateCollection }: AssetsOptions);
     load(entity: Actor | Scene | ViewComponent): Promise<void>;
     unload(entity: Scene | Actor | ViewComponent): void;
-    get(view: Sprite): HTMLImageElement | undefined;
+    get(view: Sprite | Mesh): HTMLImageElement | undefined;
     get(view: BitmapText): BitmapFont | undefined;
+    private loadViewImage;
 }
 export {};

package/build/contrib/systems/renderer/assets/index.js

@@ -2,6 +2,7 @@ import { Assets as PixiAssets } from 'pixi.js';
 import { Actor } from '../../../../engine/actor';
 import { Scene } from '../../../../engine/scene';
 import { Sprite } from '../../../components/sprite';
+import { Mesh } from '../../../components/mesh';
 import { BitmapText } from '../../../components/bitmap-text';
 import { CacheStore } from '../../../../engine/data-lib';
 import { getAllImageSources, getAllFontSources, loadImage } from './utils';
@@ -39,17 +40,11 @@ export class Assets {
         if (entity instanceof Actor) {
             const sprite = entity.getComponent(Sprite);
             if (sprite) {
-                const { src } = sprite;
-                if (this.imageStore.has(src)) {
-                    this.imageStore.retain(src);
-                }
-                else {
-                    const image = await loadImage(src);
-                    if (image) {
-                        this.imageStore.add(src, image);
-                        this.imageStore.retain(src);
-                    }
-                }
+                await this.loadViewImage(sprite.src);
+            }
+            const mesh = entity.getComponent(Mesh);
+            if (mesh) {
+                await this.loadViewImage(mesh.src);
             }
             const text = entity.getComponent(BitmapText);
             if (text) {
@@ -57,18 +52,8 @@ export class Assets {
             }
             return;
         }
-        if (entity instanceof Sprite) {
-            const { src } = entity;
-            if (this.imageStore.has(src)) {
-                this.imageStore.retain(src);
-            }
-            else {
-                const image = await loadImage(src);
-                if (image) {
-                    this.imageStore.add(src, image);
-                    this.imageStore.retain(src);
-                }
-            }
+        if (entity instanceof Sprite || entity instanceof Mesh) {
+            await this.loadViewImage(entity.src);
         }
     }
     unload(entity) {
@@ -93,7 +78,7 @@ export class Assets {
         }
     }
     get(view) {
-        if (view instanceof Sprite) {
+        if (view instanceof Sprite || view instanceof Mesh) {
             return this.imageStore.get(view.src);
         }
         if (view instanceof BitmapText) {
@@ -101,4 +86,16 @@ export class Assets {
             return PixiAssets.cache._cache.get(view.font);
         }
     }
+    async loadViewImage(src) {
+        if (this.imageStore.has(src)) {
+            this.imageStore.retain(src);
+        }
+        else {
+            const image = await loadImage(src);
+            if (image) {
+                this.imageStore.add(src, image);
+                this.imageStore.retain(src);
+            }
+        }
+    }
 }

package/build/contrib/systems/renderer/assets/utils.js

@@ -1,4 +1,5 @@
 import { Sprite } from '../../../components/sprite';
+import { Mesh } from '../../../components/mesh';
 import { BitmapText } from '../../../components/bitmap-text';
 import { ResourceLoader } from '../../../../engine/resource-loader';
 import { traverseEntity } from '../../../../engine/entity';
@@ -24,6 +25,10 @@ export const getAllImageSources = (actors) => {
             if (sprite?.src) {
                 sources.push(sprite.src);
             }
+            const mesh = entity.getComponent(Mesh);
+            if (mesh?.src) {
+                sources.push(mesh.src);
+            }
         });
     });
     return sources;

package/build/contrib/systems/renderer/builders/index.d.ts

@@ -2,4 +2,5 @@ export { SpriteBuilder } from './sprite-builder';
 export { ShapeBuilder } from './shape-builder';
 export { PixiViewBuilder } from './pixi-view-builder';
 export { BitmapTextBuilder } from './bitmap-text-builder';
+export { MeshBuilder } from './mesh-builder';
 export type { Builder } from './builder';

package/build/contrib/systems/renderer/builders/index.js

@@ -2,3 +2,4 @@ export { SpriteBuilder } from './sprite-builder';
 export { ShapeBuilder } from './shape-builder';
 export { PixiViewBuilder } from './pixi-view-builder';
 export { BitmapTextBuilder } from './bitmap-text-builder';
+export { MeshBuilder } from './mesh-builder';

package/build/contrib/systems/renderer/builders/mesh-builder/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const GEOMETRY_POSITIONS: Float32Array;
+export declare const GEOMETRY_INDICES: Uint32Array;

package/build/contrib/systems/renderer/builders/mesh-builder/consts.js

@@ -0,0 +1,2 @@
+export const GEOMETRY_POSITIONS = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
+export const GEOMETRY_INDICES = new Uint32Array([0, 1, 2, 0, 2, 3]);

package/build/contrib/systems/renderer/builders/mesh-builder/index.d.ts

@@ -0,0 +1,22 @@
+import { Mesh as PixiMesh } from 'pixi.js';
+import type { MaterialSystem } from '../../material';
+import type { Assets } from '../../assets';
+import type { Builder } from '../builder';
+import { Mesh } from '../../../../components/mesh';
+import type { Actor } from '../../../../../engine/actor';
+interface MeshBuilderOptions {
+    assets: Assets;
+    materialSystem: MaterialSystem;
+}
+export declare class MeshBuilder implements Builder<Mesh> {
+    private assets;
+    private materialSystem;
+    private textureArrayStore;
+    constructor({ assets, materialSystem }: MeshBuilderOptions);
+    destroy(mesh: Mesh): void;
+    buildView(mesh: Mesh, actor: Actor): PixiMesh;
+    updateView(mesh: Mesh): void;
+    private updateGeometry;
+    private updateTexture;
+}
+export {};

package/build/contrib/systems/renderer/builders/mesh-builder/index.js

@@ -0,0 +1,114 @@
+import { Texture, Mesh as PixiMesh, MeshGeometry } from 'pixi.js';
+import { BLEND_MODE_MAPPING } from '../../consts';
+import { Mesh } from '../../../../components/mesh';
+import { TextureArrayStore } from '../texture-array-store';
+import { GEOMETRY_POSITIONS, GEOMETRY_INDICES } from './consts';
+export class MeshBuilder {
+    assets;
+    materialSystem;
+    textureArrayStore;
+    constructor({ assets, materialSystem }) {
+        this.assets = assets;
+        this.materialSystem = materialSystem;
+        this.textureArrayStore = new TextureArrayStore(assets);
+    }
+    destroy(mesh) {
+        this.textureArrayStore.removeTextureArray(mesh);
+        this.materialSystem.destroyShader(mesh);
+        mesh.renderData?.view.destroy();
+        mesh.renderData = undefined;
+    }
+    buildView(mesh, actor) {
+        const view = new PixiMesh({
+            geometry: new MeshGeometry({
+                positions: GEOMETRY_POSITIONS,
+                uvs: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
+                indices: GEOMETRY_INDICES,
+            }),
+            pivot: 0.5,
+        });
+        mesh.renderData = { view };
+        view.__dacha = {
+            actor,
+            builderKey: Mesh.componentName,
+            viewComponent: mesh,
+            meta: {},
+        };
+        this.updateView(mesh);
+        return view;
+    }
+    updateView(mesh) {
+        const view = mesh.renderData.view;
+        const meta = view.__dacha.meta;
+        if (mesh.disabled !== meta.disabled) {
+            view.visible = !mesh.disabled;
+            meta.disabled = mesh.disabled;
+        }
+        if (mesh.color !== meta.color) {
+            view.tint = mesh.color;
+            meta.color = mesh.color;
+        }
+        if (mesh.blending !== meta.blending) {
+            view.blendMode = BLEND_MODE_MAPPING[mesh.blending];
+            meta.blending = mesh.blending;
+        }
+        if (mesh.opacity !== meta.opacity) {
+            view.alpha = mesh.opacity;
+            meta.opacity = mesh.opacity;
+        }
+        if (mesh.src !== meta.src ||
+            mesh.slice !== meta.slice ||
+            mesh.currentFrame !== meta.currentFrame) {
+            this.updateTexture(mesh);
+        }
+        const scaleX = mesh.flipX ? -1 : 1;
+        const scaleY = mesh.flipY ? -1 : 1;
+        if (scaleX !== meta.scaleX ||
+            scaleY !== meta.scaleY ||
+            mesh.width !== meta.width ||
+            mesh.height !== meta.height) {
+            view.scale.set(mesh.width * scaleX, mesh.height * scaleY);
+            meta.scaleX = scaleX;
+            meta.scaleY = scaleY;
+            meta.width = mesh.width;
+            meta.height = mesh.height;
+        }
+        this.materialSystem.updateShader(mesh);
+    }
+    updateGeometry(mesh) {
+        const view = mesh.renderData.view;
+        const texture = view.texture;
+        const geometry = view.geometry;
+        const uvs = texture?.uvs;
+        if (!uvs) {
+            return;
+        }
+        const uvAttr = geometry.getAttribute('aUV');
+        const uvBuffer = uvAttr.buffer.data;
+        uvBuffer[0] = uvs.x0;
+        uvBuffer[1] = uvs.y0;
+        uvBuffer[2] = uvs.x1;
+        uvBuffer[3] = uvs.y1;
+        uvBuffer[4] = uvs.x2;
+        uvBuffer[5] = uvs.y2;
+        uvBuffer[6] = uvs.x3;
+        uvBuffer[7] = uvs.y3;
+        uvAttr.buffer.update();
+    }
+    updateTexture(mesh) {
+        const view = mesh.renderData.view;
+        const meta = view.__dacha.meta;
+        if (this.assets.get(mesh) &&
+            (mesh.src !== meta.src || mesh.slice !== meta.slice)) {
+            view.label = mesh.src;
+            this.textureArrayStore.updateTextureArray(mesh);
+            meta.src = mesh.src;
+            meta.slice = mesh.slice;
+        }
+        const textureArray = this.textureArrayStore.getTextureArray(mesh);
+        const texture = textureArray?.[mesh.currentFrame];
+        view.texture = texture ?? Texture.WHITE;
+        meta.currentFrame = mesh.currentFrame;
+        this.updateGeometry(mesh);
+    }
+}

package/build/contrib/systems/renderer/builders/sprite-builder/index.d.ts

@@ -8,13 +8,10 @@ interface SpriteBuilderOptions {
 }
 export declare class SpriteBuilder implements Builder<Sprite> {
     private assets;
-    private textureSourceMap;
-    private textureArrayMap;
+    private textureArrayStore;
     constructor({ assets }: SpriteBuilderOptions);
     destroy(sprite: Sprite): void;
     buildView(sprite: Sprite, actor: Actor): PixiSprite | TilingSprite;
     updateView(sprite: Sprite): void;
-    private updateTextureArray;
-    private getTextureArray;
 }
 export {};