D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/Collision/spCollisionGraph.hpp

Go to the documentation of this file.

/*
 * Collision graph header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_COLLISION_GRAPH_H__
#define __SP_COLLISION_GRAPH_H__


#include "Base/spStandard.hpp"
#include "SceneGraph/Collision/spCollisionSphere.hpp"
#include "SceneGraph/Collision/spCollisionCapsule.hpp"
#include "SceneGraph/Collision/spCollisionCylinder.hpp"
#include "SceneGraph/Collision/spCollisionCone.hpp"
#include "SceneGraph/Collision/spCollisionBox.hpp"
#include "SceneGraph/Collision/spCollisionPlane.hpp"
#include "SceneGraph/Collision/spCollisionMesh.hpp"
#include "SceneGraph/Collision/spCollisionMaterial.hpp"
#include "SceneGraph/Collision/spCharacterController.hpp"

#include <boost/function.hpp>


namespace sp
{
namespace scene
{


typedef boost::function<bool (const CollisionNode* Node)> IntersectionCriteriaCallback;


class SP_EXPORT CollisionGraph
{
    
    public:
        
        CollisionGraph();
        virtual ~CollisionGraph();
        
        /* === Functions === */
        
        virtual CollisionMaterial* createMaterial();
        virtual void deleteMaterial(CollisionMaterial* Material);
        
        virtual void addCollisionNode(CollisionNode* Node);
        virtual void removeCollisionNode(CollisionNode* Node);
        
        virtual CollisionSphere* createSphere(CollisionMaterial* Material, scene::SceneNode* Node, f32 Radius);
        virtual CollisionCapsule* createCapsule(CollisionMaterial* Material, scene::SceneNode* Node, f32 Radius, f32 Height);
        //...
        virtual CollisionCylinder* createCylinder(CollisionMaterial* Material, scene::SceneNode* Node, f32 Radius, f32 Height);
        //...
        virtual CollisionCone* createCone(CollisionMaterial* Material, scene::SceneNode* Node, f32 Radius, f32 Height);
        virtual CollisionBox* createBox(CollisionMaterial* Material, scene::SceneNode* Node, const dim::aabbox3df &Box);
        virtual CollisionPlane* createPlane(CollisionMaterial* Material, scene::SceneNode* Node, const dim::plane3df &Plane);
        virtual CollisionMesh* createMesh(CollisionMaterial* Material, scene::Mesh* Mesh, u8 MaxTreeLevel = DEF_KDTREE_LEVEL);
        virtual CollisionMesh* createMeshList(CollisionMaterial* Material, const std::list<Mesh*> &MeshList, u8 MaxTreeLevel = DEF_KDTREE_LEVEL);
        
        virtual bool deleteNode(CollisionNode* Node);
        
        virtual CharacterController* createCharacterController(
            CollisionMaterial* Material, scene::SceneNode* Node, f32 Radius, f32 Height
        );
        virtual bool deleteCharacterController(CharacterController* Object);
        
        virtual void clearScene(
            bool isDeleteNodes = true, bool isDeleteMaterials = true, bool isDeleteCharacters = true
        );
        
        virtual bool checkIntersection(
            const dim::line3df &Line, bool ExcludeCorners = false, const IntersectionCriteriaCallback &CriteriaCallback = 0
        ) const;
        
        virtual void findIntersections(
            const dim::line3df &Line, std::list<SIntersectionContact> &ContactList,
            bool SearchBidirectional = false, const IntersectionCriteriaCallback &CriteriaCallback = 0
        ) const;
        
        virtual void updateScene();
        
        /* === Static functions === */
        
        static void sortContactList(
            const dim::vector3df &LineStart, std::list<SIntersectionContact> &ContactList
        );
        
        /* === Inline functions === */
        
        inline const std::list<CollisionNode*>& getNodeList() const
        {
            return CollNodes_;
        }
        inline const std::list<CollisionMaterial*>& getMaterialList() const
        {
            return CollMaterials_;
        }
        
        inline TreeNode* getRootTreeNode() const
        {
            return RootTreeNode_;
        }
        
        inline std::list<SIntersectionContact> findIntersections(
            const dim::line3df &Line, bool SearchBidirectional = false,
            const IntersectionCriteriaCallback &CriteriaCallback = 0) const
        {
            std::list<SIntersectionContact> ContactList;
            findIntersections(Line, ContactList, SearchBidirectional, CriteriaCallback);
            return ContactList;
        }
        
    protected:
        
        /* === Functions === */
        
        virtual void findIntersectionsUnidirectional(
            const dim::line3df &Line, std::list<SIntersectionContact> &ContactList,
            const IntersectionCriteriaCallback &CriteriaCallback
        ) const;
        
        /* === Templates === */
        
        template <class T> T* addCollNode(T* Node)
        {
            CollNodes_.push_back(Node);
            return Node;
        }
        
        /* === Members === */
        
        std::list<CollisionNode*> CollNodes_;
        std::list<CollisionMaterial*> CollMaterials_;
        std::list<CharacterController*> CharacterControllers_;
        
        TreeNode* RootTreeNode_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================