168 lines
7.6 KiB
C++
168 lines
7.6 KiB
C++
// Copyright (C) 2002-2006 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#pragma once
|
|
|
|
#using <mscorlib.dll>
|
|
using namespace System;
|
|
using namespace System::Runtime::InteropServices;
|
|
|
|
#pragma unmanaged
|
|
#include "..\\..\\include\\irrlicht.h"
|
|
#pragma managed
|
|
|
|
#include "Line3D.h"
|
|
#include "Triangle3D.h"
|
|
#include "ITriangleSelector.h"
|
|
#include "Position2D.h"
|
|
#include "ICameraSceneNode.h"
|
|
|
|
namespace Irrlicht
|
|
{
|
|
namespace Scene
|
|
{
|
|
|
|
/// <summary>
|
|
/// The Scene Collision Manager provides methods for performing collision tests and
|
|
/// picking on scene nodes.
|
|
/// </summary>
|
|
public __gc class ISceneCollisionManager
|
|
{
|
|
public:
|
|
|
|
/// <summary>
|
|
/// Creates a scm from a native C++ scene node. Don't use this, its better to
|
|
/// get access to the ISceneCollisionManager via ISceneManager.SceneCollisionManager.
|
|
/// </summary>
|
|
ISceneCollisionManager(irr::scene::ISceneCollisionManager* realSCM);
|
|
|
|
/// <summary>
|
|
/// Finds the collision point of a line and lots of triangles, if there is one.
|
|
/// </summary>
|
|
/// <param name="ray"> Line with witch collisions are tested.</param>
|
|
/// <param name="selector"> TriangleSelector containing the triangles. It can
|
|
/// be created for example using ISceneManager::createTriangleSelector() or
|
|
/// ISceneManager::createTriangleOctTreeSelector().</param>
|
|
/// <param name="outCollisionPoint"> If a collision is detected, this will contain the
|
|
/// position of the nearest collision.</param>
|
|
/// <param name="outTriangle"> If a collision is detected, this will contain the triangle
|
|
/// with which the ray collided.</param>
|
|
/// <returns> Returns true if a collision was detected and false if not.</returns>
|
|
bool GetCollisionPoint(Core::Line3D ray,
|
|
Scene::ITriangleSelector* selector,
|
|
[PARAMFLAG::Out] Core::Vector3D& outCollisionPoint,
|
|
[PARAMFLAG::Out] Core::Triangle3D& outTriangle);
|
|
|
|
/// <summary>
|
|
/// Collides a moving ellipsoid with a 3d world with gravity and returns
|
|
/// the resulting new position of the ellipsoid. This can be used for moving
|
|
/// a character in a 3d world: The character will slide at walls and is able
|
|
/// to walk up stairs. The method used how to calculate the collision result
|
|
/// position is based on the paper "Improved Collision detection and Response"
|
|
/// by Kasper Fauerby.
|
|
/// </summary>
|
|
/// <param name="selector"> TriangleSelector containing the triangles of the world.
|
|
/// It can be created for example using ISceneManager::createTriangleSelector() or
|
|
/// ISceneManager::createTriangleOctTreeSelector().</param>
|
|
/// <param name="ellipsoidPosition"> Position of the ellipsoid.</param>
|
|
/// <param name="ellipsoidRadius"> Radius of the ellipsoid.</param>
|
|
/// <param name="ellipsoidDirectionAndSpeed"> Direction and speed of
|
|
/// the movement of the ellipsoid.</param>
|
|
/// <param name="gravityDirectionAndSpeed"> Direction and force of gravity.</param>
|
|
/// <param name="triout"> Optional parameter where the last triangle causing a
|
|
/// collision is stored, if there is a collision.</param>
|
|
/// <param name="outFalling"> Is set to true if the ellipsoid is falling down, caused
|
|
/// by gravity.</param>
|
|
/// <param name="slidingSpeed">Set this to a small value lile 0.0005</param>
|
|
/// <returns> Returns the new position of the ellipsoid.</returns>
|
|
Core::Vector3D GetCollisionResultPosition(
|
|
Scene::ITriangleSelector* selector,
|
|
Core::Vector3D ellipsoidPosition,
|
|
Core::Vector3D ellipsoidRadius,
|
|
Core::Vector3D ellipsoidDirectionAndSpeed,
|
|
[PARAMFLAG::Out] Core::Triangle3D& triout,
|
|
[PARAMFLAG::Out] bool& outFalling,
|
|
float slidingSpeed,
|
|
Core::Vector3D gravityDirectionAndSpeed);
|
|
|
|
/// <summary>
|
|
/// Returns a 3d ray which would go through the 2d screen coodinates.
|
|
/// </summary>
|
|
/// <param name="pos"> Screen coordinates in pixels.</param>
|
|
/// <param name="camera"> Camera from which the ray starts. If null, the
|
|
/// active camera is used.</param>
|
|
/// <returns> Returns a ray starting from the position of the camera
|
|
/// and ending at a lenght of the far value of the camera at a position
|
|
/// which would be behind the 2d screen coodinates.</returns>
|
|
Core::Line3D GetRayFromScreenCoordinates(
|
|
Core::Position2D pos, Scene::ICameraSceneNode* camera);
|
|
|
|
/// <summary>
|
|
/// Calculates 2d screen position from a 3d position.
|
|
/// </summary>
|
|
/// <param name="pos"> 3D position in world space to be transformed into
|
|
/// 2d.</param>
|
|
/// <param name="camera"> Camera to be used. If null, the currently active
|
|
/// camera is used.</param>
|
|
/// <returns> Returns the 2d screen coordinates which a object in the
|
|
/// 3d world would have if it would be rendered to the screen. If the
|
|
/// 3d position is behind the camera, it is set to (-10000,-10000). In
|
|
/// most cases you can ignore this fact, because if you use this method
|
|
/// for drawing a decorator over a 3d object, it will be clipped by the
|
|
/// screen borders.</returns>
|
|
Core::Position2D GetScreenCoordinatesFrom3DPosition(
|
|
Core::Vector3D pos, Scene::ICameraSceneNode* camera);
|
|
|
|
/// <summary>
|
|
/// Returns the scene node, which is currently visible under the overgiven
|
|
/// screencoordinates, viewed from the currently active camera. The collision
|
|
/// tests are done using a bounding box for each scene node.
|
|
/// </summary>
|
|
/// <param name="pos"> Position in pixel screen coordinates, under which the returned
|
|
/// scene node will be.</param>
|
|
/// <param name="idBitMask"> Only scene nodes with an id with bits set like in this mask
|
|
/// will be tested. If the BitMask is 0, this feature is disabled.</param>
|
|
/// <returns> Returns the visible scene node under screen coordinates with matching
|
|
/// bits in its id. If there is no scene node under this position, 0 is returned.</returns>
|
|
Scene::ISceneNode* GetSceneNodeFromScreenCoordinatesBB(Core::Position2D pos,
|
|
int idBitMask, bool noDebugObjects);
|
|
|
|
/// <summary>
|
|
/// Returns the nearest scene node which collides with a 3d ray and
|
|
/// which id matches a bitmask. The collision tests are done using a bounding
|
|
/// box for each scene node.
|
|
/// </summary>
|
|
/// <param name="ray"> Line with witch collisions are tested.</param>
|
|
/// <param name="idBitMask"> Only scene nodes with an id with bits set like in this mask
|
|
/// will be tested. If the BitMask is 0, this feature is disabled.</param>
|
|
/// <returns> Returns the scene node nearest to ray.start, which collides with the
|
|
/// ray and matches the idBitMask, if the mask is not null. If no scene
|
|
/// node is found, 0 is returned.</returns>
|
|
Scene::ISceneNode* GetSceneNodeFromRayBB(Core::Line3D ray,
|
|
int idBitMask, bool noDebugObjects);
|
|
|
|
/// <summary>
|
|
/// Returns the scene node, at which the overgiven camera is looking at and
|
|
/// which id matches the bitmask. A ray is simply casted from the position
|
|
/// of the camera to the view target position, and all scene nodes are tested
|
|
/// against this ray. The collision tests are done using a bounding
|
|
/// box for each scene node.
|
|
/// </summary>
|
|
/// <param name="camera"> Camera from which the ray is casted.</param>
|
|
/// <param name="idBitMaks"> Only scene nodes with an id with bits set like in this mask
|
|
/// will be tested. If the BitMask is 0, this feature is disabled.</param>
|
|
/// <returns> Returns the scene node nearest to the camera, which collides with the
|
|
/// ray and matches the idBitMask, if the mask is not null. If no scene
|
|
/// node is found, 0 is returned.</returns>
|
|
Scene::ISceneNode* GetSceneNodeFromCameraBB(Scene::ICameraSceneNode* camera,
|
|
int idBitMask, bool noDebugObjects);
|
|
|
|
protected:
|
|
|
|
irr::scene::ISceneCollisionManager* SCM;
|
|
};
|
|
|
|
|
|
}
|
|
} |