qworld.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 QWORLD_H
#define QWORLD_H
#include <iostream>
#include <map>
#include <vector>
#include "qbody.h"
#include "qjoint.h"
#include "qvector.h"
#include "qmanifold.h"
#include "qgizmos.h"
#include "qbroadphase.h"
#include "qcollision.h"
#include "qrigidbody.h"
#include "qsoftbody.h"
#include "qraycast.h"
#include "qjoint.h"
#include "qmath_utils.h"
 
 
using namespace std;
class QWorld{
 
protected:
 
    
    //Collections
    
 
    vector <QJoint*> joints=vector<QJoint*>();
 
    vector <QSpring*> springs=vector<QSpring*>();
 
    vector<QRaycast*> raycasts=vector<QRaycast*>();
 
    vector <QGizmo*> gizmos=vector<QGizmo*>();
 
    vector<vector<QBody*> > sleepingIslands=vector<vector<QBody*> >();
 
    unordered_set<pair<QBody*, QBody*>, QBody::BodyPairHash,QBody::BodyPairEqual> collisionExceptions;
 
    vector<QManifold> manifolds;
 
    //Broadphase
    QBroadPhase *broadPhase=nullptr;
 
    
 
    //Physics World Properties
 
    bool enabled=true;
    QVector gravity=QVector(0.0f,0.2f);
    bool enableSleeping=true;
    bool enableBroadphase=true;
    int iteration=4;
    float timeScale=1.0f;
 
 
    //Sleeping
    float sleepingPositionTolerance=0.1f;
    float sleepingRotationTolerance=M_PI/180.0f;
 
    //Debug Features
    int debugAABBTestCount=0; //aabb test method call count
    int debugCollisionTestCount=0; // any collision method call count
 
    void ClearGizmos();
    void ClearBodies();
 
 
    //Collisions, Dynamic Colliders Islands and Sleeping Feature
    void CreateIslands(int bodyIndex, vector<QBody*> &bodyList, vector<QBody*> &island, vector<bool> &visitedList);
    void GenerateIslands(vector<QBody*> &bodyList, vector<vector<QBody*>> &islandList);
    static bool SortBodiesHorizontal(const QBody *bodyA,const QBody *bodyB);
    static bool SortBodiesVertical(const QBody *bodyA,const QBody *bodyB);
    void GetCollisionPairs(vector<QBody *> &bodyList,vector<pair<QBody *, QBody *> > *resList);
 
    void CreateIslands(QBody &body, vector<QBody*> island);
    vector<vector<QBody>> GenerateIslands(vector<QBody> bodyList );
    float softBodyCollisionHysteresis=0.2f;
 
    //Constraints
    void UpdateConstraints();
 
    
 
 
public:
 
    
 
    vector<QBody*> bodies=vector<QBody*>();
    
    /* It's the maximum world size in pixels. It is used in some calculations that require maximum values. */
    inline static float MAX_WORLD_SIZE=99999.0f;
 
    //General Get Methods
    /* Returns the gravity force of the world. 
     */
    QVector GetGravity(){
        return gravity;
    }
 
    
    bool GetSleepingEnabled(){
        return enableSleeping;
    }
    float GetSleepingPositionTolerance(){
        return sleepingPositionTolerance;
    }
    float GetSleepingRotationTolerance(){
        return sleepingRotationTolerance;
    }
    bool GetBroadphaseEnabled(){
        return enableBroadphase;
    }
 
    QBroadPhase *GetBroadphase(){
        return broadPhase;
    }
 
 
    int GetIterationCount(){
        return iteration;
    }
 
    float GetTimeScale(){
        return timeScale;   
    }
 
    bool GetEnabled(){
        return enabled;
    }
    float GetSoftBodyCollisionHysteresis(){
        return softBodyCollisionHysteresis;
    }
 
    //General Set Methods
    QWorld *SetGravity(QVector value){
        gravity=value;
        return this;
    }
    QWorld *SetSleepingEnabled(bool value){
        enableSleeping=value;
        return this;
    }
    QWorld *SetSleepingPositionTolerance(float value){
        sleepingPositionTolerance=value;
        return this;
    }
    QWorld *SetSleepingRotationTolerance(float value){
        sleepingRotationTolerance=value;
        return this;
    }
    QWorld *SetBroadphaseEnabled(bool value){
        enableBroadphase=value;
        return this;
    }
 
    QWorld *SetBroadphase(QBroadPhase *externalBroadphase){
        broadPhase=externalBroadphase;
        if (broadPhase!=nullptr){
            broadPhase->Clear();
        }
        return this;
    }
 
 
    QWorld *SetIterationCount(int value){
        iteration=value;
        return this;
    }
 
 
    QWorld *SetTimeScale(float value=1.0f){
        if (timeScale!=value){
            float velocityTimeScaleFactor=0.0f;
            if(timeScale!=0){
                if (value<timeScale){
                    velocityTimeScaleFactor=1/timeScale*value;
                }else{
                    velocityTimeScaleFactor=1.0f;
                }
            }
            
            
            for (auto body:bodies){
                if(body->enableBodySpecificTimeScale==false){
                    //recalculate velocities
                    if (body->bodyType==QBody::BodyTypes::RIGID){
                        QVector vel=body->GetPosition()-body->GetPreviousPosition();
                        vel*=velocityTimeScaleFactor;
                        body->SetPreviousPosition(body->GetPosition()-vel);
                        float rotVel=body->GetRotation()-body->GetPreviousRotation();
                        rotVel*=velocityTimeScaleFactor;
                        body->SetPreviousRotation(body->GetRotation()-rotVel);
                    }else if(body->bodyType!=QBody::BodyTypes::AREA){
                        for(auto mesh :body->_meshes){
                            for (auto particle :mesh->particles){
                                QVector vel=particle->GetGlobalPosition()-particle->GetPreviousGlobalPosition();
                                vel*=velocityTimeScaleFactor;
                                particle->SetPreviousGlobalPosition(particle->GetGlobalPosition()-vel );
                            }
                        }
                    }
                    body->WakeUp();
                        
                    
                }
            }
            timeScale=value;
        }
        return this;
    }
 
    QWorld *SetEnabled(bool value){
        enabled=value;
        return this;
    }
 
    QWorld *SetSoftBodyCollisionHysteresis(float value){
        softBodyCollisionHysteresis=value;
        return this;
    }
    
 
    //Methods
    void Update();
 
 
 
    static vector<QCollision::Contact*> GetCollisions(QBody *bodyA, QBody *bodyB,bool applyHotSolvers=true);
 
 
    QWorld *AddBody(QBody *body);
    QWorld *AddBodyGroup(const vector<QBody*> &bodyGroup);
    QWorld *RemoveBody(QBody *body);
    QWorld *RemoveBodyAt(int index);
    int GetBodyCount(){
        return bodies.size();
    }
    QBody *GetBodyAt(int index){
        return bodies[index];
    }
    int GetBodyIndex(QBody *body){
        if(body==nullptr)
            return -1;
        for(int i=0;i<bodies.size();i++){
            if(bodies[i]==body)
                return i;
        }
        return -1;
    }
    vector<QBody*> GetBodiesHitByPoint(QVector point,int maxBodyCount=1,bool onlyRigidBodies=true,int layersBit=-1);
    vector<QParticle*> GetParticlesCloseToPoint(QVector point,float distance,int maxParticleCount=1,bool exceptRigidBodies=true,int layersBit=-1);
    bool CollideWithWorld(QBody *body);
 
    vector<QManifold> TestCollisionWithWorld(QBody *body);
 
    //Joint Operations
    QWorld *AddJoint(QJoint *joint);
    QWorld *RemoveJoint(QJoint *joint);
    QWorld *RemoveJointAt(int index);
    QWorld *RemoveMatchingJoints(QBody *body);
    int GetJointCount(){
        return joints.size();
    }
    QJoint *GetJointAt(int index){
        return joints[index];
    }
    int GetJointIndex(QJoint *joint){
        for(int i=0;i<joints.size();i++)
            if(joints[i]==joint)
                return i;
        return -1;
    }
 
    //Spring Operations
    QWorld *AddSpring(QSpring *spring);
    QWorld *RemoveSpring(QSpring *spring);
    QWorld *RemoveSpringAt(int index);
    QWorld *RemoveMatchingSprings(QBody *body);
    QWorld *RemoveMatchingSprings(QParticle *particle);
    int GetSpringCount(){
        return springs.size();
    }
    QSpring *GetSpringAt(int index){
        return springs[index];
    }
    int GetSpringIndex(QSpring *spring){
        for(int i=0;i<springs.size();i++)
            if(springs[i]==spring)
                return i;
        return -1;
    }
 
    //Raycast Operations
    QWorld *AddRaycast(QRaycast * raycast);
    QWorld *RemoveRaycast(QRaycast *raycast);
    QWorld *RemoveRaycastAt(int index);
    int GetRaycastCount(){
        return raycasts.size();
    }
    QRaycast *GetRaycastAt(int index){
        return raycasts[index];
    }
    int GetRaycastIndex(QRaycast *raycast){
        for(int i=0;i<raycasts.size();i++)
            if(raycasts[i]==raycast)
                return i;
        return -1;
    }
 
    //Gizmos Operations
    vector<QGizmo*> *GetGizmos(){
        return &gizmos;
    };
 
    //Collision Exceptions  
    QWorld *AddCollisionException(QBody *bodyA, QBody *bodyB);
    QWorld *RemoveCollisionException(QBody *bodyA, QBody *bodyB);
    QWorld *RemoveMatchingCollisionException(QBody *body);
    bool CheckCollisionException(QBody *bodyA, QBody *bodyB);
 
    //
    QWorld();
    ~QWorld();
    QWorld *ClearJoints();
    QWorld *ClearSprings();
    QWorld *ClearRaycasts();
    QWorld *ClearWorld();
 
    friend class QCollision;
    friend class QManifold;
    friend class QSoftBody;
    friend class QBroadPhase;
 
 
 
};
 
#endif // QWORLD_H