qcollision.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 QCOLLISION_H
#define QCOLLISION_H
#include <iostream>
#include <vector>
#include "qparticle.h"
#include "qobjectpool.h"
 
 
class QWorld;
class QAABB;
using namespace std;
 
 
class QCollision
{
public:
    QCollision(){}
    ~QCollision();
 
    
 
 
    struct Contact{
    public:
        QVector position;
        QParticle *particle;
        QVector normal;
        float penetration;
        vector<QParticle*> referenceParticles;
        bool solved;
        Contact(QParticle *particle,QVector position,QVector normal,float penetration,vector<QParticle*> referenceParticles ){
            this->particle=particle;
            this->position=position;
            this->normal=normal;
            this->penetration=penetration;
            this->referenceParticles=referenceParticles;
            this->solved=false;
        }
 
        Contact(){
 
        }
 
        void Configure(QParticle *particle,QVector position,QVector normal,float penetration,vector<QParticle*> referenceParticles){
            this->particle=particle;
            this->position=position;
            this->normal=normal;
            this->penetration=penetration;
            this->referenceParticles=referenceParticles;
            this->solved=false;
        }
 
 
 
    };
 
    static QObjectPool<QCollision::Contact> contactPool;
 
    static QObjectPool<QCollision::Contact> &GetContactPool();
 
 
    struct Project{
        public:
            float min;
            float max;
            int minIndex;
            int maxIndex;
            Project(float projectMin,int minPointIndex,float projectMax,int maxPointIndex){
                min=projectMin;
                max=projectMax;
                minIndex=minPointIndex;
                maxIndex=maxPointIndex;
            }
            float Overlap(const Project other) const{
                float penetration=0.0f;
                if(other.min<min){
                    penetration=min-other.max;
                }else{
                    penetration=other.min-max;
                }
                return penetration;
            }
 
    };
 
    
 
    //Collision Methods
    static void PolygonAndPolygon(vector<QParticle*> &particlesA,vector<QParticle*> &particlesB,vector<QCollision::Contact*> &contacts);
    static void CircleAndPolygon(vector<QParticle*> &circleParticles,vector<QParticle*> &polygonParticles,vector<QCollision::Contact*> &contacts);
 
    
    static void CircleAndCircle(vector<QParticle*> &particlesA,vector<QParticle*> &particlesB, QAABB boundingBoxB, vector<QCollision::Contact*> &contacts, float specifiedRadius=0.0f, bool velocitySensitive=false);
    static void CircleAndCircleSelf(vector<QParticle*> &particles, vector<QCollision::Contact*> &contacts, float specifiedRadius=0.0f);
    static void PolylineAndPolygon(vector<QParticle*> &polylineParticles,vector<QParticle*> &polygonParticles,vector<QCollision::Contact*> &contacts);
 
    static void PolylineAndPolyline(vector<QParticle*> &testPolylineParticles,vector<QParticle*> &targetPolylineParticles,QAABB polylineAABB , vector<QCollision::Contact*> &contacts);
 
    static void CircleAndPolyline2(vector<QParticle*> &particles,vector<QParticle*> &polygonParticles,QAABB polylineAABB , vector<QCollision::Contact*> &contacts);
 
 
    //Geometry Helper Methods
    static QVector LineIntersectionLine(QVector d1A,QVector d1B, QVector d2A, QVector d2B);
    static bool PointInPolygon(QVector &point, vector<QParticle*> &polygon );
    static bool PointInPolygon(QVector &point, vector<QVector> &polygon );
    static bool PointInPolygon2(QVector point, vector<QParticle*> &polygon );
 
    
    
private:
 
    //Collision Helper Methods
    static void ClipContactParticles(QParticle *referenceParticles[], QParticle *incidentParticles[], vector<QCollision::Contact*> &contacts );
    static Project ProjectToAxis(QVector &normal,vector<QParticle*> &polygon);
    static vector<QVector> ParticlePolygonToPolygon(vector<QParticle*> particlePolygon);
    static pair<int,int> FindNearestSideOfPolygon(const QVector point, vector<QParticle*> polygonParticles,bool checkSideRange=false, bool checkNegativeDistance=false);
    static int FindNearestParticleOfPolygon(QParticle * particle, vector<QParticle*> polygonParticles);
    static int FindExtremeParticleOfAxis(vector<QParticle*> polygonParticles, QVector axisNormal);
    static bool PointInPolygonWN(const QVector point, vector<QParticle*> polygonParticles);
 
    
 
 
};
 
 
 
 
#endif // QCOLLISION_H