C:/Users/Marc/Desktop/Phystank/trunk/src/game/BaseCollisionHull.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 _BASECOLLISIONHULL_
#define _BASECOLLISIONHULL_

#include <boost/shared_ptr.hpp>

#include "contrib/xercesc/dom/DOM.hpp"

#include "game/BaseCollisionShape.h"
#include "game/CircleCollisionShape.h"
#include "game/PolygonCollisionShape.h"

#include "util/AbstractStreamedObject.h"
#include "util/Attribute.h"
#include "util/Macros.h"

#define DEFAULT_COLLISIONHULL_CONSTRUCTOR(class_name, initialization_list) \
        class_name##(const std::string & type) \
        :BaseCollisionHull(type) initialization_list \
        {\
        }

typedef std::vector<BaseCollisionShape*> CollisionShapeVector;

class ResourceCache;

class BaseCollisionHull : public AbstractStreamedObject
{
private:

        CollisionShapeVector m_shapes;

        ResourceCache* m_pResourceCache;

        std::string m_type;

protected:
        void PushShape(BaseCollisionShape* pShape);
        void ClearShapes();
public:
        BaseCollisionHull(const std::string & type)
        :m_type(type), m_pResourceCache(0)
        {
        }

        BaseCollisionHull(const std::string & type, ResourceCache* pResourceCache)
        :m_type(type), m_pResourceCache(pResourceCache)
        {
        }

        virtual ~BaseCollisionHull()
        {
                ClearShapes();
        }

        const CollisionShapeVector & GetShapes() const { return m_shapes; }
        
        void SetMaterial(const Material & material);

        ResourceCache* GetResourceCache() const { return m_pResourceCache; }
        void SetResourceCache(ResourceCache* pResourceCache) { m_pResourceCache = pResourceCache; }

        const std::string & GetType() const { return m_type; }

        template<class T>
        T* CreateShape(const COLLISIONSHAPETYPE type);

        virtual void ParseShapes() = 0;
        virtual bool FromAttribute(const Attribute * pRoot) = 0;

        virtual void ToStream(std::ostream& stream) const;
        virtual void FromStream(std::istream& stream);
};

typedef boost::shared_ptr<BaseCollisionHull> BaseCollisionHullPtr;

inline void BaseCollisionHull::SetMaterial(const Material & material)
{
        FOREACH2(CollisionShapeVector, i, m_shapes)
        {
                (*i)->SetMaterial(material);
        }
}

template<class T>
inline T* BaseCollisionHull::CreateShape(const COLLISIONSHAPETYPE type)
{
        BaseCollisionShape* pNewShape = 0;
        switch(type)
        {
        case COLLISIONSHAPETYPE_CIRCLE:
                {
                        pNewShape = new CircleCollisionShape();
                }
                break;
        case COLLISIONSHAPETYPE_POLYGON:
                {
                        pNewShape = new PolygonCollisionShape();
                }
                break;
        default:
                assert(false && "Invalid collision shape type!");
        }
        PushShape(pNewShape);
        return reinterpret_cast<T*>(pNewShape);
}


inline void BaseCollisionHull::PushShape(BaseCollisionShape* pShape)
{
        m_shapes.push_back(pShape);
}

inline void BaseCollisionHull::ClearShapes()
{
        FOREACH(CollisionShapeVector, i, m_shapes)
        {
                delete *i;
        }

        m_shapes.clear();
}

inline void BaseCollisionHull::ToStream(std::ostream& stream) const
{
        stream << m_shapes.size() << " ";

        FOREACH(CollisionShapeVector, i, m_shapes)
        {
                stream << (*i)->GetType() << " ";
                (*i)->ToStream(stream);
        }
}

inline void BaseCollisionHull::FromStream(std::istream& stream)
{
        ClearShapes();

        int nNumShapes = 0;
        stream >> nNumShapes;
        
        for(int i = 0; i < nNumShapes; ++i)
        {
                int nType = 0;
                stream >> nType;

                BaseCollisionShape* pNewShape = CreateShape<BaseCollisionShape>((COLLISIONSHAPETYPE)nType);

                pNewShape->FromStream(stream);
        }
}


#endif

---