PhysicalEngine.h

Go to the documentation of this file.

/*
    Enki - a fast 2D robot simulator
    Copyright (C) 1999-2016 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://home.gna.org/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:
            void deleteIfRequired() { if (deletedWithObject) delete this; }
            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;
        
        // 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 applyTransformation(const Matrix22& rot, const Point& trans, double* radius);
            
            // getters
            inline double getHeight() const { return height; }
            inline double getArea() const { return area; }
            inline const Polygone& getShape() const { return shape; }
            inline const Polygone& getTransformedShape() const { return transformedShape; }
            inline const Point& getCentroid() const { return centroid; }
            inline const Point& getTransformedCentroid() const { return transformedCentroid; }
            inline const Textures& getTextures() const { return textures; }
            inline bool isTextured() const { return !textures.empty(); }
            
        private:
            friend class PhysicalObject;
            // geometrical properties
            
            double height;
            double area;
            Polygone shape;
            Polygone transformedShape;
            Point centroid;
            Point transformedCentroid;
            
            // visual properties
            
            Textures textures;
        
        private:
            void computeAreaAndCentroid();
            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;
            Hull operator+(const Hull& that) const;
            Hull& operator+=(const Hull& that);
            void applyTransformation(const Matrix22& rot, const Point& trans, double* radius = 0);
        };
        
    private:        // variables
        
        // Physics
        
        Vector posBeforeCollision;
        
        double interlacedDistance;
        
        // mass and inertia tensor
        
        double mass;
        double momentOfInertia;
        
        // Geometry
        
        Hull hull;
        double r;
        double height;
        Color color;
        
    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 getMass() const { return mass; }
        inline double getMomentOfInertia() const { return momentOfInertia; }
        inline double getInterlacedDistance() const { return interlacedDistance; }
        
        // 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);

        enum ButtonCode
        {
            LEFT_MOUSE_BUTTON = 1<<0,
            RIGHT_MOUSE_BUTTON = 1<<1,
            MIDDLE_MOUSE_BUTTON = 1<<3
        };
        virtual void clickedInteraction(bool pressed, unsigned int buttonCode, double pointX, double pointY, double pointZ){};
        
    private:        // setup methods
        
        void dirtyUserData();
        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 collisionEvent(PhysicalObject *o) {}
        
        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 color;
        
        struct GroundTexture
        {
            unsigned width;
            unsigned height;
            std::vector<uint32_t> data;
            
            GroundTexture();
            GroundTexture(unsigned width, unsigned height, const uint32_t* data);
        };
        
        const GroundTexture groundTexture;
        
        typedef std::set<PhysicalObject *> Objects;
        typedef Objects::iterator ObjectsIterator;
        
        Objects objects;
        BluetoothBase* bluetoothBase;

    protected:
        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, const GroundTexture& groundTexture = GroundTexture());
        World(double r, const Color& wallsColor = Color::gray, const GroundTexture& groundTexture = GroundTexture());
        World();
        virtual ~World();
        
        bool hasGroundTexture() const;
        Color getGroundColor(const Point& p) const;
        
        virtual 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();
        
        static void takeObjectOwnership(bool doTake);
    
    protected:
        virtual void controlStep(double dt) { }
    };
    
    extern FastRandom random;
}

#endif