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

Go to the documentation of this file.

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

#ifndef __SP_COLLISION_CONFIG_TYPES_H__
#define __SP_COLLISION_CONFIG_TYPES_H__


#include "Base/spStandard.hpp"
#include "Base/spMeshBuffer.hpp"
#include "SceneGraph/spSceneMesh.hpp"


namespace sp
{
namespace scene
{


/*
 * Pre-declerations
 */

class CollisionMaterial;
class CollisionNode;
class CollisionSphere;
class CollisionCapsule;
class CollisionCylinder;
class CollisionCone;
class CollisionBox;
class CollisionPlane;
class CollisionMesh;


/*
 * Enumerations
 */

enum ECollisionModels
{
    COLLISION_NONE = 0, 
    COLLISION_SPHERE,   
    COLLISION_CAPSULE,  
    COLLISION_CYLINDER, 
    COLLISION_CONE,     
    COLLISION_BOX,      
    COLLISION_PLANE,    
    COLLISION_MESH,     
};

enum ECollisionFlags
{
    COLLISIONFLAG_NONE              = 0x00,                             
    
    COLLISIONFLAG_DETECTION         = 0x01,                             
    COLLISIONFLAG_RESOLVE           = 0x02 | COLLISIONFLAG_DETECTION,   
    COLLISIONFLAG_INTERSECTION      = 0x04,                             
    COLLISIONFLAG_PERMANENT_UPDATE  = 0x08,                             
    
    COLLISIONFLAG_FULL =
        COLLISIONFLAG_RESOLVE |
        COLLISIONFLAG_INTERSECTION |
        COLLISIONFLAG_PERMANENT_UPDATE,
};

enum ECollisionSupportFlags
{
    COLLISIONSUPPORT_NONE       = 0x00, 
    
    COLLISIONSUPPORT_SPHERE     = 0x01, 
    COLLISIONSUPPORT_CAPSULE    = 0x02, 
    COLLISIONSUPPORT_CYLINDER   = 0x04, 
    COLLISIONSUPPORT_CONE       = 0x08, 
    COLLISIONSUPPORT_BOX        = 0x10, 
    COLLISIONSUPPORT_PLANE      = 0x20, 
    COLLISIONSUPPORT_MESH       = 0x40, 
    
    COLLISIONSUPPORT_ALL        = ~0,   
};


/*
 * Structures
 */

struct SCollisionFace
{
    SCollisionFace() :
        Mesh    (0),
        Surface (0),
        Index   (0)
    {
    }
    SCollisionFace(
        scene::Mesh* InitMesh, u32 InitSurface, u32 InitIndex, const dim::triangle3df &InitTriangle) :
        Mesh    (InitMesh       ),
        Surface (InitSurface    ),
        Index   (InitIndex      ),
        Triangle(InitTriangle   )
    {
    }
    ~SCollisionFace()
    {
    }
    
    /* === Functions === */
    
    inline bool isBackFaceCulling(const video::EFaceTypes CollFace, const dim::vector3df &InversePoint) const
    {
        if (CollFace != video::FACE_BOTH)
        {
            bool isPointFront = dim::plane3df(Triangle).isPointFrontSide(InversePoint);
            
            if ( ( CollFace == video::FACE_FRONT && !isPointFront ) ||
                 ( CollFace == video::FACE_BACK  &&  isPointFront ) )
            {
                return true;
            }
        }
        return false;
    }
    
    inline bool isBackFaceCulling(const video::EFaceTypes CollFace, const dim::line3df &InverseLine) const
    {
        if (CollFace != video::FACE_BOTH)
        {
            bool isPointFrontA = dim::plane3df(Triangle).isPointFrontSide(InverseLine.Start);
            bool isPointFrontB = dim::plane3df(Triangle).isPointFrontSide(InverseLine.End);
            
            if ( ( CollFace == video::FACE_FRONT && !isPointFrontA && !isPointFrontB ) ||
                 ( CollFace == video::FACE_BACK  &&  isPointFrontA &&  isPointFrontB ) )
            {
                return true;
            }
        }
        return false;
    }
    
    /* Members */
    scene::Mesh* Mesh;
    u32 Surface;                
    u32 Index;                  
    dim::triangle3df Triangle;  
};

struct SContactBase
{
    SContactBase() :
        Impact  (0.0f   ),
        Face    (0      )
    {
    }
    virtual ~SContactBase()
    {
    }
    
    /* Members */
    dim::vector3df Point;       
    dim::vector3df Normal;      
    f32 Impact;                 
    
    dim::triangle3df Triangle;  
    SCollisionFace* Face;       
};

struct SIntersectionContact : public SContactBase
{
    SIntersectionContact() :
        SContactBase(       ),
        Object      (0      ),
        DistanceSq  (0.0f   )
    {
    }
    ~SIntersectionContact()
    {
    }
    
    /* Operators */
    inline bool operator == (const SIntersectionContact &Other) const
    {
        return Object == Other.Object && Face == Other.Face;
    }
    
    /* Members */
    const CollisionNode* Object;    
    f32 DistanceSq;                 
};

struct SCollisionContact : public SContactBase
{
    SCollisionContact() :
        SContactBase()
    {
    }
    ~SCollisionContact()
    {
    }
    
    /* Operators */
    inline bool operator == (const SCollisionContact &Other) const
    {
        return Face == Other.Face;
    }
};


} // /namespace scene

} // /namespace sp


#endif



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