worldsim/include/world.h

/********************************************************************************
 *  WorldSim -- library for robot simulations                                   *
 *  Copyright (C) 2008-2011 Gianluca Massera <emmegian@yahoo.it>                *
 *                                                                              *
 *  This program 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.                                         *
 *                                                                              *
 *  This program 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 this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef WORLD_H
#define WORLD_H

#include "worldsimconfig.h"
#include "wvector.h"
#include "wmatrix.h"
#include "wquaternion.h"
#include "ownable.h"
#include <QString>
#include <QHash>
#include <QSet>
#include <QList>
#include <QLinkedList>
#include <QVector>
#include <QPair>
#include <QEvent>
#include <QTimerEvent>
#include <QColor>

namespace farsa {

class World;
class WorldPrivate;
class PhyObject;
class PhyJoint;
class MotorController;

//--- this function is required by QSet<NObj> attribute of World class
inline uint qHash( const QPair<PhyObject*, PhyObject*>& pair ) {
#ifdef _LP64
    return ( ::qHash( (long int)(pair.first) ) );
#else
    return ( ::qHash( (int)(pair.first) ) );
#endif
}

class FARSA_WSIM_API WObject : public QObject, public Ownable {
    Q_OBJECT
public:
    WObject( World* world, QString name="unamed", const wMatrix& tm = wMatrix::identity(), bool addToWorld = true );
    virtual ~WObject();
    const wMatrix& matrix() const {
        return tm;
    };
    void setPosition( const wVector& newpos ) {
        tm.w_pos = newpos;
        changedMatrix();
    };
    void setPosition( real x, real y, real z ) {
        tm.w_pos = wVector(x,y,z);
        changedMatrix();
    };
    World* world() {
        return worldv;
    };
    const World* world() const {
        return worldv;
    };
    QString name() const {
        return namev;
    };
    void setTexture( QString textureName ) {
        texturev = textureName;
    };
    QString texture() const {
        return texturev;
    };
    void setColor( QColor c ) {
        colorv = c;
    };
    void setAlpha( int alpha ) {
        colorv.setAlpha( alpha );
    };
    QColor color() const {
        return colorv;
    };
    bool useColorTextureOfOwner() {
        return usecolortextureofowner;
    };
    void setUseColorTextureOfOwner( bool b ) {
        usecolortextureofowner = b;
    };
    virtual void preUpdate() {
        /* nothing to do */
    };
    virtual void postUpdate() {
        /* nothing to do */
    };
    void setMatrix( const wMatrix& newm ) {
        tm = newm;
        changedMatrix();
    };
    bool isInvisible() {
        return invisible;
    };
    void setInvisible( bool b ) {
        invisible = b;
    };
protected:
    virtual void changedMatrix() {
        /* nothing to do here */;
    };
    World* worldv;
    wMatrix tm;
    QString namev;
    QString texturev;
    QColor colorv;
    bool invisible;
    bool usecolortextureofowner;
};

class FARSA_WSIM_API MaterialDB {
public:
    World* world() {
        return worldv;
    };

    bool createMaterial( QString name );
    
    void setFrictions( QString mat1, QString mat2, real st, real kn );

    void setElasticity( QString mat1, QString mat2, real );

    void setSoftness( QString mat1, QString mat2, real );
    void setGravityForce( QString mat, real force );
    real gravityForce( QString mat );

    void enableCollision( QString mat1, QString mat2, bool enable = true );

    void setProperties( QString mat1, QString mat2, real fs, real fk, real el, real sf, bool en = true );

private:
    MaterialDB( World* );
    class materialPairInfo {
    public:
        real staticFriction;
        real dynamicFriction;
        real elasticity;
        real softness;
        bool collisions;
    };
    QSet<QString> mats;
    QMap<QString, real> gravities;

    QHash<QString, materialPairInfo> pmap;

    QString createKey( QString mat1, QString mat2 );

    World* worldv;
    friend class World;
};


class FARSA_WSIM_TEMPLATE Contact {
public:
    PhyObject* object;
    PhyObject* collide;
    wVector pos;
    wVector worldPos;
};

typedef QVector<Contact> contactVec;
typedef QHash<PhyObject*, contactVec> contactMap;
typedef QHashIterator<PhyObject*, contactVec> contactMapIterator;


class FARSA_WSIM_TEMPLATE RayCastHit {
public:
    PhyObject* object;
    real distance;
    wVector position;
    wVector normal;
};

typedef QVector<RayCastHit> rayCastHitVector;

class FARSA_WSIM_API World : public QObject {
    Q_OBJECT
public:
    World( QString worldname, bool LocalYarpPorts=false );
    virtual ~World();
    QString name() const;
    real elapsedTime() const;
    void resetElapsedTime();
    void setTimeStep( real );
    void setMinimumFrameRate( unsigned int frames );
    void setIsRealTime( bool b );
    bool isRealTime() const;
    real timeStep() const;
    void setGravityForce( real g );
    real gravityForce() const;
    const QLinkedList<WObject*> objects();
    WObject* getObject( QString name );
    const QLinkedList<PhyJoint*> joints();
    const QHash<WObject*, QList<PhyJoint*> > mapObjectsToJoints();

    void advanceUntil( real time );

    void disableCollision( PhyObject* obj1, PhyObject* obj2 );
    void enableCollision( PhyObject* obj1, PhyObject* obj2 );
    const contactMap& contacts();
    bool closestPoints( PhyObject* objA, PhyObject* objB, wVector& pointA, wVector& pointB );
    bool checkContacts( PhyObject* obj1, PhyObject* obj2, int maxContacts = 4, QVector<wVector>* contacts = NULL, QVector<wVector>* normals = NULL, QVector<real>* penetra = NULL );
    bool smartCheckContacts( PhyObject* obj1, PhyObject* obj2, int maxContacts = 4, QVector<wVector>* contacts = NULL );
    real collisionRayCast( PhyObject* obj, wVector start, wVector end, wVector* normal = NULL );
    rayCastHitVector worldRayCast( wVector start, wVector end, bool onlyClosest, const QSet<PhyObject*>& ignoredObjs = QSet<PhyObject*>() );

    MaterialDB& materials() {
        return (*mats);
    };

    void setSolverModel( QString model );
    void setFrictionModel( QString model );
    void setMultiThread( int numThreads );
    void setSize( const wVector& minPoint, const wVector& maxPoint );
    void size( wVector &minPoint, wVector &maxPoint );

    void pushObject( WObject* );
    void popObject( WObject* );

    void pushJoint( PhyJoint* );
    void popJoint( PhyJoint* );
    enum w_state { playingS, pausedS, stoppedS };
    w_state status() {
        return state;
    };
    void cleanUpMemory();
public slots:
    void initialize();
    void advance();
    void finalize();
    int play();
    void pause();
    void stop();
signals:
    void initialized();
    void finished();
    void advanced();
    void paused();
    void stopped();
    void addedObject( WObject* );
    void addedJoint( PhyJoint* );
    void removedObject( WObject* );
    void removedJoint( PhyJoint* );
    void resized();
protected:
    real time;
    real timestepv;
    real gforce;
    wVector minP, maxP;
    QLinkedList<WObject*> objs;

    QLinkedList<PhyJoint*> jointsv;
    QHash<WObject*, QList<PhyJoint*> > mapObjJoints;

    void timerEvent( QTimerEvent* e );
    void customEvent( QEvent* e );
public:
    enum { E_Advance = 1200, E_Play = 1201, E_Stop = 1202, E_Pause = 1203 };
private:
    QString namev;

    contactMap cmap;

    typedef QPair<PhyObject*, PhyObject*> NObj;
    QSet<NObj> nobjs;

    MaterialDB* mats;
    friend class MaterialDB;

    SimpleTimer timer;
    bool isrealtimev;
    bool isInit;
    bool isFinish;
    w_state state;
    unsigned int timerId;

    WorldPrivate* priv;
    friend class PhyObject;
    friend class PhyJoint;
    friend class WorldPrivate;
};

} // end namespace farsa

#endif