@zylem/game-lib 0.3.14

package/dist/lib/debug/debug-state.d.ts

@@ -0,0 +1,43 @@
+export type DebugConfiguration = {
+    showCollisionBounds?: boolean;
+    showModelBounds?: boolean;
+    showSpriteBounds?: boolean;
+};
+export declare const DebugTools: {
+    readonly NONE: "NONE";
+    readonly SELECT: "SELECT";
+    readonly ADD: "ADD";
+    readonly DELETE: "DELETE";
+};
+declare const debugState: {
+    on: boolean;
+    paused: boolean;
+    configuration: {
+        showCollisionBounds: boolean;
+        showModelBounds: boolean;
+        showSpriteBounds: boolean;
+    };
+    hovered: string | null;
+    selected: string[];
+    tool: keyof typeof DebugTools;
+};
+declare const setDebugFlag: (flag?: boolean) => void;
+declare const setSelectedEntity: (uuid: string) => void;
+declare const resetSelectedEntities: () => void;
+/**
+ * Set the active debug tool and print the selection to the debug console.
+ * @param tool The tool to activate
+ */
+declare const setDebugTool: (tool: keyof typeof DebugTools) => void;
+declare const getDebugTool: () => "NONE" | "SELECT" | "ADD" | "DELETE";
+declare const setHoveredEntity: (uuid: string) => void;
+declare const resetHoveredEntity: () => void;
+declare const getHoveredEntity: () => string | null;
+export { debugState, setDebugFlag, setSelectedEntity, resetSelectedEntities, setDebugTool, getDebugTool, setHoveredEntity, resetHoveredEntity, getHoveredEntity };
+export declare const togglePause: () => void;
+/**
+ * Set pause state directly and print the new state to the console.
+ * @param paused Whether to pause (true) or resume (false)
+ */
+export declare const setPaused: (paused: boolean) => void;
+export declare const isPaused: () => boolean;

package/dist/lib/debug/debug-store.d.ts

@@ -0,0 +1,14 @@
+import { DebugTools } from './debug-state';
+export declare const debugStore: {
+    debug: boolean;
+    tool: keyof typeof DebugTools;
+    paused: boolean;
+    hovered: string | null;
+    selected: string[];
+}, setDebugStore: import("solid-js/store").SetStoreFunction<{
+    debug: boolean;
+    tool: keyof typeof DebugTools;
+    paused: boolean;
+    hovered: string | null;
+    selected: string[];
+}>;

package/dist/lib/debug/state-based-debug-loader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * State-Based Debug Module Loader
+ *
+ * This approach integrates with the existing debug state system
+ * and loads the debug module when debug state changes to true.
+ */
+export {};

package/dist/lib/device/desktop.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/device/mobile.d.ts

@@ -0,0 +1 @@
+export declare function isMobile(): boolean;

package/dist/lib/device/tablet.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/entities/actor.d.ts

@@ -0,0 +1,57 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { Object3D, Group } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { UpdateContext } from '../core/base-node-life-cycle';
+import { EntityLoaderDelegate } from './delegates/loader';
+import { Vec3 } from '../core/vector';
+import { AnimationOptions } from './delegates/animation';
+import { MaterialOptions } from '../graphics/material';
+import { DebugInfoProvider } from './delegates/debug';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+type AnimationObject = {
+    key?: string;
+    path: string;
+};
+type ZylemActorOptions = GameEntityOptions & {
+    static?: boolean;
+    animations?: AnimationObject[];
+    models?: string[];
+    scale?: Vec3;
+    material?: MaterialOptions;
+};
+export declare class ActorCollisionBuilder extends EntityCollisionBuilder {
+    private height;
+    private objectModel;
+    constructor(data: any);
+    createColliderFromObjectModel(objectModel: Group | null): ColliderDesc;
+    collider(options: ZylemActorOptions): ColliderDesc;
+}
+export declare class ActorBuilder extends EntityBuilder<ZylemActor, ZylemActorOptions> {
+    protected createEntity(options: Partial<ZylemActorOptions>): ZylemActor;
+}
+export declare const ACTOR_TYPE: unique symbol;
+export declare class ZylemActor extends GameEntity<ZylemActorOptions> implements EntityLoaderDelegate, DebugInfoProvider {
+    static type: symbol;
+    private _object;
+    private _animationDelegate;
+    private _modelFileNames;
+    private _assetLoader;
+    controlledRotation: boolean;
+    constructor(options?: ZylemActorOptions);
+    load(): Promise<void>;
+    data(): Promise<any>;
+    actorUpdate(params: UpdateContext<ZylemActorOptions>): Promise<void>;
+    private loadModels;
+    playAnimation(animationOptions: AnimationOptions): void;
+    get object(): Object3D | null;
+    /**
+     * Provide custom debug information for the actor
+     * This will be merged with the default debug information
+     */
+    getDebugInfo(): Record<string, any>;
+}
+type ActorOptions = BaseNode | ZylemActorOptions;
+export declare function actor(...args: Array<ActorOptions>): Promise<ZylemActor>;
+export {};

package/dist/lib/entities/box.d.ts

@@ -0,0 +1,26 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { BoxGeometry } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+import { EntityMeshBuilder } from './builder';
+type ZylemBoxOptions = GameEntityOptions;
+export declare class BoxCollisionBuilder extends EntityCollisionBuilder {
+    collider(options: GameEntityOptions): ColliderDesc;
+}
+export declare class BoxMeshBuilder extends EntityMeshBuilder {
+    build(options: GameEntityOptions): BoxGeometry;
+}
+export declare class BoxBuilder extends EntityBuilder<ZylemBox, ZylemBoxOptions> {
+    protected createEntity(options: Partial<ZylemBoxOptions>): ZylemBox;
+}
+export declare const BOX_TYPE: unique symbol;
+export declare class ZylemBox extends GameEntity<ZylemBoxOptions> {
+    static type: symbol;
+    constructor(options?: ZylemBoxOptions);
+    buildInfo(): Record<string, any>;
+}
+type BoxOptions = BaseNode | ZylemBoxOptions;
+export declare function box(...args: Array<BoxOptions>): Promise<ZylemBox>;
+export {};

package/dist/lib/entities/builder.d.ts

@@ -0,0 +1,27 @@
+import { ColliderDesc } from "@dimforge/rapier3d-compat";
+import { GameEntity, GameEntityOptions } from "./entity";
+import { BufferGeometry, Group, Material } from "three";
+import { CollisionBuilder } from "../collision/collision-builder";
+import { MeshBuilder } from "../graphics/mesh";
+import { MaterialBuilder, MaterialOptions } from "../graphics/material";
+import { Vec3 } from "../core/vector";
+export declare abstract class EntityCollisionBuilder extends CollisionBuilder {
+    abstract collider(options: GameEntityOptions): ColliderDesc;
+}
+export declare abstract class EntityMeshBuilder extends MeshBuilder {
+    build(options: GameEntityOptions): BufferGeometry;
+    postBuild(): void;
+}
+export declare abstract class EntityBuilder<T extends GameEntity<U> & P, U extends GameEntityOptions, P = any> {
+    protected meshBuilder: EntityMeshBuilder | null;
+    protected collisionBuilder: EntityCollisionBuilder | null;
+    protected materialBuilder: MaterialBuilder | null;
+    protected options: Partial<U>;
+    protected entity: T;
+    constructor(options: Partial<U>, entity: T, meshBuilder: EntityMeshBuilder | null, collisionBuilder: EntityCollisionBuilder | null);
+    withPosition(setupPosition: Vec3): this;
+    withMaterial(options: Partial<MaterialOptions>, entityType: symbol): Promise<this>;
+    applyMaterialToGroup(group: Group, materials: Material[]): void;
+    build(): Promise<T>;
+    protected abstract createEntity(options: Partial<U>): T;
+}

package/dist/lib/entities/create.d.ts

@@ -0,0 +1,14 @@
+import { GameEntityOptions, GameEntity } from "./entity";
+import { EntityBuilder } from "./builder";
+import { EntityCollisionBuilder } from "./builder";
+import { EntityMeshBuilder } from "./builder";
+export interface CreateGameEntityOptions<T extends GameEntity<any>, CreateOptions extends GameEntityOptions> {
+    args: Array<any>;
+    defaultConfig: GameEntityOptions;
+    EntityClass: new (options: any) => T;
+    BuilderClass: new (options: any, entity: T, meshBuilder: any, collisionBuilder: any) => EntityBuilder<T, CreateOptions>;
+    MeshBuilderClass?: new (data: any) => EntityMeshBuilder;
+    CollisionBuilderClass?: new (data: any) => EntityCollisionBuilder;
+    entityType: symbol;
+}
+export declare function createEntity<T extends GameEntity<any>, CreateOptions extends GameEntityOptions>(params: CreateGameEntityOptions<T, CreateOptions>): Promise<T>;

package/dist/lib/entities/delegates/animation.d.ts

@@ -0,0 +1,32 @@
+import { AnimationClip, Object3D } from 'three';
+export type AnimationOptions = {
+    key: string;
+    pauseAtEnd?: boolean;
+    pauseAtPercentage?: number;
+    fadeToKey?: string;
+    fadeDuration?: number;
+};
+type AnimationObject = {
+    key?: string;
+    path: string;
+};
+export declare class AnimationDelegate {
+    private target;
+    private _mixer;
+    private _actions;
+    private _animations;
+    private _currentAction;
+    private _pauseAtPercentage;
+    private _isPaused;
+    private _queuedKey;
+    private _fadeDuration;
+    private _currentKey;
+    private _assetLoader;
+    constructor(target: Object3D);
+    loadAnimations(animations: AnimationObject[]): Promise<void>;
+    update(delta: number): void;
+    playAnimation(opts: AnimationOptions): void;
+    get currentAnimationKey(): string;
+    get animations(): AnimationClip[];
+}
+export {};

package/dist/lib/entities/delegates/debug.d.ts

@@ -0,0 +1,37 @@
+import { GameEntity, GameEntityOptions } from '../entity';
+/**
+ * Interface for entities that provide custom debug information
+ */
+export interface DebugInfoProvider {
+    getDebugInfo(): Record<string, any>;
+}
+/**
+ * Helper to check if an object implements DebugInfoProvider
+ */
+export declare function hasDebugInfo(obj: any): obj is DebugInfoProvider;
+/**
+ * Debug delegate that provides debug information for entities
+ */
+export declare class DebugDelegate {
+    private entity;
+    constructor(entity: GameEntity<any>);
+    /**
+     * Get formatted position string
+     */
+    private getPositionString;
+    /**
+     * Get formatted rotation string (in degrees)
+     */
+    private getRotationString;
+    /**
+     * Get material information
+     */
+    private getMaterialInfo;
+    private getPhysicsInfo;
+    buildDebugInfo(): Record<string, any>;
+}
+export declare class EnhancedDebugInfoBuilder {
+    private customBuilder?;
+    constructor(customBuilder?: (options: GameEntityOptions) => Record<string, any>);
+    buildInfo(options: GameEntityOptions, entity?: GameEntity<any>): Record<string, any>;
+}

package/dist/lib/entities/delegates/loader.d.ts

@@ -0,0 +1,11 @@
+export declare function isLoadable(obj: any): obj is EntityLoaderDelegate;
+export interface EntityLoaderDelegate {
+    load(): Promise<void>;
+    data(): any;
+}
+export declare class EntityLoader {
+    entityReference: EntityLoaderDelegate;
+    constructor(entity: EntityLoaderDelegate);
+    load(): Promise<void>;
+    data(): Promise<any>;
+}

package/dist/lib/entities/destroy.d.ts

@@ -0,0 +1,3 @@
+import { DestroyFunction } from "../core/base-node-life-cycle";
+export declare function destroyEntity<T>(entity: T, globals: any, destroyFunction: DestroyFunction<T>): void;
+export declare function destroy(entity: any, globals?: any): void;

package/dist/lib/entities/entity.d.ts

@@ -0,0 +1,100 @@
+import { Mesh, Material, ShaderMaterial, Group, Color } from "three";
+import { Collider, ColliderDesc, RigidBody, RigidBodyDesc } from "@dimforge/rapier3d-compat";
+import { Vec3 } from "../core/vector";
+import { MaterialBuilder, MaterialOptions } from "../graphics/material";
+import { PhysicsOptions } from "../collision/physics";
+import { CollisionOptions } from "../collision/collision";
+import { BaseNode } from "../core/base-node";
+import { DestroyContext, SetupContext, UpdateContext } from "../core/base-node-life-cycle";
+import type { EntityMeshBuilder, EntityCollisionBuilder } from "./builder";
+export declare abstract class AbstractEntity {
+    abstract uuid: string;
+    abstract eid: number;
+    abstract name: string;
+}
+export interface LifeCycleDelegate<U> {
+    setup?: ((params: SetupContext<U>) => void)[];
+    update?: ((params: UpdateContext<U>) => void)[];
+    destroy?: ((params: DestroyContext<U>) => void)[];
+}
+export interface CollisionContext<T, O extends GameEntityOptions, TGlobals extends Record<string, unknown> = any> {
+    entity: T;
+    other: GameEntity<O>;
+    globals: TGlobals;
+}
+export type BehaviorContext<T, O extends GameEntityOptions> = SetupContext<T, O> | UpdateContext<T, O> | CollisionContext<T, O> | DestroyContext<T, O>;
+export type BehaviorCallback<T, O extends GameEntityOptions> = (params: BehaviorContext<T, O>) => void;
+export interface CollisionDelegate<T, O extends GameEntityOptions> {
+    collision?: ((params: CollisionContext<T, O>) => void)[];
+}
+export type IBuilder<BuilderOptions = any> = {
+    preBuild: (options: BuilderOptions) => BuilderOptions;
+    build: (options: BuilderOptions) => BuilderOptions;
+    postBuild: (options: BuilderOptions) => BuilderOptions;
+};
+export type GameEntityOptions = {
+    name?: string;
+    color?: Color;
+    size?: Vec3;
+    position?: Vec3;
+    batched?: boolean;
+    collision?: Partial<CollisionOptions>;
+    physics?: Partial<PhysicsOptions>;
+    material?: Partial<MaterialOptions>;
+    custom?: {
+        [key: string]: any;
+    };
+    collisionType?: string;
+    collisionGroup?: string;
+    collisionFilter?: string[];
+    _builders?: {
+        meshBuilder?: IBuilder | EntityMeshBuilder | null;
+        collisionBuilder?: IBuilder | EntityCollisionBuilder | null;
+        materialBuilder?: MaterialBuilder | null;
+    };
+};
+export declare abstract class GameEntityLifeCycle {
+    abstract _setup(params: SetupContext<this>): void;
+    abstract _update(params: UpdateContext<this>): void;
+    abstract _destroy(params: DestroyContext<this>): void;
+}
+export interface EntityDebugInfo {
+    buildInfo: () => Record<string, string>;
+}
+export type BehaviorCallbackType = 'setup' | 'update' | 'destroy' | 'collision';
+export declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implements GameEntityLifeCycle, EntityDebugInfo {
+    group: Group | undefined;
+    mesh: Mesh | undefined;
+    materials: Material[] | undefined;
+    bodyDesc: RigidBodyDesc | null;
+    body: RigidBody | null;
+    colliderDesc: ColliderDesc | undefined;
+    collider: Collider | undefined;
+    custom: Record<string, any>;
+    debugInfo: Record<string, any>;
+    debugMaterial: ShaderMaterial | undefined;
+    lifeCycleDelegate: LifeCycleDelegate<O>;
+    collisionDelegate: CollisionDelegate<this, O>;
+    collisionType?: string;
+    behaviorCallbackMap: Record<BehaviorCallbackType, BehaviorCallback<this, O>[]>;
+    constructor();
+    create(): this;
+    onSetup(...callbacks: ((params: SetupContext<this>) => void)[]): this;
+    onUpdate(...callbacks: ((params: UpdateContext<this>) => void)[]): this;
+    onDestroy(...callbacks: ((params: DestroyContext<this>) => void)[]): this;
+    onCollision(...callbacks: ((params: CollisionContext<this, O>) => void)[]): this;
+    _setup(params: SetupContext<this>): void;
+    _update(params: UpdateContext<this>): void;
+    _destroy(params: DestroyContext<this>): void;
+    _collision(other: GameEntity<O>, globals?: any): void;
+    addBehavior(behaviorCallback: ({
+        type: BehaviorCallbackType;
+        handler: any;
+    })): this;
+    addBehaviors(behaviorCallbacks: ({
+        type: BehaviorCallbackType;
+        handler: any;
+    })[]): this;
+    protected updateMaterials(params: any): void;
+    buildInfo(): Record<string, string>;
+}

package/dist/lib/entities/index.d.ts

@@ -0,0 +1,11 @@
+export * from './actor';
+export * from './box';
+export * from './plane';
+export * from './sphere';
+export * from './sprite';
+export * from './zone';
+export * from './text';
+export * from './rect';
+export { createEntity } from './create';
+export * from './delegates/debug';
+export type { AbstractEntity, GameEntity, GameEntityOptions, } from './entity';

package/dist/lib/entities/object.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/entities/plane.d.ts

@@ -0,0 +1,35 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { Vector2 } from 'three';
+import { TexturePath } from '../graphics/material';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+import { EntityMeshBuilder } from './builder';
+import { XZPlaneGeometry } from '../graphics/geometries/XZPlaneGeometry';
+type ZylemPlaneOptions = GameEntityOptions & {
+    tile?: Vector2;
+    repeat?: Vector2;
+    texture?: TexturePath;
+    subdivisions?: number;
+};
+export declare class PlaneCollisionBuilder extends EntityCollisionBuilder {
+    collider(options: ZylemPlaneOptions): ColliderDesc;
+}
+export declare class PlaneMeshBuilder extends EntityMeshBuilder {
+    heightData: Float32Array;
+    columnsRows: Map<any, any>;
+    build(options: ZylemPlaneOptions): XZPlaneGeometry;
+    postBuild(): void;
+}
+export declare class PlaneBuilder extends EntityBuilder<ZylemPlane, ZylemPlaneOptions> {
+    protected createEntity(options: Partial<ZylemPlaneOptions>): ZylemPlane;
+}
+export declare const PLANE_TYPE: unique symbol;
+export declare class ZylemPlane extends GameEntity<ZylemPlaneOptions> {
+    static type: symbol;
+    constructor(options?: ZylemPlaneOptions);
+}
+type PlaneOptions = BaseNode | Partial<ZylemPlaneOptions>;
+export declare function plane(...args: Array<PlaneOptions>): Promise<ZylemPlane>;
+export {};

package/dist/lib/entities/rect.d.ts

@@ -0,0 +1,62 @@
+import { Color, Vector2 } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+type ZylemRectOptions = GameEntityOptions & {
+    width?: number;
+    height?: number;
+    fillColor?: Color | string | null;
+    strokeColor?: Color | string | null;
+    strokeWidth?: number;
+    radius?: number;
+    padding?: number;
+    stickToViewport?: boolean;
+    screenPosition?: Vector2;
+    zDistance?: number;
+    anchor?: Vector2;
+    bounds?: {
+        screen?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        world?: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+            z?: number;
+        };
+    };
+};
+export declare class RectBuilder extends EntityBuilder<ZylemRect, ZylemRectOptions> {
+    protected createEntity(options: Partial<ZylemRectOptions>): ZylemRect;
+}
+export declare const RECT_TYPE: unique symbol;
+export declare class ZylemRect extends GameEntity<ZylemRectOptions> {
+    static type: symbol;
+    private _sprite;
+    private _mesh;
+    private _texture;
+    private _canvas;
+    private _ctx;
+    private _cameraRef;
+    private _lastCanvasW;
+    private _lastCanvasH;
+    constructor(options?: ZylemRectOptions);
+    private createSprite;
+    private redrawRect;
+    private roundedRectPath;
+    private toCssColor;
+    private rectSetup;
+    private rectUpdate;
+    private updateStickyTransform;
+    private worldToScreen;
+    private computeScreenBoundsFromOptions;
+    updateRect(options?: Partial<Pick<ZylemRectOptions, 'width' | 'height' | 'fillColor' | 'strokeColor' | 'strokeWidth' | 'radius'>>): void;
+    buildInfo(): Record<string, any>;
+}
+type RectOptions = BaseNode | Partial<ZylemRectOptions>;
+export declare function rect(...args: Array<RectOptions>): Promise<ZylemRect>;
+export {};

package/dist/lib/entities/sphere.d.ts

@@ -0,0 +1,28 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { SphereGeometry } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+import { EntityMeshBuilder } from './builder';
+type ZylemSphereOptions = GameEntityOptions & {
+    radius?: number;
+};
+export declare class SphereCollisionBuilder extends EntityCollisionBuilder {
+    collider(options: ZylemSphereOptions): ColliderDesc;
+}
+export declare class SphereMeshBuilder extends EntityMeshBuilder {
+    build(options: ZylemSphereOptions): SphereGeometry;
+}
+export declare class SphereBuilder extends EntityBuilder<ZylemSphere, ZylemSphereOptions> {
+    protected createEntity(options: Partial<ZylemSphereOptions>): ZylemSphere;
+}
+export declare const SPHERE_TYPE: unique symbol;
+export declare class ZylemSphere extends GameEntity<ZylemSphereOptions> {
+    static type: symbol;
+    constructor(options?: ZylemSphereOptions);
+    buildInfo(): Record<string, any>;
+}
+type SphereOptions = BaseNode | Partial<ZylemSphereOptions>;
+export declare function sphere(...args: Array<SphereOptions>): Promise<ZylemSphere>;
+export {};

package/dist/lib/entities/sprite.d.ts

@@ -0,0 +1,52 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+import { Sprite as ThreeSprite } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+import { DestroyContext, UpdateContext } from '../core/base-node-life-cycle';
+export type SpriteImage = {
+    name: string;
+    file: string;
+};
+export type SpriteAnimation = {
+    name: string;
+    frames: string[];
+    speed: number | number[];
+    loop: boolean;
+};
+type ZylemSpriteOptions = GameEntityOptions & {
+    images?: SpriteImage[];
+    animations?: SpriteAnimation[];
+    size?: Vector3;
+    collisionSize?: Vector3;
+};
+export declare class SpriteCollisionBuilder extends EntityCollisionBuilder {
+    collider(options: ZylemSpriteOptions): ColliderDesc;
+}
+export declare class SpriteBuilder extends EntityBuilder<ZylemSprite, ZylemSpriteOptions> {
+    protected createEntity(options: Partial<ZylemSpriteOptions>): ZylemSprite;
+}
+export declare const SPRITE_TYPE: unique symbol;
+export declare class ZylemSprite extends GameEntity<ZylemSpriteOptions> {
+    static type: symbol;
+    protected sprites: ThreeSprite[];
+    protected spriteMap: Map<string, number>;
+    protected currentSpriteIndex: number;
+    protected animations: Map<string, any>;
+    protected currentAnimation: any;
+    protected currentAnimationFrame: string;
+    protected currentAnimationIndex: number;
+    protected currentAnimationTime: number;
+    constructor(options?: ZylemSpriteOptions);
+    protected createSpritesFromImages(images: SpriteImage[]): void;
+    protected createAnimations(animations: SpriteAnimation[]): void;
+    setSprite(key: string): void;
+    setAnimation(name: string, delta: number): void;
+    spriteUpdate(params: UpdateContext<ZylemSpriteOptions>): Promise<void>;
+    spriteDestroy(params: DestroyContext<ZylemSpriteOptions>): Promise<void>;
+}
+type SpriteOptions = BaseNode | Partial<ZylemSpriteOptions>;
+export declare function sprite(...args: Array<SpriteOptions>): Promise<ZylemSprite>;
+export {};

package/dist/lib/entities/text.d.ts

@@ -0,0 +1,41 @@
+import { Color, Vector2 } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+type ZylemTextOptions = GameEntityOptions & {
+    text?: string;
+    fontFamily?: string;
+    fontSize?: number;
+    fontColor?: Color | string;
+    backgroundColor?: Color | string | null;
+    padding?: number;
+    stickToViewport?: boolean;
+    screenPosition?: Vector2;
+    zDistance?: number;
+};
+export declare class TextBuilder extends EntityBuilder<ZylemText, ZylemTextOptions> {
+    protected createEntity(options: Partial<ZylemTextOptions>): ZylemText;
+}
+export declare const TEXT_TYPE: unique symbol;
+export declare class ZylemText extends GameEntity<ZylemTextOptions> {
+    static type: symbol;
+    private _sprite;
+    private _texture;
+    private _canvas;
+    private _ctx;
+    private _cameraRef;
+    private _lastCanvasW;
+    private _lastCanvasH;
+    constructor(options?: ZylemTextOptions);
+    private createSprite;
+    private redrawText;
+    private toCssColor;
+    private textSetup;
+    private textUpdate;
+    private updateStickyTransform;
+    updateText(_text: string): void;
+    buildInfo(): Record<string, any>;
+}
+type TextOptions = BaseNode | Partial<ZylemTextOptions>;
+export declare function text(...args: Array<TextOptions>): Promise<ZylemText>;
+export {};