source: downloads/ogreode/prefab/include/OgreOdeVehicle.h @ 21

#ifndef _OGREODEVEHICLE_H_
#define _OGREODEVEHICLE_H_

#include "OgreOde_Prefab.h"

#include <vector>

namespace OgreOde_Prefab 
{

    class _OgreOdeExport_Prefab Vehicle : public Object
    {
        public:
                class _OgreOdeExport_Prefab Engine
                {
                public:
                        Engine();
                        ~Engine();

            void setInputs(Ogre::Real throttle_position, Ogre::Real brake_position);
            void setInputs(Ogre::Real throttle_brake);
                        void setInputs(bool throttle, bool brake);
                        
                        Ogre::Real getBrakeForce();
                        Ogre::Real getPowerAtRPM(Ogre::Real rpm);
                        Ogre::Real getDesiredRPM();

                        void update(Ogre::Real time);

                        // Manual gearbox
                        void changeUp();
                        void changeDown();
                        void setGear(char code);
                        void setGear(unsigned int i);

                        // Information functions
                        Ogre::Real getRevFactor();
                        char getGearCode();
                
                        // Engine parameters
                        void setRevLimit(Ogre::Real rpm);
                        void setTorque(Ogre::Real* torque, unsigned int samples);
                        void setTorque(Ogre::Real constant);
                        void setTorque(Ogre::Real minimum, Ogre::Real maximum);

                        // Braking parameters
                        void setBrakeForce(Ogre::Real force);

                        // Drivetrain parameters
                        void addGear(Ogre::Real ratio, char code);
            void setFinalDrive(Ogre::Real ratio);
                        void setAutoShiftRevs(Ogre::Real up, Ogre::Real down);
                        void setAutoBox(bool automatic);

                protected:
                        std::vector<std::pair<char,Ogre::Real> >        _gears;
                        unsigned int                                                    _current_gear_num;
                        std::pair<char,Ogre::Real>                              _current_gear;
                        Ogre::Real*                                                             _torque_curve;
                        unsigned int                                                    _curve_length;
                        Ogre::Real                                                              _rev_limit,_throttle_position,_brake_position,_wheel_rpm,_inv_rev_limit;
                        Ogre::Real                                                              _brake_force;
                        Ogre::Real                                                              _final_drive;
                        Ogre::Real                                                              _shift_up,_shift_down;
                        bool                                                                    _auto_box;
                };

                class _OgreOdeExport_Prefab Wheel : public Object
                {
                public:
                        static const Ogre::Real FudgeFactor;

            Wheel(Vehicle* vehicle,
                const Ogre::String& name,
                const Ogre::String& mesh,
                const Ogre::Vector3& position, 
                Ogre::Real mass, 
                OgreOde::World *world, 
                OgreOde::Space* space);

                        ~Wheel();

                        void setFactors(Ogre::Real steer, Ogre::Real power, Ogre::Real brake);
                        void setContact(Ogre::Real bouncyness, Ogre::Real friction, Ogre::Real fds)
                        {
                                _bouncyness = bouncyness;
                                _friction = friction;
                                _fds = fds;
                        }

                        void setSteerFactor(Ogre::Real factor);
                        void setSteerLimit(Ogre::Real limit);
                        void setSteerForce(Ogre::Real force){_steer_force = force;}
                        void setSteerSpeed(Ogre::Real speed){_steer_speed = speed;}
                        void setSteer(Ogre::Real position);
                        
                        void setPowerFactor(Ogre::Real power){_power_factor = power;}
                        void setBrakeFactor(Ogre::Real brake){_brake_factor = brake;}

                        void setSuspension(Ogre::Real spring_constant, Ogre::Real damping_constant, Ogre::Real step_size);

                        const Ogre::Vector3& getPosition();
                        const Ogre::Quaternion& getOrientation();
                        void setPosition(const Ogre::Vector3& position);

                        Ogre::Real getRPM();
                        Ogre::Real getSteer();

                        void update(Ogre::Real power_force, Ogre::Real desired_rpm, Ogre::Real brake_force);
        
            Ogre::SceneNode* getSceneNode(){return _node;}
                        Ogre::Entity*   getEntity(){return _entity;}
            OgreOde::Body* getBody(){return _body;}

                        OgreOde::Geometry* getGeometry(){return _geometry;}

            Ogre::Real getRadius()const{return _radius;}

                        void snapOff();

                        void setupTyreContact(OgreOde::Contact* contact);

                protected:
                        void adjustJointParameters();

                        Ogre::SceneNode*                                _node;
                        Ogre::Entity*                                   _entity;
                        Ogre::Real                                      _steer_factor,_steer_limit,_steer_force,_steer_speed;
                        Ogre::Real                                      _power_factor;
                        Ogre::Real                                      _brake_factor;
                        Ogre::Real                                      _spring,_damping,_step;
                        Ogre::Real                                      _bouncyness,_friction,_fds;
                        Ogre::Real                                      _radius;
            OgreOde::Body*                                      _body;
            OgreOde::Geometry*                          _geometry;
            OgreOde::SuspensionJoint*           _joint;
            Ogre::String                                        _name;
                        Vehicle*                                        _owner;
                };

        public:
        Vehicle(const Ogre::String& name,const Ogre::String& mesh, Ogre::Real mass, 
            OgreOde::World *world, 
            OgreOde::Space* space,
            const Ogre::Vector3& offset = Ogre::Vector3::ZERO,
            OgreOde::Geometry* geometry = 0);

        Vehicle(const Ogre::String& name, 
                OgreOde::World *world, 
                OgreOde::Space* space = 0,
                OgreOde::Geometry* geometry = 0);
                ~Vehicle();

        Vehicle::Wheel* addWheel(const Ogre::String& mesh,const Ogre::Vector3& position, Ogre::Real mass);
                
                const Ogre::Vector3& getPosition();
                const Ogre::Quaternion& getOrientation();
                void setPosition(const Ogre::Vector3& position);

                void setSuspension(Ogre::Real spring_constant, Ogre::Real damping_constant, Ogre::Real step_size);
                
                void setInputs(Ogre::Real steering, Ogre::Real throttle,Ogre::Real brake);
                void setInputs(Ogre::Real steering, Ogre::Real throttle_brake);
                void setInputs(bool left, bool right, bool throttle, bool brake);

                void setSteering(Ogre::Real steering_position);

                const Ogre::String&     getName(){return _name;}

                virtual void            applyAntiSwayBarForces();
                void                            update(Ogre::Real time);

                Ogre::Entity*                           getEntity(){return _entity;}
                void                                    setEntity(Ogre::Entity *e){ _entity = e;}

        OgreOde::Body*                          getBody(){return _body;}

                Ogre::SceneNode*                        getSceneNode(){return _node;}

                Vehicle::Wheel*         getWheel(unsigned int i){return _wheels[i];}
                size_t                          getWheelCount()const{return _wheels.size();}

                OgreOde::TransformGeometry*     getTransformGeometry(){return _transform;}
                void                            setTransformGeometry(OgreOde::TransformGeometry*g){_transform = g;}

        void                            setTransNode(Ogre::SceneNode *s){_trans_node = s;}
                Ogre::SceneNode*                        getTransNode(){return _trans_node;}

        OgreOde::Geometry*                      getGeometry(){return _geometry;}
                void                            setGeometry(OgreOde::Geometry*g){_geometry = g;}

                Engine*                         getEngine(){return _engine;}

                Vehicle::Wheel*         findWheel(OgreOde::Geometry* geometry);

                OgreOde::Space*         getSpace(){return _space;}

        Ogre::Vector3                           getOffset(){return _offset;}
                void                            setOffset(const Ogre::Vector3 &of)
                {
                        _offset = of;
                        if (_geometry) 
                                _geometry->setPosition(of);
                        _trans_node->setPosition(of);
                }

                Ogre::Real getVelocity();
                
                static bool handleTyreCollision(OgreOde::Contact* contact);

                void load(const Ogre::String &filename, const Ogre::String &definition_name = Ogre::StringUtil::BLANK);

                bool isAntiSwayEnabled()const {return _antisway;};
                void enableAntiSway(bool enable){_antisway = enable;};

                void  setSwayForce(Ogre::Real swayForce){_swayForce = swayForce;};
                void  setSwayForceLimit(unsigned int swayForceLimit){_swayForceLimit = swayForceLimit;}
                void  setSwayForceRate(Ogre::Real swayRate){_swayRate = swayRate;}

                Ogre::Real                getSwayForce (Ogre::Real swayForce) const{return _swayForce;};
                unsigned int  getSwayForceLimit(unsigned int swayForceLimit) const{return _swayForceLimit;}
                Ogre::Real          getSwayForceRate(Ogre::Real swayRate) const{return _swayRate;}

        protected:
                Ogre::SceneNode*                                                _node;
                Ogre::SceneNode*                                                _trans_node;
                Ogre::Entity*                                                   _entity;
        OgreOde::Body*                                                  _body;
        OgreOde::TransformGeometry*                             _transform;
        OgreOde::Geometry*                                              _geometry;
                std::vector<Vehicle::Wheel*>    _wheels;
                Ogre::String                                                    _name;
        OgreOde::SimpleSpace*                                   _space;
        Ogre::Vector3                                                   _offset;
                Ogre::Vector3                                                   _lastPosition;
                Engine*                                                 _engine;
                
                bool                                                    _antisway;
                Ogre::Real                                                      _swayForce;
                unsigned int                                    _swayForceLimit;
                Ogre::Real                                                      _swayRate;
                Ogre::Real                                                      _swayLastUpdate;
        };
}

#endif