human.h

Go to the documentation of this file.

#ifndef VART_HUMAN_H
#define VART_HUMAN_H

#include "vart/graphicobj.h"
#include "vart/joint.h"
#include "vart/point4d.h"
#include "vart/sgpath.h"
#include "vart/callback.h"
#include <string>
#include <list>
#include <map>

namespace VART {
    class Scene;
    class NoisyDofMover;
    class Action;
    class JointAction;
    class XmlJointAction;
    class DMModifier;
    class Human : public GraphicObj
    {
        friend class StepManager;
        public:
            class StepManager : public VART::CallBack
            {
                public:
                    StepManager(Human* human);
                    virtual void Activate();
                private:
                    Human* humanPtr;
                    bool steppingRight;
            };
        // PUBLIC STATIC METHODS
        // PUBLIC METHODS
            Human();
            Human(VART::Human& human);
            ~Human();

            virtual SceneNode* Copy();
            virtual void ComputeBoundingBox();
            virtual void TraverseDepthFirst(SNOperator* operatorPtr);
            virtual void LocateDepthFirst(SNLocator* locatorPtr) const;
            virtual void DrawForPicking() const;
            bool LoadFromFile(const std::string& fileName);

            void PutIntoScene(Scene* scenePtr);

            //~ /// \brief Prints all noisy dof movers.
            //~ void PrintMovers();

            XmlJointAction* LoadAction(const std::string& fileName);

            void ModifyActions(DMModifier& modifier);

            void ComputeStickPosition(Point4D* resultPtr);

            void AdjustPosition();

            void ComputeTransform(Transform* transPtr);

            void Move(const Point4D& offset);

            void ResetPosition();

            void RotateOnY(float radians);

            void Walk(bool status);

            bool WalkTo(const Point4D& dest, const Point4D& orientation);

            void SwapLegs();

            void StickRightFoot();

            void StickLeftFoot();

            bool ReachedDestiantion() const;

            Point4D Position() const;

            bool IsWalking() const { return isWalking; }

            void ChangeAdjustment(const Point4D& displacement);

            void ActivateBreatheAction(bool status);

            void ActivateRestAction(bool status);

            //~ void XmlPrintOn(std::ostream& os, unsigned int indent) const { Transform::XmlPrintOn(os,indent); }
        protected:
            void ComputeLocalStickPosition(Point4D* resultPtr);
            //~ typedef std::map< Joint::DofID, std::list<NoisyDofMover*> > DofID2Movers;
            //~ typedef std::map<Joint::DofID, float> DofID2Offset;
            //~ typedef std::map< std::string, DofID2Movers > JointName2IDs;
        // PROTECTED STATIC METHODS
        // PROTECTED METHODS
            virtual bool DrawInstanceOGL() const;
            //~ void MapMoversFrom(Action& action);

            float AngleToPosition(const Point4D& pos, float* totalAngle) const;
        // PROTECTED STATIC ATTRIBUTES
        // PROTECTED ATTRIBUTES
            //~ JointName2IDs dofs;
            std::list<JointAction*> actionList;
            Point4D rfFront; // right foot front
            Point4D lfFront;
            Point4D rfBack;
            Point4D lfBack;
            Point4D* stickPositionPtr;
            Transform position;
            Transform adjustment;
            Transform orientation;
            Joint* hipJointPtr; // root node of a human
            SGPath pathToRFoot; // from hip joint to right foot
            SGPath pathToLFoot; // from hip joint to left foot
            SGPath* pathToStickPosPtr;
            JointAction* moveLeftLegPtr;
            JointAction* moveRightLegPtr;
            JointAction* restPtr;
            JointAction* breathePtr;
            StepManager stepManager;
            Point4D forward;
            float maxStepRotation;
            Point4D destination;
            bool isWalking;
            // Affective State
            float anxiety;
            float anger;
            float joy;
            float fear;
            float disgust;
            float surprise;
        private:
    }; // end class declaration
} // end namespace

#endif