world.h

Go to the documentation of this file.

/* This file is part of StepCore library.
   Copyright (C) 2007 Vladimir Kuznetsov <ks.vladimir@gmail.com>

   StepCore library 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.

   StepCore library 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 StepCore; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef STEPCORE_WORLD_H
#define STEPCORE_WORLD_H

#include "types.h"
#include "util.h"
#include "object.h"
#include "vector.h"

#include <vector> // XXX: replace if QT is enabled
#include <QHash>

// TODO: split this file

namespace StepCore
{

class World;
class Solver;
class Item;
class ItemGroup;
class CollisionSolver;
class ConstraintSolver;

class ObjectErrors: public Object
{
    STEPCORE_OBJECT(ObjectErrors)

public:
    ObjectErrors(Item* owner = NULL): _owner(owner) {}

    Item* owner() const { return _owner; }
    void setOwner(Item* owner) { _owner = owner; }

private:
    Item* _owner;
};

class Item : public Object
{
    /*Q_OBJECT*/
    STEPCORE_OBJECT(Item)

public:
    Item(const QString& name = QString())
        : Object(name), _world(NULL), _group(NULL),
          _objectErrors(NULL), _color(0xff000000) {}
    Item(const Item& item) : Object() { *this = item; }
    virtual ~Item() { delete _objectErrors; }

    Item& operator=(const Item& item);

    virtual void setWorld(World* world) { _world = world; }

    World* world() const { return _world; }

    virtual void setGroup(ItemGroup* group) { _group = group; }

    ItemGroup* group() const { return _group; }

    ObjectErrors* tryGetObjectErrors() const { return _objectErrors; }

    ObjectErrors* objectErrors();

    void deleteObjectErrors() { delete _objectErrors; _objectErrors = NULL; }

    Color color() const { return _color; }

    void setColor(Color color) { _color = color; }

    virtual void worldItemRemoved(Item* item STEPCORE_UNUSED) {}

protected:
    virtual ObjectErrors* createObjectErrors() { return NULL; } // XXX: rename to createObjectVariances

private:
    World*        _world;
    ItemGroup*    _group;
    ObjectErrors* _objectErrors;
    Color         _color;
};

class Body
{
    STEPCORE_OBJECT(Body)

public:
    Body(): _variablesOffset(0) {}
    virtual ~Body() {}

    virtual int  variablesCount() = 0;

    virtual void setVariables(const double* position, const double* velocity,
               const double* positionVariance, const double* velocityVariance) = 0;

    virtual void getVariables(double* position, double* velocity,
                     double* positionVariance, double* velocityVariance) = 0;

    virtual void addForce(const double* force, const double* forceVariance) = 0;

    virtual void resetForce(bool resetVariance) = 0;

    virtual void getAccelerations(double* acceleration, double* accelerationVariance) = 0;

    virtual void getInverseMass(VectorXd* inverseMass,
                                DynSparseRowMatrix* variance, int offset) = 0;
    
    int variablesOffset() const { return _variablesOffset; }

private:
    friend class World;

    void setVariablesOffset(int variablesOffset) {
        _variablesOffset = variablesOffset;
    }

    int _variablesOffset;
};

class Force
{
    STEPCORE_OBJECT(Force)

public:
    virtual ~Force() {}

    virtual void calcForce(bool calcVariances) = 0;
};

struct ConstraintsInfo
{
    int                variablesCount;      
    int                constraintsCount;    
    int                contactsCount;       

    VectorXd           value;               
    VectorXd           derivative;          
    DynSparseRowMatrix jacobian;            
    DynSparseRowMatrix jacobianDerivative;  
    VectorXd           inverseMass;         

    MappedVector       position;            
    MappedVector       velocity;            
    MappedVector       acceleration;        

    VectorXd           forceMin;            
    VectorXd           forceMax;            

    VectorXd           force;               

    bool               collisionFlag;       

    ConstraintsInfo(): variablesCount(0), constraintsCount(0), contactsCount(0),
                       position(0,0), velocity(0,0), acceleration(0,0) {}

    void setDimension(int newVariablesCount, int newConstraintsCount, int newContactsCount = 0);

    void clear();

private:
    ConstraintsInfo(const ConstraintsInfo&);
    ConstraintsInfo& operator=(const ConstraintsInfo&);
};

class Joint
{
    STEPCORE_OBJECT(Joint)

public:
    virtual ~Joint() {}

    virtual int constraintsCount() = 0;

    virtual void getConstraintsInfo(ConstraintsInfo* info, int offset) = 0;

#if 0

    virtual void getConstraints(double* value, double* derivative) = 0;

    virtual void getForceLimits(double* forceMin STEPCORE_UNUSED, double* forceMax STEPCORE_UNUSED) {}

    virtual void getJacobian(GmmSparseRowMatrix* value, GmmSparseRowMatrix* derivative, int offset) = 0;
#endif
};

class Tool
{
    STEPCORE_OBJECT(Tool)
public:
    virtual ~Tool() {}
};

typedef std::vector<Item*>  ItemList;
typedef std::vector<Body*>  BodyList;
typedef std::vector<Force*> ForceList;
typedef std::vector<Joint*> JointList;

class ItemGroup : public Item
{
    STEPCORE_OBJECT(ItemGroup)

public:
    ItemGroup(const QString& name = QString()) : Item(name) {}
    ItemGroup(const ItemGroup& group);
    ~ItemGroup();

    ItemGroup& operator=(const ItemGroup& group);

    const ItemList& items() const  { return _items; }

    ItemList allItems() const { ItemList l; allItems(&l); return l; }
    void allItems(ItemList* items) const;

    virtual void addItem(Item* item);
    virtual void removeItem(Item* item);
    virtual void deleteItem(Item* item) { removeItem(item); delete item; }

    void clear();

    int  childItemIndex(const Item* item) const;
    int  childItemCount() const { return _items.size(); }
    Item* childItem(int index) const { return _items[index]; }
    Item* childItem(const QString& name) const;
    Item* item(const QString& name) const;

    void setWorld(World* world);
    void worldItemRemoved(Item* item);
    
private:
    ItemList  _items;
};

class World : public ItemGroup
{
    /*Q_OBJECT*/
    STEPCORE_OBJECT(World)

public:
    World();
    World(const World& world);
    ~World();

    World& operator=(const World& world);


    void clear();

    double time() const { return _time; }
    void setTime(double t) { _time = t; }

    double timeScale() const { return _timeScale; }
    void setTimeScale(double timeScale) { _timeScale = timeScale; }

    bool errorsCalculation() const { return _errorsCalculation; }
    void setErrorsCalculation(bool errorsCalculation) {
        _errorsCalculation = errorsCalculation; }

    //void addItem(Item* item);
    //void removeItem(Item* item);
    //void deleteItem(Item* item) { removeItem(item); delete item; }
    //int  itemIndex(const Item* item) const;

    //Item* item(int index) const { return _items[index]; }
    //Item* item(const QString& name) const;
    Object* object(const QString& name);

    //const ItemList&  items() const  { return _items; }
    const BodyList&  bodies() const { return _bodies; }
    const ForceList& forces() const { return _forces; }
    const JointList& joints() const { return _joints; }

    Solver* solver() const { return _solver; }
    void setSolver(Solver* solver);
    Solver* removeSolver();

    CollisionSolver* collisionSolver() const { return _collisionSolver; }
    void setCollisionSolver(CollisionSolver* collisionSolver);
    CollisionSolver* removeCollisionSolver();

    ConstraintSolver* constraintSolver() const { return _constraintSolver; }
    void setConstraintSolver(ConstraintSolver* constraintSolver);
    ConstraintSolver* removeConstraintSolver();

    int doCalcFn();
    int doEvolve(double delta);
    
    bool evolveAbort() { return _evolveAbort; }
    void setEvolveAbort(bool evolveAbort = true) { _evolveAbort = evolveAbort; }

private:
    friend class ItemGroup;

    void fillCopyMap(QHash<const Object*, Object*>* map,
                        const ItemGroup* g1, ItemGroup* g2);
    void applyCopyMap(QHash<const Object*, Object*>* map, Object* obj);
    void worldItemCopied(QHash<const Object*, Object*>* map, Item* item);
    void worldItemAdded(Item* item);
    void worldItemRemoved(Item* item);

    void checkVariablesCount();

    void gatherAccelerations(double* acceleration, double* variance);

    void gatherVariables(double* variables, double* variances);

    void scatterVariables(const double* variables, const double* variances);

    void gatherJointsInfo(ConstraintsInfo* info);

    static int solverFunction(double t, const double* y, const double* yvar,
                                 double* f, double* fvar, void* params);
    int solverFunction(double t, const double* y, const double* yvar,
                                 double* f, double* fvar);

private:
    double    _time;
    double    _timeScale;
    bool      _errorsCalculation;

    //ItemList  _items;
    BodyList  _bodies;
    ForceList _forces;
    JointList _joints;

    Solver*           _solver;
    CollisionSolver*  _collisionSolver;
    ConstraintSolver* _constraintSolver;

    int             _variablesCount;  
    VectorXd    _variables;       
    VectorXd    _variances;       
    VectorXd    _tempArray;       
    ConstraintsInfo _constraintsInfo; 

    bool    _stopOnCollision;
    bool    _stopOnIntersection;
    bool    _evolveAbort;
};

} // namespace StepCore

#endif