lingo3d/lib/display/core/PhysicsObjectManager.js

Lingo3D is a React/Vue 3d game development framework that ships with a complete visual editor

import { setPxVec, setPxVec_ } from "../../engine/physx/pxMath";
import cookConvexGeometry, { decreaseConvexGeometryCount } from "../../engine/physx/cookConvexGeometry";
import { physxPtr } from "../../pointers/physxPtr";
import VisibleObjectManager from "./VisibleObjectManager";
import { controllerVXUpdateMap, controllerVYUpdateMap, controllerVZUpdateMap, actorPtrManagerMap, controllerManagerContactMap, managerActorPtrMap, managerContactMap } from "../../collections/pxCollections";
import { configJointSystemPtr } from "../../pointers/configJointSystemPtr";
import { configCastShadowSystem } from "../../systems/configLoadedSystems/configCastShadowSystem";
import { configPhysicsSystem } from "../../systems/configLoadedSystems/configPhysicsSystem";
export default class PhysicsObjectManager extends VisibleObjectManager {
    $actor;
    $capsuleHeight;
    $controller;
    $convexGeometry;
    _mass;
    get mass() {
        if (this.$controller)
            return 1;
        if (this.$actor && !this.$actor.getMass)
            return 0;
        return this.$actor?.getMass() ?? this._mass ?? 1;
    }
    set mass(val) {
        this._mass = val;
        this.$actor?.setMass?.(val);
    }
    gravity;
    get velocityX() {
        return this.$actor?.getLinearVelocity().get_x() ?? 0;
    }
    set velocityX(val) {
        const { $actor: actor } = this;
        if (!actor)
            return;
        if (this._physics === "character") {
            controllerVXUpdateMap.set(this, val);
            return;
        }
        const velocity = actor.getLinearVelocity();
        velocity.set_x(val);
        actor.setLinearVelocity(velocity);
    }
    get velocityY() {
        return this.$actor?.getLinearVelocity().get_y() ?? 0;
    }
    set velocityY(val) {
        const { $actor: actor } = this;
        if (!actor)
            return;
        if (this._physics === "character") {
            controllerVYUpdateMap.set(this, val);
            return;
        }
        const velocity = actor.getLinearVelocity();
        velocity.set_y(val);
        actor.setLinearVelocity(velocity);
    }
    get velocityZ() {
        return this.$actor?.getLinearVelocity().get_z() ?? 0;
    }
    set velocityZ(val) {
        const { $actor: actor } = this;
        if (!actor)
            return;
        if (this._physics === "character") {
            controllerVZUpdateMap.set(this, val);
            return;
        }
        const velocity = actor.getLinearVelocity();
        velocity.set_z(val);
        actor.setLinearVelocity(velocity);
    }
    addForce(x, y, z) {
        this.$actor?.addForce(setPxVec(x, y, z));
    }
    addLocalForceAtPos(x, y, z, posX = 0, posY = 0, posZ = 0) {
        const { PxRigidBodyExt } = physxPtr[0];
        if (!PxRigidBodyExt || !this.$actor)
            return;
        PxRigidBodyExt.prototype.addLocalForceAtPos(this.$actor, setPxVec(x, y, z), setPxVec_(posX, posY, posZ));
    }
    addLocalForceAtLocalPos(x, y, z, posX = 0, posY = 0, posZ = 0) {
        const { PxRigidBodyExt } = physxPtr[0];
        if (!PxRigidBodyExt || !this.$actor)
            return;
        PxRigidBodyExt.prototype.addLocalForceAtLocalPos(this.$actor, setPxVec(x, y, z), setPxVec_(posX, posY, posZ));
    }
    addTorque(x, y, z) {
        this.$actor?.addTorque(setPxVec(x, y, z));
    }
    _joints;
    get $joints() {
        return (this._joints ??= new Set());
    }
    $initActor(actor) {
        this.$actor = actor;
        const { _mass } = this;
        if (_mass !== undefined)
            actor.mass = _mass;
        actorPtrManagerMap.set(actor.ptr, this);
        managerActorPtrMap.set(this, actor.ptr);
        if (this._joints)
            for (const joint of this._joints)
                configJointSystemPtr[0].add(joint);
        return actor;
    }
    disposeNode() {
        super.disposeNode();
        decreaseConvexGeometryCount(this);
    }
    $getPxShape(_, actor) {
        const { material, shapeFlags, PxRigidActorExt, pxFilterData } = physxPtr[0];
        const shape = PxRigidActorExt.prototype.createExclusiveShape(actor, cookConvexGeometry(this.componentName, this), material, shapeFlags);
        shape.setSimulationFilterData(pxFilterData);
        return shape;
    }
    _physics;
    get physics() {
        return this._physics;
    }
    set physics(val) {
        this._physics = val;
        configPhysicsSystem.add(this);
        configCastShadowSystem.add(this);
    }
    _jointCount;
    get $jointCount() {
        return this._jointCount ?? 0;
    }
    set $jointCount(val) {
        this._jointCount = val;
        configPhysicsSystem.add(this);
        configCastShadowSystem.add(this);
    }
    //@ts-ignore
    hitTest(target) {
        if (this._physics && "_physics" in target && target._physics) {
            if (this._physics === "character")
                return !!controllerManagerContactMap.get(this)?.has(target);
            if (target._physics === "character")
                return !!controllerManagerContactMap.get(target)?.has(this);
            return !!managerContactMap.get(this)?.has(target);
        }
        return super.hitTest(target);
    }
}
//# sourceMappingURL=PhysicsObjectManager.js.map