qsoftbody.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 QSOFTBODY_H
#define QSOFTBODY_H
#include "qbody.h"
#include <utility>
class QSoftBody : public QBody
{
    //#Softbody Properties
    float rigidity=1.0f;
    float enableAreaPreserving=false;
    float areaPreservingRate=0.8f;
    float areaPreservingRigidity=1.0f;
    float targetPreservationArea=0.0f;
 
    float particleSpesificMass=1.0f;
    bool enableParticleSpesificMass=false;
 
 
    float circumference=0.0f;
    bool enableAreaStability=false;
    bool enablePassivationOfInternalSprings=false;
 
 
    bool enableSelfCollisions=false;
    float selfCollisionParticleRadius=0.0f;
 
    bool enableShapeMatching=false;
    float shapeMatchingRate=0.4f;
    bool ApplyShapeMatchingInternals=false;
    bool enableShapeMatchingFixedTransform=false;
    QVector shapeMatchingFixedPosition=QVector::Zero();
    float shapeMatchingFixedRotation=0.0f;
 
 
    //Helper methods
 
    float safe_asin(float value){
        if(value<-1.0f){
            return asin(-1.0);
        }else if(value>1.0f){
            return asin(1.0);
        }else{
            return asin(value);
        }
    }
 
    bool IsPolygonCW(vector<QParticle*> polygon);
 
 
public:
    QSoftBody();
 
 
 
    //Properties Set Methods (it returns this)
    QSoftBody * SetRigidity(float value){
        rigidity=value;
        return this;
    };
    QSoftBody * SetAreaPreservingRate(float value){
        areaPreservingRate=value;
        return this;
    }
    QSoftBody * SetAreaPreservingRigidity(float value){
        areaPreservingRigidity=value;
        return this;
    }
    QSoftBody * SetAreaPreservingEnabled(bool value){
        enableAreaPreserving=value;
        if(value==true){
            targetPreservationArea=GetTotalPolygonsInitialArea();
        }
        return this;
    }
 
    QSoftBody *SetTargetPreservationArea(float value){
        targetPreservationArea=value;
        return this;
    }
    QSoftBody *SetSelfCollisionsEnabled(bool value){
        enableSelfCollisions=value;
        return this;
    }
 
    QSoftBody *SetSelfCollisionsSpecifiedRadius(float value){
        selfCollisionParticleRadius=value;
        return this;
    }
 
    QSoftBody *SetPassivationOfInternalSpringsEnabled(bool value){
        enablePassivationOfInternalSprings=value;
        return this;
    }
    QSoftBody *SetShapeMatchingEnabled(bool value, bool withoutInternals=false){
        enableShapeMatching=value;
        ApplyShapeMatchingInternals=!withoutInternals;
        return this;
    }
 
    QSoftBody *SetShapeMatchingRate(float value){
        shapeMatchingRate=value;
        return this;
    }
 
    QSoftBody *SetShapeMatchingFixedTransformEnabled(bool value){
        enableShapeMatchingFixedTransform=value;
        shapeMatchingFixedPosition=GetPosition();
        shapeMatchingFixedRotation=GetRotation();
        return this;
    }
 
    QSoftBody *SetShapeMatchingFixedPosition(QVector value){
        shapeMatchingFixedPosition=value;
        return this;
    }
 
    QSoftBody *SetShapeMatchingFixedRotation(float value){
        shapeMatchingFixedRotation=value;
        return this;
    }
    QSoftBody *SetParticleSpesificMass(float value){
        particleSpesificMass=value;
        return this;
    }
 
    QSoftBody *SetParticleSpesificMassEnabled(bool value){
        enableParticleSpesificMass=value;
        return this;
    }
 
    //Properties Get Methods
    float GetMass(){
        if(enableParticleSpesificMass)
            return particleSpesificMass;
        else
            return mass;
    }
    float  GetRigidity(){
        return rigidity;
    };
    float  GetAreaPreservingRate(){
        return areaPreservingRate;
    };
    float  GetAreaPreservingRigidity(){
        return areaPreservingRigidity;
    };
    bool GetAreaPreservingEnabled(){
        return enableAreaPreserving;
    }
    float GetTargetPreservationArea(){
        return targetPreservationArea;
    }
    bool GetSelfCollisionsEnabled(){
        return enableSelfCollisions;
    }
    float GetSelfCollisionsSpecifiedRadius(){
        return selfCollisionParticleRadius;
    }
    bool GetPassivationOfInternalSpringsEnabled(){
        return enablePassivationOfInternalSprings;
    }
    bool GetShapeMatchingEnabled(){
        return enableShapeMatching;
    }
    
 
    float GetShapeMatchingRate(){
        return shapeMatchingRate;
    }
 
    bool GetShapeMatchingFixedTransformEnabled(){
        return enableShapeMatchingFixedTransform;
    }
 
    QVector GetShapeMatchingFixedPosition(){
        return shapeMatchingFixedPosition;
    }
 
    float GetShapeMatchingFixedRotation(){
        return shapeMatchingFixedRotation;
    }
 
    float GetParticleSpesificMass(){
        return particleSpesificMass;
    }
    bool GetParticleSpesificMassEnabled(){
        return enableParticleSpesificMass;
    }
 
    virtual QSoftBody* ApplyForce(QVector force) override;
 
 
    //
    virtual void Update();
    virtual void PostUpdate();
    void PreserveAreas();
    void ApplyShapeMatching();
 
    
 
};
 
#endif // QSOFTBODY_H