PhysicsBody.h

//
//  PhysicsBody.h
//  avara3d
//
//  Created by Morgan Davis on 1/26/18.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_PHYSICS_PHYSICSBODY_H
#define AVARA3D_PHYSICS_PHYSICSBODY_H
 
#include <memory>
 
#include "a3d/Math.h"
 
namespace a3d {
 
    class Mesh;
    class Node;
    class PhysicsWorld;
    class PhysicsBodyProxy;
    class PhysicsShapeProxy;
    class PhysicsShape;
    class Scene;
 
    class PhysicsBody {
 
    public:
        // [Public Types]
 
        enum class Type : uint8_t {
            Static,   
            Dynamic,  
            Kinematic 
        };
 
        enum class CenterOfMassCalculation : uint8_t {
            BoundsCenter, 
            // VolumeCentroid
        };
 
        // [Public Static Member Functions]
 
        static std::unique_ptr<PhysicsBody> StaticBody();
 
        static std::unique_ptr<PhysicsBody> StaticBody(const std::shared_ptr<PhysicsShape>& shape);
 
        static std::unique_ptr<PhysicsBody> DynamicBody();
 
        static std::unique_ptr<PhysicsBody> DynamicBody(const std::shared_ptr<PhysicsShape>& shape);
 
        static std::unique_ptr<PhysicsBody> KinematicBody();
 
        static std::unique_ptr<PhysicsBody> KinematicBody(const std::shared_ptr<PhysicsShape>& shape);
 
        // [Public Lifecycle Functions]
 
        explicit PhysicsBody(Type type);
 
        PhysicsBody(Type type, const std::shared_ptr<PhysicsShape>& shape);
 
        PhysicsBody(const PhysicsBody&)            = delete;
        PhysicsBody& operator=(const PhysicsBody&) = delete;
 
        PhysicsBody(PhysicsBody&&)            = delete;
        PhysicsBody& operator=(PhysicsBody&&) = delete;
 
        ~PhysicsBody();
 
        // [Public Member Functions]
 
        Type                                 type() const;
 
        void                                 type(Type type);
 
        const std::shared_ptr<PhysicsShape>& shape() const;
 
        void                                 shape(const std::shared_ptr<PhysicsShape>& shape);
 
        float                                mass() const;
 
        void                                 mass(float mass);
 
        math::vec3                           momentOfInertia() const;
 
        void                                 momentOfInertia(const math::vec3& moment);
 
        math::vec3                           centerOfMass() const;
 
        void                                 centerOfMass(const math::vec3& offset);
 
        float                                friction() const;
 
        void                                 friction(float friction);
 
        float                                rollingFriction() const;
 
        void                                 rollingFriction(float friction);
 
        float                                spinningFriction() const;
 
        void                                 spinningFriction(float friction);
 
        float                                restitution() const;
 
        void                                 restitution(float restitution);
 
        math::vec3                           linearVelocity() const;
 
        void                                 linearVelocity(const math::vec3& velocity);
 
        math::vec3                           angularVelocity() const;
 
        void                                 angularVelocity(const math::vec3& velocity);
 
        math::vec3                           linearFactor() const;
 
        void                                 linearFactor(const math::vec3& factor);
 
        math::vec3                           angularFactor() const;
 
        void                                 angularFactor(const math::vec3& factor);
 
        float                                linearDamping() const;
 
        void                                 linearDamping(float damping);
 
        float                                angularDamping() const;
 
        void                                 angularDamping(float damping);
 
        float                                linearSleepingThreshold() const;
 
        void                                 linearSleepingThreshold(float threshold);
 
        float                                angularSleepingThreshold() const;
 
        void                                 angularSleepingThreshold(float threshold);
 
        void                                 applyForce(const math::vec3& force, bool impulse);
 
        void                    applyForce(const math::vec3& force, const math::vec3& location, bool impulse);
 
        void                    applyTorque(const math::vec3& torque, bool impulse);
 
        math::vec3              totalForce() const;
 
        math::vec3              totalTorque() const;
 
        void                    clearForces();
 
        void                    ccdEnabled(bool enabled);
 
        bool                    ccdEnabled() const;
 
        void                    ccdMotionThreshold(float distance);
 
        float                   ccdMotionThreshold() const;
 
        void                    ccdSweptSphereRadius(float radius);
 
        float                   ccdSweptSphereRadius() const;
 
        bool                    affectedByGravity() const;
 
        void                    affectedByGravity(bool affectedByGravity);
 
        bool                    allowsResting() const;
 
        void                    allowsResting(bool allowsResting);
 
        bool                    resting() const;
 
        void                    resting(bool resting);
 
        bool                    autocalculatesCenterOfMass() const;
 
        void                    autocalculatesCenterOfMass(bool autocalculate);
 
        CenterOfMassCalculation centerOfMassCalculation() const;
 
        void                    centerOfMassCalculation(CenterOfMassCalculation calculation);
 
        bool                    autocalculatesMomentOfInertia() const;
 
        void                    autocalculatesMomentOfInertia(bool autocalculate);
 
        // [Internal Member Functions]
 
        void                    attachedToNode(const std::shared_ptr<Node>& node);
        void                    detachedFromNode(const std::shared_ptr<Node>& node);
 
        void meshDetachedFromNode(const std::shared_ptr<Node>& node, const std::shared_ptr<Mesh>& mesh);
        void meshAttachedToNode(const std::shared_ptr<Node>& node, const std::shared_ptr<Mesh>& mesh);
 
        void meshWillChangeOnNode(const std::shared_ptr<Node>& node, const std::shared_ptr<Mesh>& oldMesh);
        void meshDidChangeOnNode(const std::shared_ptr<Node>& node, const std::shared_ptr<Mesh>& newMesh);
 
        void physicsWorldReachable(PhysicsWorld& world);
        void physicsWorldUnreachable(PhysicsWorld& world);
 
        void addedToWorld(PhysicsWorld& world);
        void removedFromWorld(PhysicsWorld& world);
 
        void shapeWillUpdate();
        void shapeDidUpdate();
 
        void syncTransformFromNode();
 
        std::weak_ptr<Node> node() const;
 
        // the scene's world, if it exists.  not the same as _world.
        PhysicsWorld*       physicsWorld() const;
 
        PhysicsBodyProxy*   proxy() const;
 
    private:
        // [Private Member Functions]
 
        void                              checkAutocreateShape(const std::shared_ptr<Node>& node);
        void                              checkAutocreateShape(const std::shared_ptr<Mesh>& mesh);
 
        void                              checkAddToWorld();
 
        // [Private Member Variables]
 
        std::shared_ptr<PhysicsShape>     _shape;
        bool                              _shapeAutocreated;
        std::unique_ptr<PhysicsBodyProxy> _proxy;
        std::weak_ptr<Node>               _node;
        // either a pointer to the world we are currently in or null.
        PhysicsWorld*                     _world;
    };
 
}
 
#endif // AVARA3D_PHYSICS_PHYSICSBODY_H