PhysicsBody.h

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <string>
#include <utility>
#include <glm/glm.hpp>
#include <vector>
#include <map>
#include <mutex>
#include <unordered_set>
 
#include "physics/ThermalProperties.h"
 
class ICollider;
 
namespace Physics {
    namespace Bounding {
        class ICollider;
    }
 
    class PointMass;
    class RigidBody;
    class PhysicsBody;
}
 
enum class BodyLock {
    LOCK,
    NOLOCK
};
 
constexpr BodyLock operator!(BodyLock lock) {
    return (lock == BodyLock::LOCK) ? BodyLock::NOLOCK : BodyLock::LOCK;
}
 
struct ObjectSnapshot {
    Physics::PhysicsBody* body;
    float time;
    glm::vec3 position;
    glm::vec3 velocity;
    float temperature;
};
 
namespace Physics {
    class PhysicsBody {
    public:
        PhysicsBody() = delete;
        virtual ~PhysicsBody() = default;
 
        virtual void step(float dt, BodyLock lock) = 0;
        virtual void recordFrame(float t, BodyLock lock) = 0;
        virtual void loadFrame(const ObjectSnapshot& snapshot, BodyLock lock) = 0;
 
        std::unique_lock<std::mutex> lockState() const { return std::unique_lock(stateMutex); }
 
        uint32_t getID() const { return id; }
        bool isUnknown(const std::string& key, BodyLock lock) const;
        void setUnknown(const std::string& key, bool active, BodyLock lock);
 
        void setForce(const std::string& name, const glm::vec3& force, BodyLock lock);
        glm::vec3 getForce(const std::string& name, BodyLock lock) const;
        glm::vec3 getNetForce(BodyLock lock) const;
        std::map<std::string, glm::vec3> getAllForces(BodyLock lock) const;
 
        glm::vec3 getPosition(BodyLock lock) const;
        void setPosition(const glm::vec3& pos, BodyLock lock);
        glm::vec3 getVelocity(BodyLock lock) const;
        void setVelocity(const glm::vec3& vel, BodyLock lock);
        virtual double getMass(BodyLock lock) const;
        virtual void setMass(double newMass, BodyLock lock);
        virtual ThermalProperties getThermalProperties(BodyLock lock) const;
        virtual void setThermalProperty(const ThermalProperties& newProps, BodyLock lock);
        float getSurfaceArea() const { return surfaceArea; }
        bool getIsStatic(BodyLock lock) const;
        void setIsStatic(bool newStatic, BodyLock lock);
 
        glm::mat4 getWorldTransform(BodyLock lock) const;
        void setWorldTransform(const glm::mat4& M, BodyLock lock);
        void setGlobalAccelerationRef(std::atomic<glm::vec3>& globalAccRef) { globalAccelPtr = &globalAccRef; }
        void clearAllFrames(BodyLock lock);
 
        template <typename F>
        void withFrames(BodyLock lock, F&& fn) const;
 
        virtual Bounding::ICollider *getCollider() const { return nullptr; }
 
        // Uses double dispatch
        virtual bool collidesWith(const PhysicsBody& other) const = 0;
        virtual bool collidesWithPointMass(const PointMass& pm) const = 0;
        virtual bool collidesWithRigidBody(const RigidBody& rb) const = 0;
 
        virtual bool resolveCollisionWith(float dt, PhysicsBody& other) = 0;
        virtual bool resolveCollisionWithPointMass(float dt, PointMass& pm) = 0;
        virtual bool resolveCollisionWithRigidBody(float dt, RigidBody& rb) = 0;
    protected:
        explicit PhysicsBody(uint32_t _id) : id(_id) {}
 
        mutable std::mutex stateMutex;
        std::vector<ObjectSnapshot> frames;
        float surfaceArea = 1.0f;
    private:
        bool isStatic = false;
        uint32_t id;
 
        glm::vec3 position = glm::vec3(0.0f);
        glm::vec3 velocity = glm::vec3(0.0f);
        glm::vec3 netForce = glm::vec3(0.0f);
        std::map<std::string, glm::vec3> forces;
 
        std::unordered_set<std::string> unknowns;
 
        glm::mat4 worldMatrix = glm::mat4(1.0f);
        std::atomic<glm::vec3>* globalAccelPtr = nullptr;
 
        double mass = 1.0;
        ThermalProperties thermalProps;
    };
 
    template <typename F>
    void PhysicsBody::withFrames(BodyLock lock, F&& fn) const {
        std::unique_lock<std::mutex> maybeLock;
        if (lock == BodyLock::LOCK)
            maybeLock = std::unique_lock<std::mutex>(stateMutex);
        std::forward<F>(fn)(frames);
    }
}