qmesh.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 QMESH_H
#define QMESH_H
#include <vector>
#include "cmath"
#include "qspring.h"
#include "qparticle.h"
#include "qangleconstraint.h"
#include "json/json.hpp"
#include "fstream"
#include "qmath_utils.h"
 
using json =nlohmann::json;
 
using namespace std;
 
class QBody;
struct QMesh
{
public:
    enum CollisionBehaviors{
        CIRCLES,
        POLYGONS,
        POLYLINE
    };
protected:
    vector<QParticle*> particles=vector<QParticle*>();
 
    //General Properties
    QVector position=QVector::Zero();
    QVector globalPosition=QVector::Zero();
    float rotation=0.0f;
    float globalRotation=0.0f;
    vector<QSpring*> springs=vector<QSpring*>();
    vector<QAngleConstraint*> angleConstraints=vector<QAngleConstraint*>();
    vector <QParticle*> polygon=vector<QParticle*>();
    vector<vector<QParticle*>> subConvexPolygons=vector<vector<QParticle*>>();
    vector<QVector> polygonBisectors;
    float circumference=0.0f;
    QBody *ownerBody=nullptr;
    CollisionBehaviors collisionBehavior=CollisionBehaviors::CIRCLES;
    vector<vector<int>> UVMaps=vector<vector<int>>();
    bool disablePolygonForCollisions=false;
    
 
    bool collisionBehaviorNeedsUpdate=false;
 
    //Helper Methods
    void UpdateCollisionBehavior();
    
 
    //Polygon Properties
    vector<float> lastPolygonCornerAngles;
    float minAngleConstraintOfPolygon=M_PI*0.3;
 
    //Polygon Methods
    void UpdateSubConvexPolygons(bool majorUpdate=true);
    void UpdatePolygonBisectors();
    static vector<QVector> GetBisectors(vector<QParticle*> polygonParticles);
    void ApplyAngleConstraintsToPolygon();
    bool CheckIsPolygonConcave(vector<QParticle*> polygonParticles);
    static bool CheckIsReflex(QVector pA,QVector pB, QVector pC);
    static bool CheckIsReflex(int indexA,int indexB, int indexC, vector<QParticle*> polygonParticles);
    static void TriangulatePolygon(vector<QParticle*> &polygonParticles,vector<vector<int>> &triangles);
    static void DecompositePolygon(vector<QParticle*> &polygonParticles,vector<vector<QParticle*>> &polygons);
    static void DecompositePolygon2(vector<QParticle*> &polygonParticles,vector<vector<QParticle*>> &polygons);
    bool subConvexPolygonsNeedsUpdate=false;
    bool polygonBisectorsNeedsUpdate=true;
    bool isPolygonSelfIntersected=false;
 
public:
    struct MeshData{
        vector<QVector> particlePositions;
        vector<float> particleRadValues;
        vector<bool> particleInternalValues;
        vector<bool> particleEnabledValues;
        vector<bool> particleLazyValues;
        vector<pair<int,int>> springList;
        vector<pair<int,int>> internalSpringList;
        vector<int> polygon;
 
 
        vector<vector<int>> UVMaps;
 
        QVector position=QVector::Zero();
 
        float rotation=0.0f;
        
    };
 
    friend class QWorld;
    friend class QBody;
    friend class QRigidBody;
    friend class QSoftBody;
    friend class QRaycast;
    friend class QCollision;
    friend class QParticle;
 
    QMesh();
    ~QMesh();
 
 
    //General Get Methods
    QVector GetPosition(){
        return position;
    }
    QVector GetGlobalPosition(){
        return globalPosition;
    }
    float GetRotation(){
        return rotation;
    }
    float GetGlobalRotation(){
        return globalRotation;
    }
    float GetInitialArea(){
        float res=0.0f;
        res+=GetPolygonArea(polygon,true);
        for(auto particle:particles){
            if(particle->GetRadius()>0.5f){
                res+=particle->GetRadius()*particle->GetRadius();
            }
        }
        return res;
    }
    float GetInitialPolygonArea(){
        float res=GetPolygonArea(polygon,true);
        return res;
    }
    float GetArea(){
        float res=0.0f;
        res+=GetPolygonArea(polygon,false);
        for(auto particle:particles){
            if(particle->GetRadius()>0.5f){
                res+=particle->GetRadius()*particle->GetRadius();
            }
        }
        return res;
    }
    float GetPolygonArea(){
        float res=GetPolygonArea(polygon,false);
 
        return res;
    }
 
    float GetCircumference(){
        float res=0.0f;
        for(int i=0;i<polygon.size();i++){
            QParticle *p=polygon[i];
            QParticle *np=polygon[(i+1)%polygon.size()];
            float length=(np->GetPosition()-p->GetPosition()).Length();
            res+=length;
        }
 
        return res;
    }
    QBody *GetOwnerBody(){
        return ownerBody;
    }
    CollisionBehaviors GetCollisionBehavior(){
        if(collisionBehaviorNeedsUpdate){
            UpdateCollisionBehavior();
            collisionBehaviorNeedsUpdate=false;
        }
        return collisionBehavior;
    }
    bool GetPolygonForCollisionsDisabled(){
        return disablePolygonForCollisions;
    }
 
 
    //General Set Methods
    QMesh* SetPosition(QVector value){
        position=value;
        return this;
    }
    QMesh* SetGlobalPosition(QVector value){
        globalPosition=value;
        return this;
    }
    QMesh *SetRotation(float value){
        rotation=value;
        return this;
    }
 
    QMesh *SetPolygonForCollisionsDisabled(bool value){
        disablePolygonForCollisions=value;
        collisionBehaviorNeedsUpdate=true;
        return this;
    }
    
 
 
 
 
    //Particle Operations
    
    QMesh * AddParticle(QParticle *particle);
 
    QMesh * RemoveParticleAt(int index);
    QMesh * RemoveParticle(QParticle *particle);
    int GetParticleCount();
    QParticle *GetParticleAt(int index);
 
    int GetParticleIndex(QParticle *particle){
        for(int i=0;i<particles.size();i++){
            if(particles[i]==particle){
                return i;
            }
        }
        return -1;
    }
    QVector GetAveragePosition();
 
    float GetAverageRotation();
 
 
 
 
    //Polygon Operations
 
    QMesh * SetPolygon(vector<QParticle *> polygonParticles); 
 
    QMesh * AddParticleToPolygon(QParticle * particle, int position=-1);
 
    QMesh *RemoveParticleFromPolygon(QParticle * particle);
 
    QMesh * RemoveParticleFromPolygonAt(int index);
 
    QMesh * RemovePolygon();
 
    int GetPolygonParticleCount();
 
    QParticle *GetParticleFromPolygon(int index);
 
 
    float  GetMinAngleConstraintOfPolygon(){
        return minAngleConstraintOfPolygon;
    }
 
    QMesh *SetMinAngleConstraintOfPolygon(float radian){
        minAngleConstraintOfPolygon=radian;
        return this;
    }
 
    
 
    int GetSubConvexPolygonCount(){
        if (subConvexPolygonsNeedsUpdate==true){
            UpdateSubConvexPolygons();
            subConvexPolygonsNeedsUpdate=false;
        }
        return subConvexPolygons.size();
    }
    vector<QParticle*> &GetSubConvexPolygonAt(int index){
        if (subConvexPolygonsNeedsUpdate==true){
            UpdateSubConvexPolygons();
            subConvexPolygonsNeedsUpdate=false;
        }
        return subConvexPolygons[index];
    }
 
    QVector GetPolygonBisectorVectorAt(int index){
        return polygonBisectors[index];
    }
    
 
    //Spring Operations
    
    QMesh *AddSpring(QSpring *spring);
    QMesh *RemoveSpring(QSpring *spring);
    QMesh *RemoveSpringAt(int index);
    QMesh *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;
    }
 
    
 
    //UV Operations
 
    int GetUVMapCount(){
        return UVMaps.size();
    };
 
    vector<int> GetUVMapAt(int index){
        return UVMaps[index];
    };
 
    QMesh * AddUVMap(vector<int> map);
 
    QMesh * RemoveUVMapAt(int index);
 
    QMesh * ClearUVMaps();
 
 
    QMesh * RemoveMatchingUVMaps(int particleIndex);
 
 
 
    
    //Angle Constraint Operations
 
    int GetAngleConstraintCount(){
        return angleConstraints.size();
    }
    QAngleConstraint *GetAngleConstraintAt(int index){
        return angleConstraints[index];
    }
    QMesh *AddAngleConstraint( QAngleConstraint * angleConstraint ){
        angleConstraints.push_back(angleConstraint);
        return this;
    }
 
    QMesh *RemoveAngleConstraintAt( int index ){
        angleConstraints.erase(angleConstraints.begin()+index );
        return this;
    }
    int GetAngleConstraintIndex(QAngleConstraint *angleConstraint){
        for(int i=0;i<angleConstraints.size();i++)
            if(angleConstraints[i]==angleConstraint)
                return i;
        return -1;
    }
 
    QMesh *RemoveAngleConstraint( QAngleConstraint *angleConstraint ){
        int index=GetAngleConstraintIndex(angleConstraint);
        if(index!=-1){
            RemoveAngleConstraintAt(index);
        }
        return this;
    }
 
    QMesh *RemoveMatchingAngleConstraints(QParticle *particle){
        int i=0;
        while(i<angleConstraints.size()){
            QAngleConstraint *constraint=angleConstraints[i];
            if(constraint->GetParticleA()==particle || constraint->GetParticleB()==particle || constraint->GetParticleC()==particle){
                RemoveAngleConstraintAt(i);
            }else{
                ++i;
            }
        }
 
        return this;
    }
 
    
 
 
 
    //Static Methods
    static QMesh * CreateWithCircle(float radius,QVector centerPosition=QVector::Zero());
    static QMesh * CreateWithPolygon(float radius,int sideCount,QVector centerPosition=QVector::Zero(),int polarGrid=-1,bool enableSprings=true, bool enablePolygons=true,float particleRadius=0.5f);
 
    static QMesh * CreateWithRect(QVector size,QVector centerPosition=QVector::Zero(),QVector grid=QVector::Zero(),bool enableSprings=true, bool enablePolygons=true,float particleRadius=0.5f);
 
    static QMesh * CreateWithMeshData(QMesh::MeshData &data,bool enableSprings=true, bool enablePolygons=true);
 
    static vector<QMesh::MeshData> GetMeshDatasFromFile(string filePath);
 
 
    static vector<QMesh::MeshData> GetMeshDatasFromJsonData(std::string &jsonBasedData);
 
 
 
 
 
    static float GetPolygonArea(vector<QParticle*> &polygonPoints,bool withLocalPositions=false);
 
 
    static bool CheckCollisionBehaviors(QMesh *meshA,QMesh * meshB,CollisionBehaviors firstBehavior,CollisionBehaviors secondBehavior );
    static MeshData GenerateRectangleMeshData(QVector size,QVector centerPosition=QVector::Zero(),QVector grid=QVector::Zero(),float particleRadius=0.5f);
    static MeshData GeneratePolygonMeshData(float radius, int sideCount, QVector centerPosition=QVector::Zero(),int polarGrid=-1,float particleRadius=0.5f);
 
    static pair<QVector, float> GetAveragePositionAndRotation(vector<QParticle*> particleCollection);
 
    static vector<QVector> GetMatchingParticlePositions(vector<QParticle*> particleCollection,QVector targetPosition, float targetRotation);
 
 
    bool manualDeletion=false;
 
    friend class QSoftBody;
 
 
    
};
 
#endif // QMESH_H