ISceneCollisionManager.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in jimcpp/jimcpp.hpp
 
#ifndef JPP_I_SCENE_COLLISION_MANAGER_HPP_INCLUDED
#define JPP_I_SCENE_COLLISION_MANAGER_HPP_INCLUDED
 
#include <jimcpp/core/engine/IReferenceCounted.hpp>
#include <jimcpp/core/engine/vector3d.hpp>
#include <jimcpp/core/engine/triangle3d.hpp>
#include <jimcpp/core/engine/position2d.hpp>
#include <jimcpp/core/engine/line3d.hpp>
 
namespace jpp
{
 
namespace scene
{
    class ISceneNode;
    class ICameraSceneNode;
    class ITriangleSelector;
    class IMeshBuffer;
 
    class SCollisionHit
    {
    public:
        core::vector3df Intersection;
 
        core::triangle3df Triangle;
 
        const ITriangleSelector* TriangleSelector;
 
        ISceneNode* Node;
 
        const IMeshBuffer* MeshBuffer;
 
        jpp::u32 MaterialIndex;
 
    public:
        SCollisionHit() : TriangleSelector(0), Node(0), MeshBuffer(0), MaterialIndex(0)
        {}
    };
 
    class ISceneCollisionManager : public virtual IReferenceCounted
    {
    public:
 
 
        virtual bool getCollisionPoint(SCollisionHit& hitResult, const core::line3d<f32>& ray,
                ITriangleSelector* selector) = 0;
 
 
        virtual bool getCollisionPoint(const core::line3d<f32>& ray,
                ITriangleSelector* selector, core::vector3df& outCollisionPoint,
                core::triangle3df& outTriangle, ISceneNode*& outNode)
        {
            SCollisionHit hitResult;
            if ( getCollisionPoint(hitResult, ray, selector) )
            {
                outCollisionPoint = hitResult.Intersection;
                outTriangle = hitResult.Triangle;
                outNode = hitResult.Node;
                return true;
            }
            return false;
        }
 
 
        virtual core::vector3df getCollisionResultPosition(
            ITriangleSelector* selector,
            const core::vector3df &ellipsoidPosition,
            const core::vector3df& ellipsoidRadius,
            const core::vector3df& ellipsoidDirectionAndSpeed,
            core::triangle3df& triout,
            core::vector3df& hitPosition,
            bool& outFalling,
            ISceneNode*& outNode,
            f32 slidingSpeed = 0.0005f,
            const core::vector3df& gravityDirectionAndSpeed
            = core::vector3df(0.0f, 0.0f, 0.0f)) = 0;
 
 
        virtual core::line3d<f32> getRayFromScreenCoordinates(
            const core::position2d<s32>& pos, const ICameraSceneNode* camera = 0) = 0;
 
 
        virtual core::position2d<s32> getScreenCoordinatesFrom3DPosition(
            const core::vector3df& pos, const ICameraSceneNode* camera=0, bool useViewPort=false) = 0;
 
 
        virtual ISceneNode* getSceneNodeFromScreenCoordinatesBB(const core::position2d<s32>& pos,
                s32 idBitMask=0, bool bNoDebugObjects=false, ISceneNode* root=0) =0;
 
 
        virtual ISceneNode* getSceneNodeFromRayBB(const core::line3d<f32>& ray,
                            s32 idBitMask=0, bool bNoDebugObjects=false, ISceneNode* root=0) =0;
 
 
        virtual ISceneNode* getSceneNodeFromCameraBB(const ICameraSceneNode* camera,
            s32 idBitMask=0, bool bNoDebugObjects = false) = 0;
 
 
 
        virtual ISceneNode* getSceneNodeAndCollisionPointFromRay(
                                SCollisionHit& hitResult, 
                                const core::line3df& ray,
                                s32 idBitMask = 0,
                                ISceneNode * collisionRootNode = 0,
                                bool noDebugObjects = false) = 0;
 
 
        virtual ISceneNode* getSceneNodeAndCollisionPointFromRay(
                                const core::line3df& ray,
                                core::vector3df& outCollisionPoint,
                                core::triangle3df& outTriangle,
                                s32 idBitMask = 0,
                                ISceneNode * collisionRootNode = 0,
                                bool noDebugObjects = false)
        {
            SCollisionHit hitResult;
            ISceneNode* node = getSceneNodeAndCollisionPointFromRay(hitResult, ray, idBitMask, collisionRootNode, noDebugObjects);
            if ( node )
            {
                outCollisionPoint = hitResult.Intersection;
                outTriangle  = hitResult.Triangle;
            }
            return node;
        }
 
    };
 
} // end namespace scene
} // end namespace jpp
 
#endif