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

Go to the documentation of this file.

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

#ifndef __SP_COLLISION_NODE_H__
#define __SP_COLLISION_NODE_H__


#include "Base/spStandard.hpp"
#include "Base/spDimension.hpp"
#include "Base/spMathCollisionLibrary.hpp"
#include "Base/spBaseObject.hpp"
#include "SceneGraph/spSceneNode.hpp"
#include "SceneGraph/Collision/spCollisionConfigTypes.hpp"


namespace sp
{
namespace scene
{


class SP_EXPORT CollisionNode : public BaseObject
{
    
    public:
        
        virtual ~CollisionNode();
        
        /* === Functions === */
        
        /*
        Returns the flags for collision support to rival collision nodes.
        \see ECollisionSupportFlags
        */
        virtual s32 getSupportFlags() const = 0;
        
        virtual f32 getMaxMovement() const = 0;
        
        virtual void setMaterial(CollisionMaterial* Material);
        
        virtual void findIntersections(const dim::line3df &Line, std::list<SIntersectionContact> &ContactList) const;
        
        virtual bool checkIntersection(const dim::line3df &Line, SIntersectionContact &Contact) const;
        
        virtual bool checkIntersection(const dim::line3df &Line, bool ExcludeCorners = false) const;
        
        virtual bool checkCollision(const CollisionNode* Rival, SCollisionContact &Contact) const;
        
        virtual bool checkCollision(const CollisionNode* Rival) const;
        
        virtual void performCollisionResolving(const CollisionNode* Rival);
        
        void setupTransformation(const dim::matrix4f &Matrix);
        
        void updateTransformation();
        
        void setPosition(const dim::vector3df &Position, bool UpdatePrevPosition = true);
        
        void setOffset(const dim::matrix4f &Matrix, bool Enable = true);
        
        void updateCollisions();
        
        /* === Inline functions === */
        
        inline ECollisionModels getType() const
        {
            return Type_;
        }
        
        inline void setFlags(s32 Flags)
        {
            Flags_ = Flags;
        }
        inline s32 getFlags() const
        {
            return Flags_;
        }
        
        inline SceneNode* getNode() const
        {
            return Node_;
        }
        
        inline CollisionMaterial* getMaterial() const
        {
            return Material_;
        }
        
        inline dim::vector3df getPosition() const
        {
            return Trans_.getPosition();
        }
        
        inline void translate(const dim::vector3df &Direction)
        {
            Node_->translate(Direction);
            updateTransformation();
        }
        inline void move(const dim::vector3df &Direction)
        {
            Node_->move(Direction);
            updateTransformation();
        }
        inline void turn(const dim::vector3df &Rotation)
        {
            Node_->turn(Rotation);
            updateTransformation();
        }
        
        inline void setRotation(const dim::matrix4f &Rotation)
        {
            Node_->setRotationMatrix(Rotation, true);
            updateTransformation();
        }
        inline dim::matrix4f getRotation() const
        {
            return Trans_.getRotationMatrix();
        }
        
        inline void setScale(const dim::vector3df &Scale)
        {
            Node_->setScale(Scale, true);
            updateTransformation();
        }
        inline dim::vector3df getScale() const
        {
            return Trans_.getScale();
        }
        
        inline const dim::matrix4f& getTransformation() const
        {
            return Trans_;
        }
        inline const dim::matrix4f& getInverseTransformation() const
        {
            return InvTrans_;
        }
        
        inline void getOffset(dim::matrix4f &Matrix, bool &Enable) const
        {
            Matrix = OffsetTrans_;
            Enable = UseOffsetTrans_;
        }
        
        inline dim::vector3df getNodePosition() const
        {
            return NodePosition_;
        }
        inline dim::vector3df getPrevPosition() const
        {
            return PrevPosition_;
        }
        
    protected:
        
        friend class CollisionGraph;
        
        /* === Functions === */
        
        CollisionNode(CollisionMaterial* Material, SceneNode* Node, const ECollisionModels Type);
        
        virtual bool checkCollisionToSphere     (const CollisionSphere*     Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToCapsule    (const CollisionCapsule*    Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToCylinder   (const CollisionCylinder*   Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToCone       (const CollisionCone*       Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToBox        (const CollisionBox*        Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToPlane      (const CollisionPlane*      Rival, SCollisionContact &Contact) const;
        virtual bool checkCollisionToMesh       (const CollisionMesh*       Rival, SCollisionContact &Contact) const;
        
        virtual bool checkAnyCollisionToSphere  (const CollisionSphere*     Rival) const;
        virtual bool checkAnyCollisionToCapsule (const CollisionCapsule*    Rival) const;
        virtual bool checkAnyCollisionToCylinder(const CollisionCylinder*   Rival) const;
        virtual bool checkAnyCollisionToCone    (const CollisionCone*       Rival) const;
        virtual bool checkAnyCollisionToBox     (const CollisionBox*        Rival) const;
        virtual bool checkAnyCollisionToPlane   (const CollisionPlane*      Rival) const;
        virtual bool checkAnyCollisionToMesh    (const CollisionMesh*       Rival) const;
        
        virtual void performCollisionResolvingToSphere  (const CollisionSphere*     Rival);
        virtual void performCollisionResolvingToCapsule (const CollisionCapsule*    Rival);
        virtual void performCollisionResolvingToCylinder(const CollisionCylinder*   Rival);
        virtual void performCollisionResolvingToCone    (const CollisionCone*       Rival);
        virtual void performCollisionResolvingToBox     (const CollisionBox*        Rival);
        virtual void performCollisionResolvingToPlane   (const CollisionPlane*      Rival);
        virtual void performCollisionResolvingToMesh    (const CollisionMesh*       Rival);
        
        bool notifyCollisionContact(const CollisionNode* Rival, const SCollisionContact &Contact);
        bool performDetectedContact(const CollisionNode* Rival, const SCollisionContact &Contact);
        
        bool checkCornerExlusion(const dim::line3df &Line, const dim::vector3df &Point) const;
        
        void updatePrevPosition();
        
    private:
        
        friend class CollisionMaterial;
        
        /* === Members === */
        
        ECollisionModels Type_;         
        s32 Flags_;                     
        
        SceneNode* Node_;               
        
        CollisionMaterial* Material_;   
        
        dim::matrix4f Trans_;           
        dim::matrix4f InvTrans_;        
        dim::matrix4f OffsetTrans_;     
        
        dim::vector3df NodePosition_;   
        dim::vector3df PrevPosition_;   
        
        bool UseOffsetTrans_;           
        
};


} // /namespace scene

} // /namespace sp


#endif



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