From f9158592e1478b2013afc7041d9ed041cf2d2f4a Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 13 Jan 2014 19:47:58 +1000 Subject: Update Irrlicht to 1.8.1. Include actual change markers this time. lol --- .../include/ISceneNodeAnimatorCollisionResponse.h | 171 +++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 libraries/irrlicht-1.8.1/include/ISceneNodeAnimatorCollisionResponse.h (limited to 'libraries/irrlicht-1.8.1/include/ISceneNodeAnimatorCollisionResponse.h') diff --git a/libraries/irrlicht-1.8.1/include/ISceneNodeAnimatorCollisionResponse.h b/libraries/irrlicht-1.8.1/include/ISceneNodeAnimatorCollisionResponse.h new file mode 100644 index 0000000..299c0a7 --- /dev/null +++ b/libraries/irrlicht-1.8.1/include/ISceneNodeAnimatorCollisionResponse.h @@ -0,0 +1,171 @@ +// 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_NODE_ANIMATOR_COLLISION_RESPONSE_H_INCLUDED__ +#define __I_SCENE_NODE_ANIMATOR_COLLISION_RESPONSE_H_INCLUDED__ + +#include "ISceneNode.h" + +namespace irr +{ +namespace scene +{ + + class ISceneNodeAnimatorCollisionResponse; + + //! Callback interface for catching events of collisions. + /** Implement this interface and use + ISceneNodeAnimatorCollisionResponse::setCollisionCallback to be able to + be notified if a collision has occurred. + **/ + class ICollisionCallback : public virtual IReferenceCounted + { + public: + + //! Will be called when a collision occurrs. + /** See ISceneNodeAnimatorCollisionResponse::setCollisionCallback for more information. + \param animator: Collision response animator in which the collision occurred. You can call + this animator's methods to find the node, collisionPoint and/or collision triangle. + \retval true if the collision was handled in the animator. The animator's target + node will *not* be stopped at the collision point, but will instead move fully + to the location that triggered the collision check. + \retval false if the collision was not handled in the animator. The animator's + target node will be moved to the collision position. + */ + virtual bool onCollision(const ISceneNodeAnimatorCollisionResponse& animator) = 0; + }; + + //! Special scene node animator for doing automatic collision detection and response. + /** This scene node animator can be attached to any single scene node + and will then prevent it from moving through specified collision geometry + (e.g. walls and floors of the) world, as well as having it fall under gravity. + This animator provides a simple implementation of first person shooter cameras. + Attach it to a camera, and the camera will behave as the player control in a + first person shooter game: The camera stops and slides at walls, walks up stairs, + falls down if there is no floor under it, and so on. + + The animator will treat any change in the position of its target scene + node as movement, including a setPosition(), as movement. If you want to + teleport the target scene node manually to a location without it being effected + by collision geometry, then call setTargetNode(node) after calling node->setPosition(). + */ + class ISceneNodeAnimatorCollisionResponse : public ISceneNodeAnimator + { + public: + + //! Destructor + virtual ~ISceneNodeAnimatorCollisionResponse() {} + + //! Check if the attached scene node is falling. + /** Falling means that there is no blocking wall from the scene + node in the direction of the gravity. The implementation of + this method is very fast, no collision detection is done when + invoking it. + \return True if the scene node is falling, false if not. */ + virtual bool isFalling() const = 0; + + //! Sets the radius of the ellipsoid for collision detection and response. + /** If you have a scene node, and you are unsure about how big + the radius should be, you could use the following code to + determine it: + \code + core::aabbox box = yourSceneNode->getBoundingBox(); + core::vector3df radius = box.MaxEdge - box.getCenter(); + \endcode + \param radius: New radius of the ellipsoid. */ + virtual void setEllipsoidRadius(const core::vector3df& radius) = 0; + + //! Returns the radius of the ellipsoid for collision detection and response. + /** \return Radius of the ellipsoid. */ + virtual core::vector3df getEllipsoidRadius() const = 0; + + //! Sets the gravity of the environment. + /** A good example value would be core::vector3df(0,-100.0f,0) + for letting gravity affect all object to fall down. For bigger + gravity, make increase the length of the vector. You can + disable gravity by setting it to core::vector3df(0,0,0); + \param gravity: New gravity vector. */ + virtual void setGravity(const core::vector3df& gravity) = 0; + + //! Get current vector of gravity. + //! \return Gravity vector. */ + virtual core::vector3df getGravity() const = 0; + + //! 'Jump' the animator, by adding a jump speed opposite to its gravity + /** \param jumpSpeed The initial speed of the jump; the velocity will be opposite + to this animator's gravity vector. */ + virtual void jump(f32 jumpSpeed) = 0; + + //! Should the Target react on collision ( default = true ) + virtual void setAnimateTarget ( bool enable ) = 0; + virtual bool getAnimateTarget () const = 0; + + //! Set translation of the collision ellipsoid. + /** By default, the ellipsoid for collision detection is + created around the center of the scene node, which means that + the ellipsoid surrounds it completely. If this is not what you + want, you may specify a translation for the ellipsoid. + \param translation: Translation of the ellipsoid relative + to the position of the scene node. */ + virtual void setEllipsoidTranslation(const core::vector3df &translation) = 0; + + //! Get the translation of the ellipsoid for collision detection. + /** See + ISceneNodeAnimatorCollisionResponse::setEllipsoidTranslation() + for more details. + \return Translation of the ellipsoid relative to the position + of the scene node. */ + virtual core::vector3df getEllipsoidTranslation() const = 0; + + //! Sets a triangle selector holding all triangles of the world with which the scene node may collide. + /** \param newWorld: New triangle selector containing triangles + to let the scene node collide with. */ + virtual void setWorld(ITriangleSelector* newWorld) = 0; + + //! Get the current triangle selector containing all triangles for collision detection. + virtual ITriangleSelector* getWorld() const = 0; + + //! Set the single node that this animator will act on. + /** \param node The new target node. Setting this will force the animator to update + its last target position for the node, allowing setPosition() to teleport + the node through collision geometry. */ + virtual void setTargetNode(ISceneNode * node) = 0; + + //! Gets the single node that this animator is acting on. + /** \return The node that this animator is acting on. */ + virtual ISceneNode* getTargetNode(void) const = 0; + + //! Returns true if a collision occurred during the last animateNode() + virtual bool collisionOccurred() const = 0; + + //! Returns the last point of collision. + virtual const core::vector3df & getCollisionPoint() const = 0; + + //! Returns the last triangle that caused a collision + virtual const core::triangle3df & getCollisionTriangle() const = 0; + + //! Returns the position that the target node will be moved to, unless the collision is consumed in a callback. + /** + If you have a collision callback registered, and it consumes the collision, then the + node will ignore the collision and will not stop at this position. Instead, it will + move fully to the position that caused the collision to occur. */ + virtual const core::vector3df & getCollisionResultPosition(void) const = 0; + + //! Returns the node that was collided with. + virtual ISceneNode* getCollisionNode(void) const = 0; + + //! Sets a callback interface which will be called if a collision occurs. + /** \param callback: collision callback handler that will be called when a collision + occurs. Set this to 0 to disable the callback. + */ + virtual void setCollisionCallback(ICollisionCallback* callback) = 0; + + }; + + +} // end namespace scene +} // end namespace irr + +#endif + -- cgit v1.1