C:/Users/Marc/Desktop/Phystank/trunk/src/game/ComplexPhysicalComponent.h

//This file is part of PhysTank.
//
//PhysTank 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 3 of the License, or
//(at your option) any later version.
//
//PhysTank 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 PhysTank.  If not, see <http://www.gnu.org/licenses/>.
//
// © Marc Johnson, 2009

#ifndef _COMPLEXPHYSICALCOMPONENT_
#define _COMPLEXPHYSICALCOMPONENT_

#include <iostream>
#include <map>

#include "contrib/box2d/Include/box2d.h"

#include "game/CollisionHullFactory.h"
#include "game/ModelCollisionHull.h"
#include "game/PhysicalComponent.h"
#include "game/Physics.h"

#include "util/Vector2.h"

class BaseCollisionHull;

//Horribly inefficient.
struct JointDefs
{
        DistanceJoint _distanceDef;
        RevoluteJoint _revoluteDef;
        PrismaticJoint _prismaticDef;
        PulleyJoint _pulleyDef;
        GearJoint _gearDef;
};

struct Constraint
{
        b2Joint* _pJoint;
        JointDefs _defs;
        std::string _body1;
        std::string _body2;
};

std::ostream & operator<<(std::ostream & os, const Constraint & constraint);

typedef std::map<std::string, Constraint> ConstraintMap;

struct BodyPart
{
        b2Body* _pBody; 
        BaseCollisionHullPtr _pCollisionHull; 
        ConstraintMap _constraints; 
        std::string _name; 
        b2BodyDef _bodyDef; 
};

std::ostream & operator<<(std::ostream & os, const BodyPart & bp);

typedef std::map<std::string, BodyPart> BodyPartMap;

class ComplexPhysicalComponent : public PhysicalComponent
{
private:
        BodyPartMap m_bodyParts; 
        ConstraintMap m_constraints; 
        std::string m_mainPart; 
        bool m_bLocalCollisions;
public:
        DEFAULT_COMPONENT_CONSTRUCTOR(PhysicalComponent, ComplexPhysicalComponent, INIT1(m_bLocalCollisions, false) , ,);

        virtual ~ComplexPhysicalComponent();

        virtual void Update(const int nDelta);
        virtual void ToStream(std::ostream & stream) const;
        virtual void FromStream(std::istream & stream);

        virtual bool FromAttribute(const Attribute* pRoot);

        const std::string & GetMainPart() const { return m_mainPart; }

        template<class T>
        boost::shared_ptr<T> CreateCollisionHull(const std::string & type);

        void ConstructBodyPart(const std::string & name, const Vector2 & position, float fRotation, float fMass, float fLinearDamping, float fAngularDamping, bool bFixRotation, bool bBullet, bool bIsMain, BaseCollisionHullPtr pCollisionHull);
        
        void TurnOnLocalCollisions();
        void TurnOffLocalCollisions();

        bool GetBodyPart(const std::string& name, BodyPart** pBodyPartOut);
        bool RemoveBodyPart(const std::string& name);

        bool ConstructDistanceConstraint(const std::string & name, const std::string& body1, const std::string& body2, const DistanceJoint& jointInfo);
        bool ConstructRevoluteConstraint(const std::string & name, const std::string& body1, const std::string& body2, const RevoluteJoint& jointInfo);
        bool ConstructPrismaticConstraint(const std::string & name, const std::string& body1, const std::string& body2, const PrismaticJoint& jointInfo);
        bool ConstructPulleyConstraint(const std::string & name, const std::string& body1, const std::string& body2, const PulleyJoint& jointInfo);
        bool ConstructGearConstraint(const std::string & name, const std::string& body1, const std::string& body2, const GearJoint& jointInfo);

        bool GetConstraint(const std::string& name, Constraint** ppConstraintOut);
        bool RemoveConstraint(const std::string& name);
};

template<class T>
boost::shared_ptr<T> ComplexPhysicalComponent::CreateCollisionHull(const std::string & type)
{
        T* pHull = CollisionHullFactoryCreate<T>(type);

        if(pHull)
        {
                pHull->SetResourceCache(GET_RESOURCE_CACHE);
                return boost::shared_ptr<T>(pHull);
        }

        return boost::shared_ptr<T>();
}

REGISTER_COMPONENT(ComplexPhysicalComponent, "component_complexphysics", "physics");

#endif

---