dacha 0.17.2 → 0.18.0-alpha.1

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.js

@@ -1,36 +1,12 @@
-import { Vector2 } from '../../../../../engine/math-lib';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { Collision } from '../../../../events';
 import { RIGID_BODY_TYPE } from '../../consts';
+const SOLVER_ITERATIONS = 8;
+const POSITION_CORRECTION_PERCENT = 0.8;
+const PENETRATION_SLOP = 0.01;
+const DEFAULT_CONTACT_FRICTION = 0.6;
 export class ConstraintSolver {
-    scene;
-    processedPairs;
-    mtvMap;
-    constructor(options) {
-        this.scene = options.scene;
-        this.processedPairs = new Map();
-        this.mtvMap = new Map();
-        this.scene.addEventListener(Collision, this.handleCollision);
-    }
-    destroy() {
-        this.scene.removeEventListener(Collision, this.handleCollision);
-    }
-    handleCollision = (event) => {
-        const { actor1, actor2, mtv1, mtv2 } = event;
-        if (this.processedPairs.has(actor2) &&
-            this.processedPairs.get(actor2).has(actor1)) {
-            return;
-        }
-        if (!this.processedPairs.has(actor1)) {
-            this.processedPairs.set(actor1, new Set());
-        }
-        this.processedPairs.get(actor1).add(actor2);
-        if (!this.validateCollision(actor1, actor2)) {
-            return;
-        }
-        this.resolveCollision(actor1, actor2, mtv1, mtv2);
-    };
+    validContacts = [];
     validateCollision(actor1, actor2) {
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
@@ -41,68 +17,130 @@ export class ConstraintSolver {
             rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
             return false;
         }
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC ||
-            rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            return !rigidBody1.ghost && !rigidBody2.ghost;
+        return true;
+    }
+    getInverseMass(rigidBody) {
+        if (rigidBody.disabled || rigidBody.type === RIGID_BODY_TYPE.STATIC) {
+            return 0;
+        }
+        return rigidBody.inverseMass;
+    }
+    applyNormalImpulse(contact) {
+        const { actor1, actor2, normal } = contact;
+        const rigidBody1 = actor1.getComponent(RigidBody);
+        const rigidBody2 = actor2.getComponent(RigidBody);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return 0;
+        }
+        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
+        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
+        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
+        if (velocityAlongNormal >= 0) {
+            return 0;
+        }
+        const impulseMagnitude = -velocityAlongNormal / inverseMassSum;
+        const impulseX = normal.x * impulseMagnitude;
+        const impulseY = normal.y * impulseMagnitude;
+        if (inverseMass1 > 0) {
+            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
+            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
         }
-        return (!rigidBody1.ghost &&
-            !rigidBody1.isPermeable &&
-            !rigidBody2.ghost &&
-            !rigidBody2.isPermeable);
+        if (inverseMass2 > 0) {
+            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
+            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
+        }
+        return impulseMagnitude;
     }
-    setMtv(actor, mtvX, mtvY, type) {
-        if (!this.mtvMap.has(actor)) {
-            this.mtvMap.set(actor, {});
+    applyFrictionImpulse(contact, normalImpulseMagnitude) {
+        if (normalImpulseMagnitude <= 0) {
+            return;
+        }
+        const { normal } = contact;
+        const rigidBody1 = contact.actor1.getComponent(RigidBody);
+        const rigidBody2 = contact.actor2.getComponent(RigidBody);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return;
         }
-        const mtvs = this.mtvMap.get(actor);
-        if (!mtvs?.[type]) {
-            mtvs[type] = new Vector2(mtvX, mtvY);
+        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
+        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
+        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
+        const tangentX = relativeVelocityX - normal.x * velocityAlongNormal;
+        const tangentY = relativeVelocityY - normal.y * velocityAlongNormal;
+        const tangentMagnitude = Math.sqrt(tangentX ** 2 + tangentY ** 2);
+        if (tangentMagnitude === 0) {
             return;
         }
-        switch (type) {
-            case 'static':
-                mtvs[type].x =
-                    Math.abs(mtvX) > Math.abs(mtvs[type].x) ? mtvX : mtvs[type].x;
-                mtvs[type].y =
-                    Math.abs(mtvY) > Math.abs(mtvs[type].y) ? mtvY : mtvs[type].y;
-                break;
-            case 'dynamic':
-                mtvs[type].x += mtvX;
-                mtvs[type].y += mtvY;
+        const normalizedTangentX = tangentX / tangentMagnitude;
+        const normalizedTangentY = tangentY / tangentMagnitude;
+        const velocityAlongTangent = relativeVelocityX * normalizedTangentX +
+            relativeVelocityY * normalizedTangentY;
+        const unclampedImpulseMagnitude = -velocityAlongTangent / inverseMassSum;
+        const maxFrictionImpulseMagnitude = DEFAULT_CONTACT_FRICTION * normalImpulseMagnitude;
+        const impulseMagnitude = Math.max(-maxFrictionImpulseMagnitude, Math.min(unclampedImpulseMagnitude, maxFrictionImpulseMagnitude));
+        const impulseX = normalizedTangentX * impulseMagnitude;
+        const impulseY = normalizedTangentY * impulseMagnitude;
+        if (inverseMass1 > 0) {
+            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
+            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
+        }
+        if (inverseMass2 > 0) {
+            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
+            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
         }
     }
-    resolveCollision(actor1, actor2, mtv1, mtv2) {
+    applyPositionCorrection(contact) {
+        const { actor1, actor2, normal, penetration } = contact;
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(actor2, mtv2.x, mtv2.y, rigidBody1.type);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return;
         }
-        else if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(actor1, mtv1.x, mtv1.y, rigidBody2.type);
+        const correctionMagnitude = (Math.max(penetration - PENETRATION_SLOP, 0) *
+            POSITION_CORRECTION_PERCENT) /
+            inverseMassSum;
+        if (correctionMagnitude === 0) {
+            return;
+        }
+        const correctionX = normal.x * correctionMagnitude;
+        const correctionY = normal.y * correctionMagnitude;
+        const transform1 = actor1.getComponent(Transform);
+        const transform2 = actor2.getComponent(Transform);
+        if (inverseMass1 > 0) {
+            transform1.world.position.x -= correctionX * inverseMass1;
+            transform1.world.position.y -= correctionY * inverseMass1;
         }
-        else {
-            this.setMtv(actor1, mtv1.x / 2, mtv1.y / 2, rigidBody2.type);
-            this.setMtv(actor2, mtv2.x / 2, mtv2.y / 2, rigidBody1.type);
+        if (inverseMass2 > 0) {
+            transform2.world.position.x += correctionX * inverseMass2;
+            transform2.world.position.y += correctionY * inverseMass2;
         }
     }
-    update() {
-        for (const [actor, entry] of this.mtvMap) {
-            const transform = actor.getComponent(Transform);
-            const { static: staticMtv, dynamic: dynamicMtv } = entry;
-            /*
-             * TODO:: Enable this part when it will be possible to run
-             * phycics pipeline several times per single game loop iteration
-             */
-            // transform.world.position.x += Math.sign(staticMtv.x) === Math.sign(dynamicMtv.x)
-            //   ? staticMtv.x + dynamicMtv.x
-            //   : staticMtv.x || dynamicMtv.x;
-            // transform.world.position.y += Math.sign(staticMtv.y) === Math.sign(dynamicMtv.y)
-            //   ? staticMtv.y + dynamicMtv.y
-            //   : staticMtv.y || dynamicMtv.y;
-            transform.world.position.x += (staticMtv?.x ?? 0) + (dynamicMtv?.x ?? 0);
-            transform.world.position.y += (staticMtv?.y ?? 0) + (dynamicMtv?.y ?? 0);
-        }
-        this.processedPairs.clear();
-        this.mtvMap.clear();
+    update(contacts) {
+        let validContactsCount = 0;
+        contacts.forEach((contact) => {
+            if (!this.validateCollision(contact.actor1, contact.actor2)) {
+                return;
+            }
+            this.validContacts[validContactsCount] = contact;
+            validContactsCount += 1;
+        });
+        this.validContacts.length = validContactsCount;
+        for (let iteration = 0; iteration < SOLVER_ITERATIONS; iteration += 1) {
+            this.validContacts.forEach((contact) => {
+                const normalImpulseMagnitude = this.applyNormalImpulse(contact);
+                this.applyFrictionImpulse(contact, normalImpulseMagnitude);
+            });
+        }
+        this.validContacts.forEach((contact) => {
+            this.applyPositionCorrection(contact);
+        });
     }
 }

package/build/contrib/systems/physics-system/subsystems/index.d.ts

@@ -1,5 +1,4 @@
 export { PhysicsSubsystem } from './physics';
 export { CollisionDetectionSubsystem } from './collision-detection';
 export { CollisionBroadcastSubsystem } from './collision-broadcast';
-export { CollisionSolver } from './collision-solver';
 export { ConstraintSolver } from './constraint-solver';

package/build/contrib/systems/physics-system/subsystems/index.js

@@ -1,5 +1,4 @@
 export { PhysicsSubsystem } from './physics';
 export { CollisionDetectionSubsystem } from './collision-detection';
 export { CollisionBroadcastSubsystem } from './collision-broadcast';
-export { CollisionSolver } from './collision-solver';
 export { ConstraintSolver } from './constraint-solver';

package/build/contrib/systems/physics-system/subsystems/physics/index.d.ts

@@ -1,17 +1,11 @@
 import type { SceneSystemOptions, UpdateOptions } from '../../../../../engine/system';
 export declare class PhysicsSubsystem {
-    private scene;
     private actorQuery;
     private gravity;
-    private actorVectors;
     constructor(options: SceneSystemOptions);
     destroy(): void;
-    private handleActorRemove;
-    private handleStopMovement;
-    private handleAddForce;
-    private handleAddImpulse;
-    private setUpVectors;
-    private applyDragForce;
-    private getGravityForce;
+    private applyLinearDamping;
+    private integrateVelocities;
+    private integratePositions;
     update(options: UpdateOptions): void;
 }

package/build/contrib/systems/physics-system/subsystems/physics/index.js

@@ -1,125 +1,89 @@
-import { Vector2 } from '../../../../../engine/math-lib';
 import { ActorQuery } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { AddForce, AddImpulse, StopMovement } from '../../../../events';
-import { RemoveActor } from '../../../../../engine/events';
-const DIRECTION_VECTOR = {
-    UP: new Vector2(0, -1),
-    LEFT: new Vector2(-1, 0),
-    RIGHT: new Vector2(1, 0),
-    DOWN: new Vector2(0, 1),
-};
 export class PhysicsSubsystem {
-    scene;
     actorQuery;
     gravity;
-    actorVectors;
     constructor(options) {
         const { gravity, scene } = options;
-        this.scene = scene;
         this.actorQuery = new ActorQuery({ scene, filter: [RigidBody, Transform] });
         this.gravity = gravity;
-        this.actorVectors = {};
-        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.addEventListener(StopMovement, this.handleStopMovement);
-        this.scene.addEventListener(AddForce, this.handleAddForce);
-        this.scene.addEventListener(AddImpulse, this.handleAddImpulse);
     }
     destroy() {
-        this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.removeEventListener(StopMovement, this.handleStopMovement);
-        this.scene.removeEventListener(AddForce, this.handleAddForce);
-        this.scene.removeEventListener(AddImpulse, this.handleAddImpulse);
+        this.actorQuery.destroy();
     }
-    handleActorRemove = (event) => {
-        const { actor } = event;
-        delete this.actorVectors[actor.id];
-    };
-    handleStopMovement = (event) => {
-        const { target } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].velocity.multiplyNumber(0);
-    };
-    handleAddForce = (event) => {
-        const { target, value } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].force.add(value);
-    };
-    handleAddImpulse = (event) => {
-        const { target, value } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].impulse.add(value);
-    };
-    setUpVectors(actor) {
-        this.actorVectors[actor.id] = {
-            velocity: new Vector2(0, 0),
-            force: new Vector2(0, 0),
-            impulse: new Vector2(0, 0),
-        };
-    }
-    applyDragForce(actor, deltaTime) {
-        const { mass, drag } = actor.getComponent(RigidBody);
-        const velocity = this.actorVectors[actor.id]?.velocity;
-        if (!drag || !velocity || (!velocity.x && !velocity.y)) {
+    applyLinearDamping(rigidBody, deltaTime) {
+        const { mass, linearDamping, linearVelocity } = rigidBody;
+        if (!linearDamping || (!linearVelocity.x && !linearVelocity.y)) {
             return;
         }
-        const velocitySignX = Math.sign(velocity.x);
-        const velocitySignY = Math.sign(velocity.y);
+        const velocitySignX = Math.sign(linearVelocity.x);
+        const velocitySignY = Math.sign(linearVelocity.y);
         const reactionForceValue = mass * this.gravity;
-        const dragForceValue = -1 * drag * reactionForceValue;
+        const dragForceValue = -1 * linearDamping * reactionForceValue;
         const forceToVelocityMultiplier = deltaTime / mass;
         const slowdownValue = dragForceValue * forceToVelocityMultiplier;
-        const normalizationMultiplier = 1 / velocity.magnitude;
-        const slowdown = velocity.clone();
-        slowdown.multiplyNumber(slowdownValue * normalizationMultiplier);
-        velocity.add(slowdown);
-        if (Math.sign(velocity.x) !== velocitySignX &&
-            Math.sign(velocity.y) !== velocitySignY) {
-            velocity.multiplyNumber(0);
+        const normalizationMultiplier = 1 / linearVelocity.magnitude;
+        const slowdownMultiplier = slowdownValue * normalizationMultiplier;
+        linearVelocity.x += linearVelocity.x * slowdownMultiplier;
+        linearVelocity.y += linearVelocity.y * slowdownMultiplier;
+        if (Math.sign(linearVelocity.x) !== velocitySignX &&
+            Math.sign(linearVelocity.y) !== velocitySignY) {
+            linearVelocity.multiplyNumber(0);
         }
     }
-    getGravityForce(rigidBody) {
-        const { mass, useGravity } = rigidBody;
-        const gravityVector = new Vector2(0, 0);
-        if (useGravity) {
-            gravityVector.add(DIRECTION_VECTOR.DOWN);
-            gravityVector.multiplyNumber(mass * this.gravity);
-        }
-        return gravityVector;
-    }
-    update(options) {
-        const { deltaTime } = options;
-        const deltaTimeInMsec = deltaTime;
-        const deltaTimeInSeconds = deltaTimeInMsec / 1000;
+    integrateVelocities(deltaTimeInSeconds) {
         this.actorQuery.getActors().forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);
-            const transform = actor.getComponent(Transform);
-            const { mass } = rigidBody;
-            if (!this.actorVectors[actor.id]) {
-                this.setUpVectors(actor);
+            const { mass, inverseMass } = rigidBody;
+            if (rigidBody.disabled || rigidBody.type === 'static' || mass <= 0) {
+                rigidBody.clearForces();
+                return;
+            }
+            const { force, impulse } = rigidBody;
+            const velocity = rigidBody.linearVelocity;
+            if (rigidBody.sleeping) {
+                if (force.x || force.y || impulse.x || impulse.y) {
+                    rigidBody.wakeUp();
+                }
+                else {
+                    return;
+                }
+            }
+            if (rigidBody.gravityScale) {
+                force.y += mass * this.gravity * rigidBody.gravityScale;
             }
-            const { velocity, force, impulse } = this.actorVectors[actor.id];
-            force.add(this.getGravityForce(rigidBody));
             if (force.x || force.y) {
-                force.multiplyNumber(deltaTimeInSeconds / mass);
+                force.multiplyNumber(deltaTimeInSeconds * inverseMass);
                 velocity.add(force);
             }
             if (impulse.x || impulse.y) {
-                impulse.multiplyNumber(1 / mass);
+                impulse.multiplyNumber(inverseMass);
                 velocity.add(impulse);
             }
-            this.applyDragForce(actor, deltaTimeInSeconds);
-            transform.world.position.x += velocity.x * deltaTimeInSeconds;
-            transform.world.position.y += velocity.y * deltaTimeInSeconds;
-            force.multiplyNumber(0);
-            impulse.multiplyNumber(0);
+            this.applyLinearDamping(rigidBody, deltaTimeInSeconds);
+            rigidBody.clearForces();
         });
     }
+    integratePositions(deltaTimeInSeconds) {
+        this.actorQuery.getActors().forEach((actor) => {
+            const rigidBody = actor.getComponent(RigidBody);
+            const transform = actor.getComponent(Transform);
+            if (rigidBody.disabled ||
+                rigidBody.type === 'static' ||
+                rigidBody.mass <= 0 ||
+                rigidBody.sleeping) {
+                return;
+            }
+            transform.world.position.x +=
+                rigidBody.linearVelocity.x * deltaTimeInSeconds;
+            transform.world.position.y +=
+                rigidBody.linearVelocity.y * deltaTimeInSeconds;
+        });
+    }
+    update(options) {
+        const deltaTimeInSeconds = options.deltaTime / 1000;
+        this.integrateVelocities(deltaTimeInSeconds);
+        this.integratePositions(deltaTimeInSeconds);
+    }
 }

package/build/contrib/systems/physics-system/types.d.ts

@@ -1,4 +1,41 @@
 import type { SceneSystemOptions } from '../../../engine/system';
+import type { Actor } from '../../../engine/actor';
+import type { Vector2, Point } from '../../../engine/math-lib';
 export interface PhysicsSystemOptions extends SceneSystemOptions {
     gravity: number;
 }
+export interface CollisionLayer {
+    id: string;
+    name: string;
+}
+export type CollisionMatrix = Record<string, Record<string, boolean>>;
+export interface PhysicsSettings {
+    collisionLayers: CollisionLayer[];
+    collisionMatrix: CollisionMatrix;
+}
+export interface PhysicsQueryFilter {
+    layer?: string;
+}
+export interface RaycastParams extends PhysicsQueryFilter {
+    origin: Point;
+    direction: Vector2;
+    maxDistance: number;
+}
+export interface RaycastHit {
+    actor: Actor;
+    point: Point;
+    normal: Vector2;
+    distance: number;
+}
+export interface OverlapPointParams extends PhysicsQueryFilter {
+    point: Point;
+}
+export interface OverlapCircleParams extends PhysicsQueryFilter {
+    center: Point;
+    radius: number;
+}
+export interface OverlapBoxParams extends PhysicsQueryFilter {
+    center: Point;
+    size: Point;
+    rotation?: number;
+}

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

@@ -108,8 +108,6 @@ export class ActorRenderTree {
                 container.addChild(view);
             }
         });
-        this.updateParent(container, actor);
-        this.updatePosition(container, actor);
         return container;
     }
     delete(actor) {
@@ -178,6 +176,7 @@ export class ActorRenderTree {
                 renderLayer?.attach(view);
                 meta.sortingLayer = sortingLayer;
             }
+            view.__dacha.isReady = true;
         });
     }
     update() {

package/build/contrib/systems/renderer/{service → api}/index.d.ts

@@ -6,7 +6,7 @@ import type { FilterSystem } from '../filters';
 import type { FilterEffectConfig } from '../filters/filter-effect';
 import type { MaterialSystem } from '../material';
 import type { ShaderConstructor } from '../material/shader';
-interface RendererServiceOptions {
+interface RendererAPIOptions {
     application: Application;
     worldContainer: Container;
     getViewEntries: () => Set<ViewContainer> | undefined;
@@ -15,21 +15,21 @@ interface RendererServiceOptions {
     materialSystem: MaterialSystem;
 }
 /**
- * Service that provides rendering utilities and view management
+ * API that provides rendering utilities and view management
  *
  * Offers methods for view intersection testing, bounds calculation, and
  * direct access to the underlying PIXI.js application
  *
  * @category Systems
  */
-export declare class RendererService {
+export declare class RendererAPI {
     private application;
     private worldContainer;
     private getViewEntries;
     private sortFn;
     private filterSystem;
     private materialSystem;
-    constructor({ application, worldContainer, getViewEntries, sortFn, filterSystem, materialSystem, }: RendererServiceOptions);
+    constructor({ application, worldContainer, getViewEntries, sortFn, filterSystem, materialSystem, }: RendererAPIOptions);
     /**
      * Returns the underlying PIXI.js application
      *
@@ -61,9 +61,9 @@ export declare class RendererService {
      * the bounds will be the smallest rectangle that contains all views
      *
      * @param actor - Actor to get the bounds of
-     * @returns Bounds of the actor
+     * @returns Bounds of the actor or null if the actor has no available views
      */
-    getBounds(actor: Actor): Bounds;
+    getBounds(actor: Actor): Bounds | null;
     /**
      * Adds a post-processing effect that applies to the entire scene.
      * Effects are applied in the order they are added.

package/build/contrib/systems/renderer/{service → api}/index.js

@@ -1,15 +1,14 @@
-import { Transform } from '../../../components/transform';
 import { VIEW_COMPONENTS } from '../consts';
-import { convertBounds } from './utils';
+import { convertBounds, getWorldPosition } from './utils';
 /**
- * Service that provides rendering utilities and view management
+ * API that provides rendering utilities and view management
  *
  * Offers methods for view intersection testing, bounds calculation, and
  * direct access to the underlying PIXI.js application
  *
  * @category Systems
  */
-export class RendererService {
+export class RendererAPI {
     application;
     worldContainer;
     getViewEntries;
@@ -43,6 +42,9 @@ export class RendererService {
         const intersects = new Set();
         const inverseMatrix = this.worldContainer.worldTransform.clone().invert();
         this.getViewEntries()?.forEach((entry) => {
+            if (!entry.__dacha.isReady) {
+                return;
+            }
             const { minX, minY, maxX, maxY } = convertBounds(entry, inverseMatrix);
             if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
                 intersects.add(entry);
@@ -67,8 +69,12 @@ export class RendererService {
      */
     intersectsWithRectangle(minX, minY, maxX, maxY) {
         const actors = new Set();
+        const inverseMatrix = this.worldContainer.worldTransform.clone().invert();
         this.getViewEntries()?.forEach((entry) => {
-            const { x, y } = entry.position;
+            if (!entry.__dacha.isReady) {
+                return;
+            }
+            const { x, y } = getWorldPosition(entry, inverseMatrix);
             if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
                 actors.add(entry.__dacha.actor);
             }
@@ -81,10 +87,9 @@ export class RendererService {
      * the bounds will be the smallest rectangle that contains all views
      *
      * @param actor - Actor to get the bounds of
-     * @returns Bounds of the actor
+     * @returns Bounds of the actor or null if the actor has no available views
      */
     getBounds(actor) {
-        const { world } = actor.getComponent(Transform);
         let minX = Infinity;
         let minY = Infinity;
         let maxX = -Infinity;
@@ -92,7 +97,7 @@ export class RendererService {
         const inverseMatrix = this.worldContainer.worldTransform.clone().invert();
         VIEW_COMPONENTS.forEach((ViewComponent) => {
             const viewComponent = actor.getComponent(ViewComponent);
-            if (!viewComponent?.renderData?.view) {
+            if (!viewComponent?.renderData?.view?.__dacha.isReady) {
                 return;
             }
             const bounds = convertBounds(viewComponent.renderData.view, inverseMatrix);
@@ -102,14 +107,7 @@ export class RendererService {
             maxY = Math.max(maxY, bounds?.maxY);
         });
         if (minX === Infinity) {
-            return {
-                minX: world.position.x,
-                minY: world.position.y,
-                maxX: world.position.x,
-                maxY: world.position.y,
-                width: 0,
-                height: 0,
-            };
+            return null;
         }
         return {
             minX,

package/build/contrib/systems/renderer/api/utils.d.ts

@@ -0,0 +1,4 @@
+import { type Container, Point, type Matrix } from 'pixi.js';
+import { type Bounds } from '../types';
+export declare const convertBounds: (container: Container, matrix: Matrix) => Bounds;
+export declare const getWorldPosition: (container: Container, matrix: Matrix) => Point;

package/build/contrib/systems/renderer/{service → api}/utils.js

@@ -12,3 +12,8 @@ export const convertBounds = (container, matrix) => {
         height: bottomRight.y - topLeft.y,
     };
 };
+export const getWorldPosition = (container, matrix) => {
+    const worldPoint = new Point();
+    container.getGlobalPosition(worldPoint, true);
+    return matrix.apply(worldPoint);
+};