qbody.h

 
/************************************************************************************
 * MIT License
 *
 * Copyright (c) 2023 Eray Zesen
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * https://github.com/erayzesen/QuarkPhysics
 *
**************************************************************************************/
 
#ifndef QBODY_H
#define QBODY_H
 
#include "qvector.h"
#include "qaabb.h"
#include <cmath>
#include <vector>
#include "qmesh.h"
#include <functional>
#include "qmath_utils.h"
 
 
class QWorld;
class QBody{
    float inertia=0.0f;
    float circumference=0.0f;
public:
    enum Modes{
        DYNAMIC,
        STATIC
    };
 
    enum BodyTypes{
        RIGID,
        AREA,
        SOFT
    };
    enum SimulationModels{
        MASS_SPRING,
        RIGID_BODY
    };
 
    struct BodyPairHash {
        size_t operator()(const std::pair<QBody*, QBody*>& p) const {
            std::size_t h1 = std::hash<QBody*>{}(p.first);
            std::size_t h2 = std::hash<QBody*>{}(p.second);
            return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
        }
    };
 
    struct BodyPairEqual {
        bool operator()(const std::pair<QBody*, QBody*>& p1, const std::pair<QBody*, QBody*>& p2) const {
            return (p1.first == p2.first && p1.second == p2.second) ||
                (p1.first == p2.second && p1.second == p2.first);
        }
    };
 
protected:
 
    //General Properties
 
    QWorld *world;
    QVector position=QVector(0,0);
    QVector prevPosition=QVector::Zero();
    float rotation=0.0f;
    float prevRotation=0.0f;
    QAABB aabb;
    Modes mode=QBody::Modes::DYNAMIC;
    bool inertiaNeedsUpdate=true;
    bool circumferenceNeedsUpdate=true;
    bool enableBodySpecificTimeScale=false;
    float bodySpecificTimeScale=1.0f;
    BodyTypes bodyType=BodyTypes::RIGID;
    bool enabled=true;
    float velocityLimit=0.0f;
    bool enableIntegratedVelocities=true;
 
    //Material Properties;
 
    float friction=0.2f;
    float staticFriction=0.5f;
    float airFriction=0.01f;
    float mass=1.0f;
    float restitution=0.0f;
 
    //Collision Features
    int layersBit=1;
    int collidableLayersBit=1;
    bool isKinematic=false;
    bool allowKinematicCollisions=false;
 
    //Sleeping Features
    bool isSleeping=false;
 
    int sleepTick=120;
    int fixedVelocityTick=0;
    int fixedAngularTick=0;
    bool canSleep=true;
 
 
    void UpdateAABB();
    void UpdateMeshTransforms();
    virtual void Update(){};
    virtual void PostUpdate(){};
    virtual bool CanGiveCollisionResponseTo(QBody *otherBody);
 
    public:
        QBody();
        virtual ~QBody();
 
        //Collision Info
        struct CollisionInfo{
            QVector position;
            QBody *body;
            QVector normal;
            float penetration;
            CollisionInfo(QVector position,QBody *body,QVector normal,float penetration) : position(position), body(body), normal(normal), penetration(penetration){};
        };
 
        //Default Events
        virtual void OnPreStep(){};
        virtual void OnStep(){};
        virtual bool OnCollision(CollisionInfo){ return true;}
 
        //Custom Event Listeners
        std::function<void(QBody *body)> PreStepEventListener;
        std::function<void(QBody *body)> StepEventListener;
        std::function<bool(QBody *body,CollisionInfo)> CollisionEventListener;
 
 
 
 
        //General Get Methods
 
        BodyTypes GetBodyType(){
            return bodyType;
        }
        QWorld *GetWorld(){
            return world;
        }
        QVector GetPosition(){
            return position;
        }
        QVector GetPreviousPosition(){
            return prevPosition;
        }
        float GetRotation(){
            return rotation;
        }
        float GetRotationDegree(){
            return GetRotation()/(M_PI/180);
        }
        float GetPreviousRotation(){
            return prevRotation;
        }
        QAABB GetAABB()const{
            return aabb;
        }
        
        float GetTotalInitialArea(){
            float res=0.0f;
            for(auto mesh:_meshes){
                res+=mesh->GetInitialArea();
            }
            return res;
        }
        float GetTotalPolygonsInitialArea(){
            float res=0.0f;
            for(auto mesh:_meshes){
                res+=mesh->GetInitialPolygonsArea();
            }
            return res;
        }
        float GetTotalArea(){
            float res=0.0f;
            for(auto mesh:_meshes){
                res+=mesh->GetArea();
            }
            return res;
        }
        float GetTotalPolygonsArea(){
            float res=0.0f;
            for(auto mesh:_meshes){
                res+=mesh->GetPolygonsArea();
            }
            return res;
        }
        Modes GetMode(){
            return mode;
        }
        float GetInertia(){
            if(inertiaNeedsUpdate==true){
                inertia=GetTotalInitialArea()*2.0f*mass;
                inertia=inertia<500.0f ? 500.0f:inertia;
                inertiaNeedsUpdate=false;
            }
            return inertia;
        }
        int GetLayersBit(){
            return layersBit;
        }
        int GetCollidableLayersBit(){
            return collidableLayersBit;
        }
        bool GetOverlapWithCollidableLayersBit(int layersBit){
            if( (layersBit & this->collidableLayersBit)==0 )
                return false;
            return true;
        }
        bool GetOverlapWithLayersBit(int layersBit){
            if( (layersBit & this->layersBit)==0 ){
                return false;
            }
            return true;
        }
        bool GetIsSleeping(){
            return isSleeping;
        }
        bool GetCanSleep(){
            return canSleep;
        }
        SimulationModels GetSimulationModel(){
            return simulationModel;
        }
 
        float GetFriction(){
            return friction;
        }
        float GetStaticFriction(){
            return staticFriction;
        }
 
        float GetAirFriction(){
            return airFriction;
        }
 
        virtual float GetMass(){
            return mass;
        }
        float GetRestitution(){
            return restitution;
        }
 
        float GetCircumference(){
            if(circumferenceNeedsUpdate==true){
                circumference=0.0f;
                for(auto mesh:_meshes){
                    circumference+=mesh->GetCircumference();
                }
                circumferenceNeedsUpdate=false;
            }
 
            return circumference;
        }
        
        bool GetBodySpecificTimeScaleEnabled(){
            return enableBodySpecificTimeScale;
        }
        float GetBodySpesificTimeScale(){
            return bodySpecificTimeScale;
        }
 
        bool GetEnabled(){
            return enabled;
        }
        float GetVelocityLimit();
 
        bool GetIntegratedVelocitiesEnabled();
 
 
 
        //General Set Methods
        QBody * SetPosition(QVector value, bool withPreviousPosition=true){
            position=value;
            if (withPreviousPosition) {
                prevPosition=position;
            }
            WakeUp();
 
            UpdateMeshTransforms();
            UpdateAABB();
            return this;
        }
 
        QBody *AddPosition(QVector value, bool withPreviousPosition=true){
            return SetPosition(GetPosition()+value,withPreviousPosition);
        }
        QBody * SetPreviousPosition(QVector value){
            prevPosition=value;
            return this; 
        }
        QBody *AddPreviousPosition(QVector value){
            return SetPreviousPosition(GetPreviousPosition()+value);
        }
        QBody * SetRotation(float angleRadian, bool withPreviousRotation=true){
            rotation=angleRadian;
            if(withPreviousRotation)
                prevRotation=angleRadian;
            WakeUp();
            UpdateMeshTransforms();
            return this;
        }
        QBody * SetRotationDegree(float degree, bool withPreviousRotation=true){
            return SetRotation( degree*(M_PI/180.0f),withPreviousRotation );
        }
        
        QBody *AddRotation(float angleRadian, bool withPreviousRotation=true){
            return SetRotation(GetRotation()+angleRadian,withPreviousRotation);
        }
        QBody *SetPreviousRotation(float angleRadian){
            prevRotation=angleRadian;
            return this;
        }
        QBody *AddPreviousRotation(float angleRadian){
            return SetPreviousRotation(GetPreviousRotation()+angleRadian);
        }
        
        
 
 
        
        QBody *SetLayersBit(int value){
            layersBit=value;
            return this;
        }
        QBody *SetCollidableLayersBit(int value){
            collidableLayersBit=value;
            return this;
        }
        QBody *SetCanSleep(bool value){
            canSleep=value;
            return this;
        }
        QBody * SetMode(QBody::Modes bodyMode){
            mode=bodyMode;
            return this;
        }
        QBody * SetSimulationModel(SimulationModels model)
        {
            simulationModel=model;
            for(auto mesh:_meshes){
                mesh->UpdateCollisionBehavior();
            }
            UpdateMeshTransforms();
 
            return this;
        }
        QBody *SetFriction(float value){
            friction=value;
            return this;
        }
        QBody *SetStaticFriction(float value){
            staticFriction=value;
            return this;
        }
 
        QBody *SetAirFriction(float value){
            airFriction=value;
            return this;
        }
 
        QBody *SetMass(float value){
            mass=value;
            inertiaNeedsUpdate=true;
            return this;
        }
        QBody *SetRestitution(float value){
            restitution=value;
            return this;
        }
 
        QBody *SetBodySpecificTimeScaleEnabled(bool value){
            enableBodySpecificTimeScale=value;
            return this;
        }
 
        QBody *SetBodySpecificTimeScale(float value){
            bodySpecificTimeScale=value;
            return this;
        }
        QBody *SetEnabled(bool value){
            enabled=true;
            return this;
        }
 
        QBody *SetIntegratedVelocitiesEnabled(bool value);
 
 
        //Mesh Methods
        QBody * AddMesh(QMesh *mesh);
        QBody * RemoveMeshAt(int index);
        QMesh * GetMeshAt(int index);
        int GetMeshCount();
        vector<QMesh*>  *GetMeshes();
 
        QBody * AddMeshesFromFile(string filePath);
 
 
        //Methods About the Sleeping Feature
        QBody* WakeUp() {
            isSleeping = false;
            return this;
        }
 
        QBody *SetVelocityLimit(float value);
 
 
        friend class QMesh;
        friend class QWorld;
        friend class QManifold;
        friend class QParticle;
        friend class QJoint;
        friend class QBroadPhase;
 
    protected:
        vector<QMesh*> _meshes=vector<QMesh*>();
        SimulationModels simulationModel=SimulationModels::RIGID_BODY;
        static QVector ComputeFriction(QBody *bodyA, QBody *bodyB, QVector &normal, float penetration, QVector &relativeVelocity);
        static bool CanCollide(QBody *bodyA,QBody *bodyB,bool checkBodiesAreEnabled=true);
 
 
};
 
#endif // QBODY_H