enki/PhysicalEngine.h

Go to the documentation of this file.

/*
    Enki - a fast 2D robot simulator
    Copyright (C) 1999-2008 Stephane Magnenat <stephane at magnenat dot net>
    Copyright (C) 2004-2005 Markus Waibel <markus dot waibel at epfl dot ch>
    Copyright (c) 2004-2005 Antoine Beyeler <abeyeler at ab-ware dot com>
    Copyright (C) 2005-2006 Laboratory of Intelligent Systems, EPFL, Lausanne
    Copyright (C) 2006-2008 Laboratory of Robotics Systems, EPFL, Lausanne
    See AUTHORS for details

    This program is free software; the authors of any publication 
    arising from research using this software are asked to add the 
    following reference:
    Enki - a fast 2D robot simulator
    http://lis.epfl.ch/enki
    Stephane Magnenat <stephane at magnenat dot net>,
    Markus Waibel <markus dot waibel at epfl dot ch>
    Laboratory of Intelligent Systems, EPFL, Lausanne.

    You can redistribute this program 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __ENKI_PHYSICALENGINE_H
#define __ENKI_PHYSICALENGINE_H

#include "Geometry.h"
#include "Types.h"
#include "Random.h"
#include "Interaction.h"
#include "BluetoothBase.h"
#include <iostream>
#include <set>
#include <vector>
#include <valarray>



namespace Enki
{
    class World;


    class PhysicalObject
    {
        friend class World;
        
    public:         // inner classes
        
        // User data
        
        class UserData
        {
        public:
            bool deletedWithObject; 
            
        public:
            virtual ~UserData() {}
        };
        
        UserData *userData;
        
        // Physics
        
        // physical constant
        static const double g;
        
        // physical parameters constants
        
        double collisionElasticity;
        double dryFrictionCoefficient;
        double viscousFrictionCoefficient;
        double viscousMomentFrictionCoefficient;
        
        // physics state variables
        
        // space coordinates
        
        Point pos;
        double angle;
        
        // space coordinates derivatives
        
        Vector speed;
        double angSpeed;
        
        // space coordinates double-derivatives
        
        /*
        The only accelerations we have for now are friction and are computed inside PhysicalObject::step()
        Both collisions and forces due to wheels of differential wheeled robots are computed instantly
        
        Vector acc;
        double angAcc;
        
        double staticFrictionThreshold;
        */
        
        // Geometry
        
        class Part
        {
        public:
            Part(const Polygone& shape, double height);
            Part(const Polygone& shape, double height, const Textures& textures);
            Part(double l1, double l2, double height);
            
            void updateRadius(double& radius);
            
            // getters
            inline double getHeight() const { return height; }
            inline const Polygone& getShape() const { return shape; }
            inline const Polygone& getTransformedShape() const { return transformedShape; }
            inline const Textures& getTextures() const { return textures; }
            inline bool isTextured() const { return !textures.empty(); }
            
        private:
            friend class PhysicalObject;
            // geometrical properties
            
            double height;
            Polygone shape;
            Polygone transformedShape;
            
            // visual properties
            
            Textures textures;
        
        private:
            void computeTransformedShape(const Matrix22& rot, const Point& trans);
        };
        
        struct Hull:std::vector<Part>
        {
            Hull() {}
            Hull(const Part& part) : std::vector<Part>(1, part) {}
            Polygone getConvexHull() const;
        };
        
    private:        // variables
        
        // Physics
        
        // mass and inertia tensor
        
        double mass;
        double momentOfInertia;
        
        // Geometry
        
        Hull hull;
        double r;
        double height;
        Color color;
        double infraredReflectiveness;
        
    public:         // methods
        
        PhysicalObject();
        virtual ~PhysicalObject();
        
        // getters
        
        inline double getRadius() const { return r; }
        inline double getHeight() const { return height; }
        inline bool isCylindric() const { return hull.empty(); }
        inline const Hull& getHull() const { return hull; }
        inline const Color& getColor() const { return color; }
        inline double getInfraredReflectiveness() const { return infraredReflectiveness; }
        inline double getMass() const { return mass; }
        inline double getMomentOfInertia() const { return momentOfInertia; }
        
        // setters
        
        void setCylindric(double radius, double height, double mass);
        void setRectangular(double l1, double l2, double height, double mass);
        void setCustomHull(const Hull& hull, double mass);
        void setColor(const Color &color);
        void setInfraredReflectiveness(double value);

    private:        // setup methods
        
        void computeMomentOfInertia();
        void setupCenterOfMass();
        void computeTransformedShape();
    
    protected:      // physical actions
        
        /*//! A physics simulation step for this object. It is considered as deinterlaced. The position and orientation are updated.
        virtual void physicsStep(double dt);*/
        virtual void controlStep(double dt) { }
        virtual void applyForces(double dt);

        
        virtual void initLocalInteractions(double dt, World* w) { }
        virtual void doLocalInteractions(double dt, World *w, PhysicalObject *o) { }
        virtual void doLocalWallsInteraction(double dt, World* w) { }
        virtual void finalizeLocalInteractions(double dt, World* w) { }

        virtual void initGlobalInteractions(double dt, World* w) { }
        virtual void doGlobalInteractions(double dt, World* w) { }
        virtual void finalizeGlobalInteractions(double dt, World* w) { }

    private:        // physical actions
        
        void initPhysicsInteractions(double dt);
        void finalizePhysicsInteractions(double dt);
        
        void collideWithStaticObject(const Vector &n, const Point &cp);
        void collideWithObject(PhysicalObject &that, const Point &cp, const Vector &dist);
    };


    class Robot: public PhysicalObject
    {
    protected:
        std::vector<LocalInteraction *> localInteractions;
        std::vector<GlobalInteraction *> globalInteractions;
        
    public:
        void addLocalInteraction(LocalInteraction *li);
        void addGlobalInteraction(GlobalInteraction *gi) {globalInteractions.push_back(gi);}
        virtual void initLocalInteractions(double dt, World* w);
        virtual void doLocalInteractions(double dt, World *w, PhysicalObject *po);
        virtual void doLocalWallsInteraction(double dt, World* w);
        virtual void finalizeLocalInteractions(double dt, World* w);
        
        virtual void doGlobalInteractions(double dt, World* w);
        void sortLocalInteractions(void);
    };


    class World
    {
    public:
        enum WallsType
        {
            WALLS_SQUARE = 0,   
            WALLS_CIRCULAR,     
            WALLS_NONE          
        };
        
        const WallsType wallsType;
        const double w;
        const double h;
        const double r;
        /* Texture of world walls is disabled now, re-enable a proper support if required
        Texture wallTextures[4];*/
        const Color wallsColor;
        
        typedef std::set<PhysicalObject *> Objects;
        typedef Objects::iterator ObjectsIterator;
        
        Objects objects;
        BluetoothBase* bluetoothBase;

        void collideCircleWithShape(PhysicalObject *circularObject, PhysicalObject *shapedObject, const Polygone &shape);
        void collideObjects(PhysicalObject *object1, PhysicalObject *object2);
        void collideWithSquareWalls(PhysicalObject *object);
        void collideWithCircularWalls(PhysicalObject *object);
        bool isPointInside(const Point &p, const Point &c, const Polygone &bs, Vector *distVector);

    public:
        World(double width, double height, const Color& wallsColor = Color::gray);
        World(double r, const Color& wallsColor = Color::gray);
        World();
        ~World();
        
        void step(double dt, unsigned physicsOversampling = 1);
        void addObject(PhysicalObject *o);
        void removeObject(PhysicalObject *o);
        void disconnectExternalObjectsUserData();
        void setRandomSeed(unsigned long seed);
        void initBluetoothBase();
        BluetoothBase* getBluetoothBase();
    };
    
    extern FastRandom random;
}

#endif

---