PhysicalEngine.h

Go to the documentation of this file.

/*
    Enki - a fast 2D robot simulator
    Copyright (C) 1999-2005 Stephane Magnenat <stephane at magnenat dot net>
    Copyright (C) 2004-2005 Markus Waibel <markus dot waibel at epfl dot ch>
    Copyright (C) 2005 Laboratory of Intelligent 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 part of the Teem framework
    http://teem.epfl.ch
    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 __PHYSICALENGINE_H
#define __PHYSICALENGINE_H

#include <iostream>
#include <vector>
#include <valarray>
#include <an/Types.h>
#include <an/Geometry.h>
#include <an/Random.h>
#include "Interaction.h"


namespace Enki
{
    class World;


    class PhysicalObject
    {
    public:
        An::Point pos;
        double height;
        double angle;
        An::Vector speed;
        double angSpeed;
        double mass;
        double staticFrictionThreshold;
        double viscousFrictionTau;
        double viscousMomentFrictionTau;
        double collisionAngularFrictionFactor;
        const An::Polygone *boundingSurface;
        An::Polygone absBoundingSurface;
        double r;
        An::Color color;
        std::valarray<An::Texture> textures;
        
    protected:
        An::Vector deinterlaceVector;

        void collideWithStaticObject(const An::Vector &n);
        void computeAbsBoundingSurface(void);

    public:
        PhysicalObject();
        virtual ~PhysicalObject();
        
        void setBoundingSurface(const An::Polygone *bs);
        const An::Polygone &getTrueBoundingSurface(void) const { return absBoundingSurface; }

        // Physical Actions
        virtual void step(double dt);

        virtual void initLocalInteractions();
        virtual void doLocalInteractions(World *w, PhysicalObject *o, double dt, bool firstInteraction);
        virtual void doLocalWallsInteraction(World *w);
        virtual void finalizeLocalInteractions(double dt);

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

        void collideWithStaticObject(const An::Point &cp1, const An::Point &cp2, const An::Vector &n1, const An::Vector &n2, const An::Vector &dist);
        void collideWithObject(PhysicalObject &object, const An::Point &cp, const An::Vector &dist);
        
    };


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


    class World
    {
    protected:
        bool collideEven;

    public:
        std::vector<PhysicalObject *> objects;
        bool useWalls;
        const double w;
        const double h;
        An::Texture wallTextures[4];

        bool getCollideEven() {return collideEven;}
        void collideCircleWithBS(PhysicalObject *circle, PhysicalObject *objectBS, const An::Polygone &bs);
        void collideObjects(PhysicalObject *object1, PhysicalObject *object2);
        void collideWithWalls(PhysicalObject *object);
        bool isPointInside(const An::Point &p, const An::Point &c, const An::Polygone &bs, An::Vector *distVector);

    public:
        World(double width, double height);
        ~World();
        void step(double dt);
        void addObject(PhysicalObject *o);
        void removeObject(PhysicalObject *o);
        void setRandomSeed(unsigned long seed);
    };
    
    extern An::FastRandom random;
}

#endif

---