ISceneCollisionManager.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_SCENE_COLLISION_MANAGER_H_INCLUDED__
#define __I_SCENE_COLLISION_MANAGER_H_INCLUDED__

#include "IReferenceCounted.h"
#include "vector3d.h"
#include "triangle3d.h"
#include "position2d.h"
#include "line3d.h"

namespace irr
{

namespace scene
{
        class ISceneNode;
        class ICameraSceneNode;
        class ITriangleSelector;
        class IMeshBuffer;

        struct SCollisionHit
        {
                core::vector3df Intersection;

                core::triangle3df Triangle;

                ITriangleSelector* TriangleSelector;

                ISceneNode* Node;

                const IMeshBuffer* MeshBuffer;

                irr::u32 MaterialIndex;

                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 irr

#endif