collisionsolver.h

Go to the documentation of this file.

/* This file is part of StepCore library.
   Copyright (C) 2007 Vladimir Kuznetsov <ks.vladimir@gmail.com>

   StepCore library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   StepCore library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with StepCore; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef STEPCORE_COLLISIONSOLVER_H
#define STEPCORE_COLLISIONSOLVER_H

#include "object.h"
#include "world.h"
#include "vector.h"
#include "solver.h"

#define EIGEN_USE_NEW_STDVECTOR
#include <Eigen/StdVector>

namespace StepCore
{

class BasePolygon;
class Body;

struct Contact {
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    enum {
        Unknown = 0,    
        Separated,      
        Separating,     
        Contacted,      
        Colliding,      
        Intersected     
    };
    enum {
        UnknownType,
        PolygonPolygonType,
        PolygonDiskType,
        PolygonParticleType,
        DiskDiskType,
        DiskParticleType
    };
    int      type;          
    Body*    body0;         
    Body*    body1;         
    int      state;         
    double   distance;      
    Vector2d normal;        
    Vector2d normalDerivative; 
    int      pointsCount;   
    int      pointsState[2];
    Vector2d points[2];     
    double   vrel[2];       
    // Cached values from previous run
    // TODO: move it to GJK-specific derived struct
    int _w1[2];
};

class CollisionSolver : public Object
{
    STEPCORE_OBJECT(CollisionSolver)

public:
    CollisionSolver(): _toleranceAbs(0.001), _localError(0) {}
    virtual ~CollisionSolver() {}

    double toleranceAbs() const { return _toleranceAbs; }
    virtual void setToleranceAbs(double toleranceAbs) { _toleranceAbs = toleranceAbs; }
    double localError() const { return _localError; }

    //virtual int checkContact(Contact* contact) = 0;

    virtual int checkContacts(BodyList& bodies, bool collisions = false, int* count = NULL) = 0;
    
    virtual void getContactsInfo(ConstraintsInfo& info, bool collisions = false) = 0;

    // TODO: add errors
    virtual int solveCollisions(BodyList& bodies) = 0;

    virtual void resetCaches() {}

    virtual void bodyAdded(BodyList&, Body*) {}
    virtual void bodyRemoved(BodyList&, Body*) {}

public:
    enum {
        InternalError = Solver::CollisionError
    };

protected:
    double _toleranceAbs;
    //double _toleranceRel;
    double _localError;
};

typedef std::vector<Contact, Eigen::aligned_allocator<Contact> >
            ContactValueList;

class GJKCollisionSolver : public CollisionSolver
{
    STEPCORE_OBJECT(GJKCollisionSolver)

public:
    GJKCollisionSolver() : _contactsIsValid(false) {}

    // TODO: proper copying of the cache !
    GJKCollisionSolver(const GJKCollisionSolver& solver)
        : CollisionSolver(solver), _contactsIsValid(false) {}
    GJKCollisionSolver& operator=(const GJKCollisionSolver&) {
        _contactsIsValid = false; return *this; }

    /*
    enum {
        OK = 0,
        CollisionDetected = 4096,
        PenetrationDetected = 4097
    };*/

    int checkContacts(BodyList& bodies, bool collisions = false, int* count = NULL);
    void getContactsInfo(ConstraintsInfo& info, bool collisions = false);
    //int findClosestPoints(const BasePolygon* polygon1, const BasePolygon* polygon2);

    int solveCollisions(BodyList& bodies);
    //int solveConstraints(BodyList& bodies);

    void resetCaches();
    void bodyAdded(BodyList& bodies, Body* body);
    void bodyRemoved(BodyList& bodies, Body* body);

protected:
    int checkContact(Contact* contact);

    int checkPolygonPolygon(Contact* contact);
    int solvePolygonPolygon(Contact* contact);

    int checkPolygonParticle(Contact* contact);
    int solvePolygonParticle(Contact* contact);

    int checkPolygonDisk(Contact* contact);
    int solvePolygonDisk(Contact* contact);

    int checkDiskDisk(Contact* contact);
    int solveDiskDisk(Contact* contact);

    int checkDiskParticle(Contact* contact);
    int solveDiskParticle(Contact* contact);

    void addContact(Body* body0, Body* body1);
    void checkCache(BodyList& bodies);

protected:
    ContactValueList _contacts;
    bool             _contactsIsValid;
};

} // namespace StepCore

#endif