dacha 0.16.1 → 0.17.1

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/components/sprite/index.d.ts

@@ -13,7 +13,6 @@ export interface SpriteConfig {
     width: number;
     height: number;
     slice: number;
-    rotation: number;
     flipX: boolean;
     flipY: boolean;
     sortingLayer: string;
@@ -38,7 +37,6 @@ export interface SpriteConfig {
  *   width: 64,
  *   height: 64,
  *   slice: 0,
- *   rotation: 0,
  *   flipX: false,
  *   flipY: false,
  *   sortingLayer: 'units',
@@ -69,8 +67,6 @@ export declare class Sprite extends Component {
     height: number;
     /** Amount of frames in the sprite sheet */
     slice: number;
-    /** Rotation of the sprite in degrees */
-    rotation: number;
     /** Whether to flip the sprite horizontally */
     flipX: boolean;
     /** Whether to flip the sprite vertically */

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

@@ -13,7 +13,6 @@ import { Component } from '../../../engine/component';
  *   width: 64,
  *   height: 64,
  *   slice: 0,
- *   rotation: 0,
  *   flipX: false,
  *   flipY: false,
  *   sortingLayer: 'units',
@@ -44,8 +43,6 @@ export class Sprite extends Component {
     height;
     /** Amount of frames in the sprite sheet */
     slice;
-    /** Rotation of the sprite in degrees */
-    rotation;
     /** Whether to flip the sprite horizontally */
     flipX;
     /** Whether to flip the sprite vertically */
@@ -80,7 +77,6 @@ export class Sprite extends Component {
         this.height = config.height;
         this.slice = config.slice;
         this.currentFrame = 0;
-        this.rotation = config.rotation;
         this.flipX = config.flipX;
         this.flipY = config.flipY;
         this.disabled = config.disabled;
@@ -97,7 +93,6 @@ export class Sprite extends Component {
             width: this.width,
             height: this.height,
             slice: this.slice,
-            rotation: this.rotation,
             flipX: this.flipX,
             flipY: this.flipY,
             disabled: this.disabled,

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

@@ -1,4 +1,7 @@
 import { Component } from '../../../engine/component';
+import { Matrix } from '../../../engine/math-lib';
+import { LocalTransform } from './local-transform';
+import { WorldTransform } from './world-transform';
 export interface TransformConfig {
     offsetX: number;
     offsetY: number;
@@ -7,11 +10,11 @@ export interface TransformConfig {
     scaleY: number;
 }
 /**
- * Transform component that handles position, rotation, and scale of an actor.
+ * Component responsible for handling local and world-space transforms.
  *
- * Component provides hierarchical transformation support, meaning
- * child actors inherit transformations from their parents. All values are
- * stored as relative to the parent, but accessed as world coordinates.
+ * A Transform manages position, rotation, and scale, and computes
+ * corresponding transformation matrices. It supports hierarchical
+ * parent-child relationships via world matrix composition.
  *
  * @example
  * ```typescript
@@ -28,90 +31,69 @@ export interface TransformConfig {
  * actor.setComponent(transform);
  *
  * // Access world coordinates
- * console.log(`Position: ${transform.offsetX}, ${transform.offsetY}`);
- * console.log(`Rotation: ${transform.rotation}`);
- * console.log(`Scale: ${transform.scaleX}, ${transform.scaleY}`);
+ * console.log(`Position: ${transform.world.position.x}, ${transform.world.position.y}`);
+ * console.log(`Rotation (in radians): ${transform.world.rotation}`);
+ * console.log(`Scale: ${transform.world.scale.x}, ${transform.world.scale.y}`);
  * ```
  *
  * @category Components
  */
 export declare class Transform extends Component {
     /**
-     * Relative X position of the actor.
+     * Local-space transform values (position, rotation, scale).
+     * These values are relative to the parent transform.
      */
-    relativeOffsetX: number;
+    local: LocalTransform;
     /**
-     * Relative offset Y position of the actor.
+     * World-space transform values derived from the local transform
+     * and the parent hierarchy.
      */
-    relativeOffsetY: number;
+    world: WorldTransform;
     /**
-     * Relative rotation of the actor.
+     * Matrix representing the local-space transformation.
      */
-    relativeRotation: number;
+    localMatrix: Matrix;
     /**
-     * Relative scale X factor of the actor.
+     * Matrix representing the world-space transformation.
      */
-    relativeScaleX: number;
-    /**
-     * Relative scale Y factor of the actor.
-     */
-    relativeScaleY: number;
+    worldMatrix: Matrix;
+    private _invertedWorldMatrix;
+    private dirty;
+    private invertedDirty;
     /**
      * Creates a new Transform component.
      *
-     * @param config - Configuration for the transform
+     * @param config - Initial configuration for position, rotation, and scale.
      */
     constructor(config: TransformConfig);
-    _getPropertyFromParent(name: string, defaultValue: number): number;
-    /**
-     * Sets the world X position of the actor.
-     * @param offsetX - World X position
-     */
-    set offsetX(offsetX: number);
-    /**
-     * Gets the world X position of the actor.
-     * @returns World X position
-     */
-    get offsetX(): number;
-    /**
-     * Sets the world Y position of the actor.
-     * @param offsetY - World Y position
-     */
-    set offsetY(offsetY: number);
     /**
-     * Gets the world Y position of the actor.
-     * @returns World Y position
-     */
-    get offsetY(): number;
-    /**
-     * Sets the world rotation of the actor in degrees.
-     * @param rotation - World rotation in degrees
-     */
-    set rotation(rotation: number);
-    /**
-     * Gets the world rotation of the actor in degrees.
-     * @returns World rotation in degrees
+     * Returns the parent Transform component, if one exists.
+     *
+     * @returns The parent Transform or `undefined` if this transform has no parent.
      */
-    get rotation(): number;
+    getParentComponent(): Transform | undefined;
     /**
-     * Sets the X scale factor of the actor.
-     * @param scaleX - X scale factor
+     * Marks this transform and all descendant transforms as dirty.
+     *
+     * This signals that their matrices must be recalculated before use.
      */
-    set scaleX(scaleX: number);
+    markDirty(): void;
     /**
-     * Gets the X scale factor of the actor.
-     * @returns X scale factor
+     * Recomputes the local transformation matrix from local position,
+     * rotation, and scale.
      */
-    get scaleX(): number;
+    updateLocalMatrix(): void;
     /**
-     * Sets the Y scale factor of the actor.
-     * @param scaleY - Y scale factor
+     * Recomputes the world transformation matrix if the transform is dirty.
+     *
+     * This method ensures parent transforms are updated first and then
+     * composes the local matrix with the parent world matrix.
      */
-    set scaleY(scaleY: number);
+    updateWorldMatrix(): void;
     /**
-     * Gets the Y scale factor of the actor.
-     * @returns Y scale factor
+     * Inverse of the world transformation matrix.
+     * Useful for converting world-space coordinates to local space.
      */
-    get scaleY(): number;
+    get invertedWorldMatrix(): Matrix;
     clone(): Transform;
 }