dacha 0.18.1 → 0.18.3

package/build/contrib/components/rigid-body/index.d.ts

@@ -8,7 +8,6 @@ export interface RigidBodyConfig {
     linearDamping?: number;
     angularDamping?: number;
     lockRotation?: boolean;
-    autoSleep?: boolean;
     restitution?: number;
     friction?: number;
     disabled: boolean;
@@ -75,8 +74,6 @@ export declare class RigidBody extends Component {
     _biasLinearVelocity: Vector2;
     /** @internal Temporary solver angular velocity used for contact separation */
     _biasAngularVelocity: number;
-    /** @internal Time this body has stayed below automatic sleep thresholds */
-    _sleepTime: number;
     /** Body type that defines how the rigid body participates in simulation */
     readonly type: RigidBodyType;
     /** Gravity multiplier. `0` ignores gravity, `1` uses normal world gravity. */
@@ -93,10 +90,6 @@ export declare class RigidBody extends Component {
     lockRotation: boolean;
     /** Whether rigid body simulation is disabled */
     disabled: boolean;
-    /** Whether rigid body is sleeping */
-    sleeping: boolean;
-    /** Whether this body may be put to sleep automatically when settled */
-    autoSleep: boolean;
     /** @internal Force applied at the rigid body center */
     _centralForce: Vector2;
     /** @internal Impulse applied at the rigid body center */
@@ -185,14 +178,6 @@ export declare class RigidBody extends Component {
      * bodies with unlocked rotation.
      */
     applyAngularImpulse(impulse: number): void;
-    /**
-     * Marks the rigid body as awake so it can be simulated.
-     */
-    wakeUp(): void;
-    /**
-     * Marks the rigid body as sleeping so dynamic integration can skip it.
-     */
-    sleep(): void;
     /**
      * Clears all accumulated force and impulse values.
      */

package/build/contrib/components/rigid-body/index.js

@@ -51,8 +51,6 @@ export class RigidBody extends Component {
     _biasLinearVelocity;
     /** @internal Temporary solver angular velocity used for contact separation */
     _biasAngularVelocity;
-    /** @internal Time this body has stayed below automatic sleep thresholds */
-    _sleepTime;
     /** Body type that defines how the rigid body participates in simulation */
     type;
     /** Gravity multiplier. `0` ignores gravity, `1` uses normal world gravity. */
@@ -69,10 +67,6 @@ export class RigidBody extends Component {
     lockRotation;
     /** Whether rigid body simulation is disabled */
     disabled;
-    /** Whether rigid body is sleeping */
-    sleeping;
-    /** Whether this body may be put to sleep automatically when settled */
-    autoSleep;
     /** @internal Force applied at the rigid body center */
     _centralForce;
     /** @internal Impulse applied at the rigid body center */
@@ -106,7 +100,6 @@ export class RigidBody extends Component {
         this._prevAngularVelocity = 0;
         this._biasLinearVelocity = new Vector2(0, 0);
         this._biasAngularVelocity = 0;
-        this._sleepTime = 0;
         this.type = config.type;
         this.mass = config.mass ?? (this.type === 'dynamic' ? 1 : 0);
         this.gravityScale =
@@ -116,11 +109,9 @@ export class RigidBody extends Component {
         this.restitution = config.restitution ?? 0;
         this.friction = config.friction ?? 0.6;
         this.lockRotation = config.lockRotation ?? false;
-        this.autoSleep = config.autoSleep ?? true;
         this.disabled = config.disabled;
         this.linearVelocity = new Vector2(0, 0);
         this.angularVelocity = 0;
-        this.sleeping = false;
         this._centralForce = new Vector2(0, 0);
         this._centralImpulse = new Vector2(0, 0);
         this._pointForces = [];
@@ -154,7 +145,7 @@ export class RigidBody extends Component {
      * Bodies with zero or negative mass return `0`.
      */
     get inverseMass() {
-        if (this.type === 'static' || this.type === 'kinematic' || this.sleeping) {
+        if (this.type === 'static' || this.type === 'kinematic') {
             return 0;
         }
         return this._inverseMass;
@@ -183,7 +174,6 @@ export class RigidBody extends Component {
     get inverseInertia() {
         if (this.type === 'static' ||
             this.type === 'kinematic' ||
-            this.sleeping ||
             this.lockRotation) {
             return 0;
         }
@@ -214,7 +204,6 @@ export class RigidBody extends Component {
         if (this.disabled || this.type !== 'dynamic') {
             return;
         }
-        this.wakeUp();
         if (!position) {
             this._centralForce.add(force);
             return;
@@ -235,7 +224,6 @@ export class RigidBody extends Component {
         if (this.disabled || this.type !== 'dynamic') {
             return;
         }
-        this.wakeUp();
         if (!position) {
             this._centralImpulse.add(impulse);
             return;
@@ -255,7 +243,6 @@ export class RigidBody extends Component {
         if (this.disabled || this.type !== 'dynamic' || this.lockRotation) {
             return;
         }
-        this.wakeUp();
         this._torque += torque;
     }
     /**
@@ -268,36 +255,8 @@ export class RigidBody extends Component {
         if (this.disabled || this.type !== 'dynamic' || this.lockRotation) {
             return;
         }
-        this.wakeUp();
         this._angularImpulse += impulse;
     }
-    /**
-     * Marks the rigid body as awake so it can be simulated.
-     */
-    wakeUp() {
-        if (this.disabled || this.type !== 'dynamic') {
-            return;
-        }
-        this.sleeping = false;
-        this._sleepTime = 0;
-    }
-    /**
-     * Marks the rigid body as sleeping so dynamic integration can skip it.
-     */
-    sleep() {
-        if (this.disabled || this.type !== 'dynamic') {
-            return;
-        }
-        this.sleeping = true;
-        this._sleepTime = 0;
-        this._prevLinearVelocity.multiplyNumber(0);
-        this._prevAngularVelocity = 0;
-        this.linearVelocity.multiplyNumber(0);
-        this.angularVelocity = 0;
-        this._biasLinearVelocity.multiplyNumber(0);
-        this._biasAngularVelocity = 0;
-        this.clearForces();
-    }
     /**
      * Clears all accumulated force and impulse values.
      */

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

@@ -1,13 +1,7 @@
 export declare const DEFAULT_SOLVER_ITERATIONS = 8;
-export declare const DEFAULT_LINEAR_SLEEP_THRESHOLD = 1;
-export declare const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
-export declare const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
 export declare const DEFAULT_MAX_BIAS_VELOCITY = 60;
 export declare const DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION = 0.5;
 export declare const CONTACT_BIAS = 0.2;
-export declare const BIAS_ANGULAR_SLEEP_MULTIPLIER = 2;
 export declare const RESTITUTION_VELOCITY_THRESHOLD = 1;
-export declare const PENETRATION_SLEEP_MARGIN = 0.25;
-export declare const SUPPORT_MIN_GRAVITY_DOT = 0.5;
 export declare const DEFAULT_GRAVITY_X = 0;
 export declare const DEFAULT_GRAVITY_Y = 980;

package/build/contrib/systems/physics-system/consts.js

@@ -1,17 +1,8 @@
 export const DEFAULT_SOLVER_ITERATIONS = 8;
-export const DEFAULT_LINEAR_SLEEP_THRESHOLD = 1;
-export const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
-export const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
 export const DEFAULT_MAX_BIAS_VELOCITY = 60;
 export const DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION = 0.5;
 export const CONTACT_BIAS = 0.2;
-export const BIAS_ANGULAR_SLEEP_MULTIPLIER = 2;
 export const RESTITUTION_VELOCITY_THRESHOLD = 1;
-// Kept above maxAllowedPenetration so a settled stack resting at the
-// allowed slop does not wake itself from its own steady-state penetration.
-export const PENETRATION_SLEEP_MARGIN = 0.25;
-// 0.5 treats surfaces up to ~60° from horizontal as holding a body up.
-export const SUPPORT_MIN_GRAVITY_DOT = 0.5;
 // Default gravity in world units (px/s²).
 export const DEFAULT_GRAVITY_X = 0;
 export const DEFAULT_GRAVITY_Y = 980;

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

@@ -22,16 +22,13 @@ export class PhysicsSystem extends SceneSystem {
     gravity;
     constructor(options) {
         super();
-        const { gravityX = DEFAULT_GRAVITY_X, gravityY = DEFAULT_GRAVITY_Y, solverIterations, linearSleepThreshold, angularSleepThreshold, sleepTimeThreshold, maxAllowedPenetration, maxBiasVelocity, } = options;
+        const { gravityX = DEFAULT_GRAVITY_X, gravityY = DEFAULT_GRAVITY_Y, solverIterations, maxAllowedPenetration, maxBiasVelocity, } = options;
         this.gravity = new Vector2(gravityX, gravityY);
         this.world = options.world;
         this.physicsSubsystem = new PhysicsSubsystem({
             scene: options.scene,
             time: options.time,
             getGravity: () => this.gravity,
-            linearSleepThreshold,
-            angularSleepThreshold,
-            sleepTimeThreshold,
         });
         this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
         this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
@@ -41,7 +38,6 @@ export class PhysicsSystem extends SceneSystem {
             solverIterations,
             maxAllowedPenetration,
             maxBiasVelocity,
-            linearSleepThreshold,
         });
         this.physicsApi = new PhysicsAPI({
             raycast: (params) => this.collisionDetectionSubsystem.raycast(params),
@@ -79,7 +75,6 @@ export class PhysicsSystem extends SceneSystem {
         const contacts = this.collisionDetectionSubsystem.update();
         this.constraintSolver.update(contacts);
         this.physicsSubsystem.integrateDynamicPositions();
-        this.physicsSubsystem.updateSleepTimers();
         this.collisionBroadcastSubsystem.update(contacts);
         this.physicsSubsystem.lateUpdate();
     }

package/build/contrib/systems/physics-system/subsystems/constraint-solver/contact-state-manager.js

@@ -52,8 +52,7 @@ export class ContactStateManager {
     pruneStaleStates() {
         let stateIndex = 0;
         for (const state of this.states) {
-            if (state.version === this.version ||
-                (state.bodyA.sleeping && state.bodyB.sleeping)) {
+            if (state.version === this.version) {
                 this.states[stateIndex] = state;
                 stateIndex += 1;
                 continue;

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

@@ -7,27 +7,22 @@ interface ConstraintSolverOptions {
     solverIterations?: number;
     maxAllowedPenetration?: number;
     maxBiasVelocity?: number;
-    linearSleepThreshold?: number;
 }
 export declare class ConstraintSolver {
     private oneWayValidator;
     private contactStateManager;
-    private sleepSupportTracker;
     private time;
     private getGravity;
     private restitutionThreshold;
     private solverIterations;
     private maxAllowedPenetration;
     private maxBiasVelocity;
-    private linearSleepThreshold;
-    private penetrationSleepThreshold;
     private flippedNormal;
     private blockImpulse0;
     private blockImpulse1;
     constructor(options: ConstraintSolverOptions);
     private validateCollision;
     private validateOneWayContact;
-    private validateSleepContact;
     private getPoint;
     private prepareContact;
     private prepareBlockSolver;

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

@@ -1,12 +1,10 @@
 import { MathOps, } from '../../../../../engine/math-lib';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { DEFAULT_SOLVER_ITERATIONS, DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION, CONTACT_BIAS, DEFAULT_MAX_BIAS_VELOCITY, RESTITUTION_VELOCITY_THRESHOLD, DEFAULT_LINEAR_SLEEP_THRESHOLD, PENETRATION_SLEEP_MARGIN, } from '../../consts';
+import { DEFAULT_SOLVER_ITERATIONS, DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION, CONTACT_BIAS, DEFAULT_MAX_BIAS_VELOCITY, RESTITUTION_VELOCITY_THRESHOLD, } from '../../consts';
 import { ContactStateManager, } from './contact-state-manager';
 import { OneWayValidator } from './one-way-validator';
 import { getContactFriction, getContactRestitution, getEffectiveMass, getNormalVelocity, getTangentVelocity, getPrevNormalVelocity, getBiasNormalVelocity, applyImpulse, applyBiasImpulse, } from './impulse-utils';
-import { shouldWakeSleepingContact } from './contact-utils';
-import { SleepSupportTracker } from './sleep-support-tracker';
 const BLOCK_SOLVER_MIN_DETERMINANT = 1e-8;
 const BLOCK_SOLVER_TOLERANCE = 1e-8;
 /**
@@ -21,22 +19,18 @@ const RESTITUTION_GRAVITY_THRESHOLD_FACTOR = 2;
 export class ConstraintSolver {
     oneWayValidator;
     contactStateManager;
-    sleepSupportTracker;
     time;
     getGravity;
     restitutionThreshold;
     solverIterations;
     maxAllowedPenetration;
     maxBiasVelocity;
-    linearSleepThreshold;
-    penetrationSleepThreshold;
     flippedNormal;
     blockImpulse0;
     blockImpulse1;
     constructor(options) {
         this.oneWayValidator = new OneWayValidator();
         this.contactStateManager = new ContactStateManager();
-        this.sleepSupportTracker = new SleepSupportTracker(options.getGravity);
         this.time = options.time;
         this.getGravity = options.getGravity;
         this.restitutionThreshold = RESTITUTION_VELOCITY_THRESHOLD;
@@ -45,10 +39,6 @@ export class ConstraintSolver {
         this.maxAllowedPenetration =
             options.maxAllowedPenetration ?? DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION;
         this.maxBiasVelocity = options.maxBiasVelocity ?? DEFAULT_MAX_BIAS_VELOCITY;
-        this.linearSleepThreshold =
-            options.linearSleepThreshold ?? DEFAULT_LINEAR_SLEEP_THRESHOLD;
-        this.penetrationSleepThreshold =
-            this.maxAllowedPenetration + PENETRATION_SLEEP_MARGIN;
         this.flippedNormal = { x: 0, y: 0 };
         this.blockImpulse0 = 0;
         this.blockImpulse1 = 0;
@@ -82,24 +72,6 @@ export class ConstraintSolver {
         this.flippedNormal.y = -contact.normal.y;
         return this.oneWayValidator.shouldBlock(contact.actor2, contact.actor1, this.flippedNormal);
     }
-    validateSleepContact(contact) {
-        const rigidBody1 = contact.actor1.getComponent(RigidBody);
-        const rigidBody2 = contact.actor2.getComponent(RigidBody);
-        const isDeepContact = contact.penetration > this.penetrationSleepThreshold;
-        const isFastContact = shouldWakeSleepingContact(contact, this.linearSleepThreshold);
-        if (!isDeepContact && !isFastContact) {
-            this.sleepSupportTracker.trackContact(contact);
-        }
-        if (rigidBody1.sleeping && rigidBody2.sleeping) {
-            return false;
-        }
-        if ((rigidBody1.sleeping || rigidBody2.sleeping) &&
-            (isDeepContact || isFastContact)) {
-            rigidBody1.wakeUp();
-            rigidBody2.wakeUp();
-        }
-        return true;
-    }
     getPoint(state, index) {
         return index === 0 ? state.point0 : state.point1;
     }
@@ -182,9 +154,7 @@ export class ConstraintSolver {
     prepareDecisions(state, minPrevNormalVelocity) {
         const hasRestitution = state.restitution > 0;
         const isBouncing = hasRestitution && -minPrevNormalVelocity > this.restitutionThreshold;
-        const eitherSleeping = state.bodyA.sleeping || state.bodyB.sleeping;
-        state.warmStartAllowed =
-            (!hasRestitution || !isBouncing) && !eitherSleeping;
+        state.warmStartAllowed = !hasRestitution || !isBouncing;
         state.skipBias =
             isBouncing && (state.invMassA === 0 || state.invMassB === 0);
     }
@@ -352,7 +322,6 @@ export class ConstraintSolver {
     update(contacts) {
         this.oneWayValidator.updateVersion();
         this.contactStateManager.updateVersion();
-        this.sleepSupportTracker.beginFrame();
         const deltaTime = this.time.fixedDeltaTime;
         this.restitutionThreshold = Math.max(RESTITUTION_VELOCITY_THRESHOLD, RESTITUTION_GRAVITY_THRESHOLD_FACTOR *
             this.getGravity().magnitude *
@@ -364,14 +333,10 @@ export class ConstraintSolver {
             if (!this.validateOneWayContact(contact)) {
                 return;
             }
-            if (!this.validateSleepContact(contact)) {
-                return;
-            }
             const state = this.contactStateManager.acquire(contact);
             this.prepareContact(state);
             this.applyWarmStartImpulse(state);
         });
-        this.sleepSupportTracker.wakeUnsupportedBodies();
         this.contactStateManager.pruneStaleStates();
         for (let iteration = 0; iteration < this.solverIterations; iteration += 1) {
             this.contactStateManager.forEach((state) => {
@@ -386,6 +351,5 @@ export class ConstraintSolver {
             });
         }
         this.oneWayValidator.clearOneWayContacts();
-        this.sleepSupportTracker.endFrame();
     }
 }

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

@@ -5,18 +5,11 @@ export interface PhysicsSubsystemOptions {
     scene: Scene;
     time: Time;
     getGravity: () => Vector2;
-    linearSleepThreshold?: number;
-    angularSleepThreshold?: number;
-    sleepTimeThreshold?: number;
 }
 export declare class PhysicsSubsystem {
     private actorQuery;
     private time;
     private getGravity;
-    private linearSleepThreshold;
-    private angularSleepThreshold;
-    private biasAngularSleepThreshold;
-    private sleepTimeThreshold;
     private kinematicMovedActors;
     constructor(options: PhysicsSubsystemOptions);
     destroy(): void;
@@ -25,6 +18,5 @@ export declare class PhysicsSubsystem {
     integrateVelocities(): void;
     integrateKinematicPositions(): void;
     integrateDynamicPositions(): void;
-    updateSleepTimers(): void;
     lateUpdate(): void;
 }

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

@@ -2,30 +2,17 @@ import { ActorQuery } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
 import { Collider } from '../../../../components/collider';
-import { DEFAULT_LINEAR_SLEEP_THRESHOLD, DEFAULT_ANGULAR_SLEEP_THRESHOLD, DEFAULT_SLEEP_TIME_THRESHOLD, BIAS_ANGULAR_SLEEP_MULTIPLIER, } from '../../consts';
 import { calculateInertia } from './mass-properties';
 export class PhysicsSubsystem {
     actorQuery;
     time;
     getGravity;
-    linearSleepThreshold;
-    angularSleepThreshold;
-    biasAngularSleepThreshold;
-    sleepTimeThreshold;
     kinematicMovedActors;
     constructor(options) {
         const { scene, time, getGravity } = options;
         this.actorQuery = new ActorQuery({ scene, filter: [RigidBody, Transform] });
         this.time = time;
         this.getGravity = getGravity;
-        this.linearSleepThreshold =
-            options.linearSleepThreshold ?? DEFAULT_LINEAR_SLEEP_THRESHOLD;
-        this.angularSleepThreshold =
-            options.angularSleepThreshold ?? DEFAULT_ANGULAR_SLEEP_THRESHOLD;
-        this.biasAngularSleepThreshold =
-            this.angularSleepThreshold * BIAS_ANGULAR_SLEEP_MULTIPLIER;
-        this.sleepTimeThreshold =
-            options.sleepTimeThreshold ?? DEFAULT_SLEEP_TIME_THRESHOLD;
         this.kinematicMovedActors = new Set();
     }
     destroy() {
@@ -93,10 +80,7 @@ export class PhysicsSubsystem {
                     (position.x - transform.world.position.x) * impulse.y -
                         (position.y - transform.world.position.y) * impulse.x;
             });
-            const { _centralForce, _centralImpulse, linearVelocity, mass, inverseMass, inverseInertia, gravityScale, lockRotation, sleeping, } = rigidBody;
-            if (sleeping) {
-                return;
-            }
+            const { _centralForce, _centralImpulse, linearVelocity, mass, inverseMass, inverseInertia, gravityScale, lockRotation, } = rigidBody;
             if (gravityScale) {
                 const gravity = this.getGravity();
                 _centralForce.x += mass * gravity.x * gravityScale;
@@ -150,7 +134,7 @@ export class PhysicsSubsystem {
             if (rigidBody.disabled || rigidBody.type !== 'dynamic') {
                 return;
             }
-            if (rigidBody.mass <= 0 || rigidBody.sleeping) {
+            if (rigidBody.mass <= 0) {
                 return;
             }
             transform.world.position.x +=
@@ -166,37 +150,6 @@ export class PhysicsSubsystem {
             }
         });
     }
-    updateSleepTimers() {
-        const deltaTime = this.time.fixedDeltaTime;
-        this.actorQuery.getActors().forEach((actor) => {
-            const rigidBody = actor.getComponent(RigidBody);
-            if (rigidBody.disabled ||
-                rigidBody.type !== 'dynamic' ||
-                rigidBody.mass <= 0 ||
-                !rigidBody.autoSleep) {
-                rigidBody._sleepTime = 0;
-                return;
-            }
-            if (rigidBody.sleeping) {
-                return;
-            }
-            const realMotionIsSmall = rigidBody.linearVelocity.squaredMagnitude <=
-                this.linearSleepThreshold * this.linearSleepThreshold &&
-                Math.abs(rigidBody.angularVelocity) <= this.angularSleepThreshold;
-            const biasMotionIsSmall = rigidBody._biasLinearVelocity.squaredMagnitude <=
-                this.linearSleepThreshold * this.linearSleepThreshold &&
-                Math.abs(rigidBody._biasAngularVelocity) <=
-                    this.biasAngularSleepThreshold;
-            if (!realMotionIsSmall || !biasMotionIsSmall) {
-                rigidBody._sleepTime = 0;
-                return;
-            }
-            rigidBody._sleepTime += deltaTime;
-            if (rigidBody._sleepTime >= this.sleepTimeThreshold) {
-                rigidBody.sleep();
-            }
-        });
-    }
     lateUpdate() {
         this.kinematicMovedActors.forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);

package/build/contrib/systems/physics-system/tests/helpers.d.ts

@@ -7,7 +7,7 @@ import { PhysicsSystem } from '../index';
 import type { PhysicsSettings, PhysicsSystemOptions } from '../types';
 export declare const createTime: (fixedDeltaTime?: number) => Time;
 export declare const createScene: () => Scene;
-export declare const createPhysicsSystem: (scene: Scene, settings?: PhysicsSettings, gravityY?: number, gravityX?: number, solverOptions?: Partial<Pick<PhysicsSystemOptions, 'solverIterations' | 'linearSleepThreshold' | 'angularSleepThreshold' | 'sleepTimeThreshold' | 'maxAllowedPenetration' | 'maxBiasVelocity'>>) => {
+export declare const createPhysicsSystem: (scene: Scene, settings?: PhysicsSettings, gravityY?: number, gravityX?: number, solverOptions?: Partial<Pick<PhysicsSystemOptions, 'solverIterations' | 'maxAllowedPenetration' | 'maxBiasVelocity'>>) => {
     physicsSystem: PhysicsSystem;
     world: World;
     time: Time;

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

@@ -5,9 +5,6 @@ export interface PhysicsSystemOptions extends SceneSystemOptions {
     gravityX?: number;
     gravityY?: number;
     solverIterations?: number;
-    linearSleepThreshold?: number;
-    angularSleepThreshold?: number;
-    sleepTimeThreshold?: number;
     maxAllowedPenetration?: number;
     maxBiasVelocity?: number;
 }

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

@@ -97,7 +97,8 @@ export class RendererAPI {
         const inverseMatrix = this.worldContainer.worldTransform.clone().invert();
         VIEW_COMPONENTS.forEach((ViewComponent) => {
             const viewComponent = actor.getComponent(ViewComponent);
-            if (!viewComponent?.renderData?.view?.__dacha.isReady) {
+            if (viewComponent?.disabled ||
+                !viewComponent?.renderData?.view?.__dacha.isReady) {
                 return;
             }
             const bounds = convertBounds(viewComponent.renderData.view, inverseMatrix);

package/build/contrib/systems/renderer/types.d.ts

@@ -20,6 +20,7 @@ export interface Bounds {
     height: number;
 }
 export interface ViewComponent extends Component {
+    disabled?: boolean;
     renderData?: {
         view: ViewContainer;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.18.1",
+  "version": "0.18.3",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {

package/build/contrib/systems/physics-system/subsystems/constraint-solver/contact-utils.d.ts

@@ -1,5 +0,0 @@
-import type { Actor } from '../../../../../engine/actor';
-import { type Vector2 } from '../../../../../engine/math-lib';
-import type { Contact } from '../collision-detection/types';
-export declare const shouldWakeSleepingContact: (contact: Contact, contactSpeedThreshold: number) => boolean;
-export declare const isSleepSupportContact: (contact: Contact, actor: Actor, gravity: Vector2) => boolean;

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

@@ -1,41 +0,0 @@
-import { VectorOps } from '../../../../../engine/math-lib';
-import { RigidBody } from '../../../../components/rigid-body';
-import { Transform } from '../../../../components/transform';
-import { SUPPORT_MIN_GRAVITY_DOT } from '../../consts';
-const getMinNormalVelocity = (contact) => {
-    const rigidBody1 = contact.actor1.getComponent(RigidBody);
-    const rigidBody2 = contact.actor2.getComponent(RigidBody);
-    const transform1 = contact.actor1.getComponent(Transform);
-    const transform2 = contact.actor2.getComponent(Transform);
-    const { normal } = contact;
-    let minVelocity = null;
-    for (const point of contact.contactPoints) {
-        const anchor1X = point.x - transform1.world.position.x;
-        const anchor1Y = point.y - transform1.world.position.y;
-        const anchor2X = point.x - transform2.world.position.x;
-        const anchor2Y = point.y - transform2.world.position.y;
-        const velocity1X = rigidBody1.linearVelocity.x - rigidBody1.angularVelocity * anchor1Y;
-        const velocity1Y = rigidBody1.linearVelocity.y + rigidBody1.angularVelocity * anchor1X;
-        const velocity2X = rigidBody2.linearVelocity.x - rigidBody2.angularVelocity * anchor2Y;
-        const velocity2Y = rigidBody2.linearVelocity.y + rigidBody2.angularVelocity * anchor2X;
-        const velocity = (velocity2X - velocity1X) * normal.x +
-            (velocity2Y - velocity1Y) * normal.y;
-        if (minVelocity === null || velocity < minVelocity) {
-            minVelocity = velocity;
-        }
-    }
-    return minVelocity;
-};
-export const shouldWakeSleepingContact = (contact, contactSpeedThreshold) => {
-    const minNormalVelocity = getMinNormalVelocity(contact);
-    return (minNormalVelocity !== null && -minNormalVelocity > contactSpeedThreshold);
-};
-export const isSleepSupportContact = (contact, actor, gravity) => {
-    const gravityMagnitude = gravity.magnitude;
-    if (gravityMagnitude === 0) {
-        return false;
-    }
-    const normalGravityDot = VectorOps.dotProduct(contact.normal, gravity);
-    const supportDot = contact.actor1 === actor ? normalGravityDot : -normalGravityDot;
-    return supportDot / gravityMagnitude > SUPPORT_MIN_GRAVITY_DOT;
-};

package/build/contrib/systems/physics-system/subsystems/constraint-solver/sleep-support-tracker.d.ts

@@ -1,13 +0,0 @@
-import type { Vector2 } from '../../../../../engine/math-lib';
-import type { Contact } from '../collision-detection/types';
-export declare class SleepSupportTracker {
-    private currentSupportedActors;
-    private previousSupportedActors;
-    private getGravity;
-    constructor(getGravity: () => Vector2);
-    beginFrame(): void;
-    trackContact(contact: Contact): void;
-    wakeUnsupportedBodies(): void;
-    endFrame(): void;
-    private trackActor;
-}

package/build/contrib/systems/physics-system/subsystems/constraint-solver/sleep-support-tracker.js

@@ -1,42 +0,0 @@
-import { RigidBody } from '../../../../components/rigid-body';
-import { isSleepSupportContact } from './contact-utils';
-export class SleepSupportTracker {
-    currentSupportedActors;
-    previousSupportedActors;
-    getGravity;
-    constructor(getGravity) {
-        this.currentSupportedActors = new Set();
-        this.previousSupportedActors = new Set();
-        this.getGravity = getGravity;
-    }
-    beginFrame() {
-        this.currentSupportedActors.clear();
-    }
-    trackContact(contact) {
-        this.trackActor(contact.actor1, contact);
-        this.trackActor(contact.actor2, contact);
-    }
-    wakeUnsupportedBodies() {
-        this.previousSupportedActors.forEach((actor) => {
-            if (this.currentSupportedActors.has(actor)) {
-                return;
-            }
-            const rigidBody = actor.getComponent(RigidBody);
-            rigidBody?.wakeUp();
-        });
-    }
-    endFrame() {
-        const previousSupportedActors = this.previousSupportedActors;
-        this.previousSupportedActors = this.currentSupportedActors;
-        this.currentSupportedActors = previousSupportedActors;
-    }
-    trackActor(actor, contact) {
-        const gravity = this.getGravity();
-        const rigidBody = actor.getComponent(RigidBody);
-        if (rigidBody.type !== 'dynamic' ||
-            !isSleepSupportContact(contact, actor, gravity)) {
-            return;
-        }
-        this.currentSupportedActors.add(actor);
-    }
-}