phyepuck.h

/********************************************************************************
 *  WorldSim -- library for robot simulations                                   *
 *  Copyright (C) 2012-2013                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Fabrizio Papi <erkito87@gmail.com>                                          *
 *                                                                              *
 *  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 PHYEPUCK_H
#define PHYEPUCK_H

#include "worldsimconfig.h"
#include "wvector.h"
#include "wmatrix.h"
#include "world.h"
#include "motorcontrollers.h"
#include "sensorcontrollers.h"
#include "graphicalwobject.h"
#include "phycylinder.h"
#include <QVector>

namespace farsa {
    class PhyObject;
    class PhyJoint;
    class PhyCylinder;

    class FARSA_WSIM_API PhyEpuck : public WObject {
        Q_OBJECT

    public:
        static const real batteryplacex;

        static const real batteryplacey;

        static const real batteryplacez;

        static const real batterym;

        static const real batteryplacedistancefromground;

        static const real bodyr;

        static const real bodyh;

        static const real wholebodym;

        static const real wheelr;

        static const real wheelh;

        static const real wheelm;

        static const real axletrack;

        static const real passivewheelr;

        static const real passivewheelm;

    public:
        PhyEpuck(World* world, QString name, const wMatrix& transformation = wMatrix::identity());

        virtual ~PhyEpuck();

        WheelMotorController* wheelsController()
        {
            return m_wheelsCtrl;
        }

        SimulatedIRProximitySensorController* proximityIRSensorController()
        {
            return m_proximityIR;
        }

        SimulatedIRGroundSensorController* groundIRSensorController()
        {
            return m_groundIR;
        }

        virtual void preUpdate();

        virtual void postUpdate();

        void setProximityIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

        void setGroundIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

        void setDrawFrontMarker(bool drawMarker);

        bool getDrawFrontMarker() const;

        void doKinematicSimulation(bool k);

        bool isKinematic() const
        {
            return m_kinematicSimulation;
        }

        void setLedColors(QList<QColor> c, QColor upperBaseColor = QColor());

        QList<QColor> ledColors() const;

        const QList<PhyCylinder::SegmentColor>& segmentsColor() const;


    protected slots:
        void setLeftWheelDesideredVelocity(real velocity);

        void setRightWheelDesideredVelocity(real velocity);

    protected:
        virtual void changedMatrix();

    private:
        PhyObject* m_body;

        PhyCylinder* m_turret;

        QVector<PhyObject*> m_wheels;

        QVector<wMatrix> m_wheelsTransformation;

        QVector<PhyJoint*> m_wheelJoints;

        WheelMotorController* m_wheelsCtrl;

        SimulatedIRProximitySensorController* m_proximityIR;

        SimulatedIRGroundSensorController* m_groundIR;

        bool m_kinematicSimulation;

        real m_leftWheelVelocity;

        real m_rightWheelVelocity;

        GraphicalWObject* m_frontMarker;

        QList<QColor> m_ledColors;

        mutable QList<PhyCylinder::SegmentColor> m_uniformColor;
    };
} // end namespace farsa

#endif