renderworld.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 RENDERWORLD_H
#define RENDERWORLD_H

#include "worldsimconfig.h"
#include "world.h"
#include "resourcesuser.h"
#include <QObject>
#include "qglviewer/qglviewer.h"
#include <QWidget>
#include <QVector>
#include <QMap>
#include <QString>
#include <QColor>
#include <QMutex>

namespace farsa {

class RenderWorld;
class PhyDOF;
class RenderWObjectContainer;

class FARSA_WSIM_API RenderWObject : public QObject {
    Q_OBJECT
public:
    RenderWObject( WObject* o, RenderWObjectContainer* container ) : obj(o) {
        this->contain = container;
    };
    virtual ~RenderWObject() { };
    virtual void render( QGLContext* gw ) = 0;
    virtual void renderAABB( RenderWorld* gw ) {
        UNUSED_PARAM( gw );
    };
    virtual void calculateAABB( wVector& minPoint, wVector& maxPoint, const wMatrix tm ) {
        UNUSED_PARAM( tm );
        //--- return the following points if in your case there is no meaningful AABB
        minPoint = wVector(0, 0, 0);
        maxPoint = wVector(0, 0, 0);
    };
    virtual void calculateOBB( wVector& dimension, wVector& minPoint, wVector& maxPoint ) {
        UNUSED_PARAM( dimension );
        //--- return the following points if in your case there is no meaningful OBB
        minPoint = wVector(0,0,0);
        maxPoint = wVector(0,0,0);
    };
    WObject* object() {
        return obj;
    };
    RenderWObjectContainer* container() {
        return contain;
    };
    virtual void objectAlreadyDestroyed()
    {
    }
    void drawLabel();
protected:
    WObject* obj;
    RenderWObjectContainer* contain;
};

class FARSA_WSIM_TEMPLATE WAbstractCreator {
public:
    virtual ~WAbstractCreator() { };
    virtual RenderWObject* create( WObject*, RenderWObjectContainer* container ) const = 0;
};

template<class T>
class FARSA_WSIM_TEMPLATE WCreator : public WAbstractCreator {
    virtual RenderWObject* create( WObject* wobj, RenderWObjectContainer* container ) const {
        return ( new T(wobj, container) );
    };
};

class FARSA_WSIM_API RenderWObjectContainer : public ConcurrentResourcesUser {
public:
    RenderWObjectContainer( QString wResName = "world" );
    virtual ~RenderWObjectContainer();
    const QVector<RenderWObject*> graphics() {
        return graphs;
    };
    void setWorld( World* newworld );
    QImage textureImage( QString texture ) {
        return (*textmap)[texture];
    };
    static bool addTextureImage( QString filename, QString texturename );
    RenderWObject* operator[]( const WObject* );
    static RenderWObject* createRenderWObjectFor( const WObject*, RenderWObjectContainer* );
    template<class renderwobject>
    static void registerRenderWObjectFor( QString classname ) {
        initFactory();
        (*fac)[classname] = new WCreator<renderwobject>();
    };
    void applyTexture( QGLContext* gw, QString texts );
    void setupColorTexture( QGLContext*, RenderWObject* obj );
    void drawSkyGroundBox( QGLContext* );
    static void drawSphere( wVector pos, real radius );
    static void drawCylinder( wVector axis, wVector centre, float len, float radius, QColor c = Qt::green );
    static void drawCylinder( wVector start, wVector end, float radius, QColor c = Qt::green );
    static void drawCylinder( const wMatrix& mat, float len, float radius, QColor c = Qt::green );
    static void drawCone( const wMatrix& mat, float len, float radius, QColor c = Qt::green );
    static void drawArrow( const wVector& direction, const wVector& start, float radius, float tipRadius, float tipLength, QColor c = Qt::green );
    static void drawWireBox( wVector dims, wMatrix matrix );
    static void drawWireBox( wVector min, wVector max, const wMatrix& tm );
    static void drawWireBox( wVector min, wVector max );
    static void drawTorus( real outRad, real innRad, const wMatrix& mat, real angle = 2.0*PI_GRECO, QColor c=Qt::red );
    static void drawTorus( wVector axis, wVector centre, real outRad, real innRad, real angle = 2.0*PI_GRECO );
protected:
    World* world() {
        return worldv;
    };

    void addObject( WObject* );
    void removeObject( WObject* );

    virtual void resourceChanged(QString name, ResourceChangeType changeType);

    QMutex mutex;
private:
    static void initializeTextmap();
    const QString worldResourceName;
    World* worldv;
    QVector<RenderWObject*> graphs;
    static QMap<QString, WAbstractCreator*>* fac;
    static bool facInited;
    static void initFactory();
    static QMap<QString, QImage>* textmap;
    static unsigned int textmapRefCounter;
    static QMutex textmapMutex;
    QMap<QString, GLuint> textGLId;
    QImage skyb[6];
};

class FARSA_WSIM_API RenderWorld : public QGLViewer, public RenderWObjectContainer {
    Q_OBJECT
public:
    RenderWorld( QWidget* parent = NULL, QString wResName = "world" );
    virtual ~RenderWorld();
    void drawArrow( const wVector& from, const wVector& to, float radius=-1, int nbSubdivisions=12, QColor c = Qt::red );
    bool viewerStateRestoredFromFile() const { return m_viewerStateRestoredFromFile; }
public slots:
    void wireframe( bool b );
    void showSkyGround( bool b );
    void showObjects( bool b );
    void showJoints( bool b );
    void showAABBs( bool b );
    void showContacts( bool b );
    void showForces( bool b );
    void showLocalAxes( bool b );
    void showLabels( bool b );
    void showTimeAndStep( bool b );
    void contextMenu( const QPoint& );
private slots:
    void slotAddObject( WObject* );
    void slotRemoveObject( WObject* );
    void onWorldResize();
protected:
    virtual void init();
    virtual void draw();
    virtual void drawWithNames();
    virtual void postSelection(const QPoint& point);
    virtual void keyPressEvent(QKeyEvent *e);

    virtual void resourceChanged(QString name, ResourceChangeType changeType);

private:
    virtual void customEvent(QEvent* event);

    int currentSelected;

    void drawDOF( PhyDOF* dof, bool );
    void drawKineChains();

    bool wiref;
    bool showskygroundbox;
    bool showobjs;
    bool showjoints;
    bool showaabbs;
    bool showcontacts;
    bool showforces;
    bool showlocalaxes;
    bool showlabels;
    bool showtimeandstep;
    bool m_viewerStateRestoredFromFile;
};

} // end namespace farsa

#endif