source: trunk/test/Physics/Include/BulletCharacterController.h @ 1802 Tweet

//
// Lol Engine
//
// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
//   This program is free software; you can redistribute it and/or
//   modify it under the terms of the Do What The Fuck You Want To
//   Public License, Version 2, as published by Sam Hocevar. See
//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
//

//
// The BulletCharacterController class
// ------------------
// This class is a equivalent of btKinematicCharacterController, but more useful for Lol.
//

#if !defined __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__
#define __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__

#ifdef HAVE_PHYS_USE_BULLET
#include "core.h"
#include "EasyPhysics.h"
//#include "BulletDynamics\Character\btCharacterControllerInterface.h"
#endif

namespace lol
{

        namespace phys
        {

#if 0
#ifdef HAVE_PHYS_USE_BULLET

                ///BulletKinematicCharacterController is an object that supports a sliding motion in a world.
                ///It uses a ghost object and convex sweep test to test for upcoming collisions. This is combined with discrete collision detection to recover from penetrations.
                ///Interaction between btKinematicCharacterController and dynamic rigid bodies needs to be explicity implemented by the user.
                class BulletKinematicCharacterController : public btCharacterControllerInterface
                {
                protected:

                        btScalar m_halfHeight;

                        btPairCachingGhostObject* m_ghostObject;
                        btConvexShape*  m_convexShape;//is also in m_ghostObject, but it needs to be convex, so we store it here to avoid upcast

                        btScalar m_verticalVelocity;
                        btScalar m_verticalOffset;
                        btScalar m_fallSpeed;
                        btScalar m_jumpSpeed;
                        btScalar m_maxJumpHeight;
                        btScalar m_maxSlopeRadians; // Slope angle that is set (used for returning the exact value)
                        btScalar m_maxSlopeCosine;  // Cosine equivalent of m_maxSlopeRadians (calculated once when set, for optimization)
                        btScalar m_gravity;

                        btScalar m_turnAngle;

                        btScalar m_stepHeight;

                        btScalar        m_addedMargin;//@todo: remove this and fix the code

                        ///this is the desired walk direction, set by the user
                        btVector3       m_walkDirection;
                        btVector3       m_normalizedDirection;

                        //some internal variables
                        btVector3 m_currentPosition;
                        btScalar  m_currentStepOffset;
                        btVector3 m_targetPosition;

                        ///keep track of the contact manifolds
                        btManifoldArray m_manifoldArray;

                        bool m_touchingContact;
                        btVector3 m_touchingNormal;

                        bool  m_wasOnGround;
                        bool  m_wasJumping;
                        bool    m_useGhostObjectSweepTest;
                        bool    m_useWalkDirection;
                        btScalar        m_velocityTimeInterval;
                        int m_upAxis;

                        static btVector3* getUpAxisDirections();

                        btVector3 computeReflectionDirection (const btVector3& direction, const btVector3& normal);
                        btVector3 parallelComponent (const btVector3& direction, const btVector3& normal);
                        btVector3 perpindicularComponent (const btVector3& direction, const btVector3& normal);

                        bool recoverFromPenetration ( btCollisionWorld* collisionWorld);
                        void stepUp (btCollisionWorld* collisionWorld);
                        void updateTargetPositionBasedOnCollision (const btVector3& hit_normal, btScalar tangentMag = btScalar(0.0), btScalar normalMag = btScalar(1.0));
                        void stepForwardAndStrafe (btCollisionWorld* collisionWorld, const btVector3& walkMove);
                        void stepDown (btCollisionWorld* collisionWorld, btScalar dt);
                public:
                        BulletKinematicCharacterController (btPairCachingGhostObject* ghostObject,btConvexShape* convexShape,btScalar stepHeight, int upAxis = 1);
                        ~BulletKinematicCharacterController ();


                        ///btActionInterface interface
                        virtual void updateAction( btCollisionWorld* collisionWorld,btScalar deltaTime)
                        {
                                preStep ( collisionWorld);
                                playerStep (collisionWorld, deltaTime);
                        }

                        ///btActionInterface interface
                        void    debugDraw(btIDebugDraw* debugDrawer);

                        void setUpAxis (int axis)
                        {
                                if (axis < 0)
                                        axis = 0;
                                if (axis > 2)
                                        axis = 2;
                                m_upAxis = axis;
                        }

                        /// This should probably be called setPositionIncrementPerSimulatorStep.
                        /// This is neither a direction nor a velocity, but the amount to
                        ///     increment the position each simulation iteration, regardless
                        ///     of dt.
                        /// This call will reset any velocity set by setVelocityForTimeInterval().
                        virtual void    setWalkDirection(const btVector3& walkDirection);

                        /// Caller provides a velocity with which the character should move for
                        ///     the given time period.  After the time period, velocity is reset
                        ///     to zero.
                        /// This call will reset any walk direction set by setWalkDirection().
                        /// Negative time intervals will result in no motion.
                        virtual void setVelocityForTimeInterval(const btVector3& velocity,
                                btScalar timeInterval);

                        void reset ();
                        void warp (const btVector3& origin);

                        void preStep (  btCollisionWorld* collisionWorld);
                        void playerStep ( btCollisionWorld* collisionWorld, btScalar dt);

                        void setFallSpeed (btScalar fallSpeed);
                        void setJumpSpeed (btScalar jumpSpeed);
                        void setMaxJumpHeight (btScalar maxJumpHeight);
                        bool canJump () const;

                        void jump ();

                        void setGravity(btScalar gravity);
                        btScalar getGravity() const;

                        /// The max slope determines the maximum angle that the controller can walk up.
                        /// The slope angle is measured in radians.
                        void setMaxSlope(btScalar slopeRadians);
                        btScalar getMaxSlope() const;

                        btPairCachingGhostObject* getGhostObject();
                        void    setUseGhostSweepTest(bool useGhostObjectSweepTest)
                        {
                                m_useGhostObjectSweepTest = useGhostObjectSweepTest;
                        }

                        bool onGround () const;
                };

#endif // HAVE_PHYS_USE_BULLET
#endif // 0

        } /* namespace phys */

} /* namespace lol */

#endif /* __BULLETCHARACTERCONTROLLER_BULLETCHARACTERCONTROLLER_H__ */