VRS - The Virtual Rendering System

version 3.3

gamenavigation.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: gamenavigation.h 6014 2007-08-09 07:51:16Z Konstantin_Baumann $
// $Date: 2007-08-09 09:51:16 +0200 (Thu, 09 Aug 2007) $
// $Revision: 6014 $
// $State$
// $Author: Konstantin_Baumann $
//
// $Log$
// Revision 1.17  2005/01/03 01:43:10  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.16  2004/10/28 14:16:01  basch
// Class comment changed (Doxygen style)
//
// Revision 1.15  2004/06/16 18:09:03  buchholz
// timing adapted to support non-realtime clocks
//
// Revision 1.14  2004/03/12 16:28:41  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.13  2004/02/04 22:29:56  buchholz
// keyTimeout fixed
//
// Revision 1.12  2004/02/02 10:43:58  baumann
// changed unsigned long to unsigned int
//
// Revision 1.11  2004/01/23 14:15:33  buchholz
// it is now possible to enable acceleration via mouse button.
//
// Revision 1.10  2003/08/27 18:07:45  buchholz
//  - new well-defined configuration parameters introduced
//  - get/set-methods for all parameters included
//  - large amounts of comments and explanations included
//  - code re-structured and cleaned up
//  - reasonable error-reactions added (see constructor comment)
//
// Revision 1.9  2003/07/06 16:27:29  buchholz
// Regular movements (onTimer() method) will now be executed multiple times or left out according to the current time. In this way, the movement speed does not longer depend on the regularity of time events.
//
// Revision 1.8  2003/07/04 09:53:22  baumgarten
// removed lookAt (it's a member of the base class already)
// constructor has two additional parameters walkSpeed and accelation
//
// Revision 1.7  2003/04/09 15:11:09  buchholz
// some comments added
//
// Revision 1.6  2003/02/24 17:29:57  buchholz
// bug fix: now key release (if supported by gui) is correctly handled.
//
// Revision 1.5  2003/02/24 13:22:55  buchholz
// bugfix: added destructor, that sets the static "activeNavigation_" to 0.
//
// Revision 1.4  2003/02/24 12:45:20  buchholz
//  - handle return type changed to BehaviorNode::InvalidationHint
//  - added: "launch" feature for plane navigation
//  - some bugs fixed
//  - navigation conflict management (using common base class (navigation.h will follow)
//
// Revision 1.3  2003/02/24 10:05:57  baumann
// changed return type of BehaviorNode::handle() and Manipulator::drag*()
// from "int" to "BehaviorNode::InvalidationHint"
//
// Revision 1.2  2003/02/19 21:24:07  kirsch
// cleaned up includes
//
// Revision 1.1  2003/02/19 15:13:26  buchholz
// some navigation classes
//

#ifndef VRS_SG_GAMENAVIGATION_H
#define VRS_SG_GAMENAVIGATION_H

#include <vrs/vector.h>
#include <vrs/sg/navigation.h>
#include <vrs/sg/inputevent.h>

namespace VRS {

class DirectionInterpolator;
class KeyEvent;
class LookAt;
class TimeEvent;

class VRS_CORE_API GameNavigation : public Navigation {

public:
    
    GameNavigation(
        LookAt* target = NULL,        
        InputEvent::Button button = InputEvent::MouseButton1,
        InputEvent::Modifier must_modifier = InputEvent::NoModifier,
        InputEvent::Modifier must_not_modifier = InputEvent::NoModifier,
        const Vector& onGroundPlane = Vector::origin, 
        double minHeight = 0.01,        
        double refHeight = 1.0,
        double walkSpeed = 0.1, 
        double runSpeed = 0.3,
        double verticalTime = 2.0,
        double horizontalAccelerationTime = 0.3,
        double verticalAccelerationTime = 0.3
    );
    double getSensitivity() const;
    void setSensitivity(double sensitivity = 0.05);
    Vector getGroundPlaneVector() const;
    void setGroundPlaneVector(const Vector& onGroundPlane);
       
    double getMinHeight() const;
    void setMinHeight(double height);

    double getReferenceHeight() const;
    void setReferenceHeight(double height);

    double getWalkSpeed() const;
    void setWalkSpeed(double s);
    
    double getRunSpeed() const;
        void setRunSpeed(double s);
    
    double getVerticalTime() const; 
    void setVerticalTime(double time);

    double getHorizontalAccelerationTime() const;
    void setHorizontalAccelerationTime(double acceleration);

    double getVerticalAccelerationTime() const;
    void setVerticalAccelerationTime(double acceleration);
        
    bool isRunning() const;
        void setKeyTimeout(unsigned int t); 
        void setKeys(unsigned int front, unsigned int back, unsigned int left, unsigned int right,
                        unsigned int up, unsigned int down, unsigned int toggleSpeed, unsigned int turnAround);

        void enableKeys();
        void disableKeys();
        void enableMouseButtonAcceleration(InputEvent::Button button = InputEvent::MouseButton3);
        void disableMouseButtonAcceleration();
    double getHorizontalScaling() const;        
    double getVerticalScaling() const;
    void setScaling(double horizontal = 1.0, double vertical = 1.0);
    virtual BehaviorNode::InvalidationHint dragStart(int x, int y, ButtonEvent*);
    virtual BehaviorNode::InvalidationHint dragMotion(int x, int y, MotionEvent*);
    virtual BehaviorNode::InvalidationHint dragEnd(int x, int y, ButtonEvent*);
        virtual BehaviorNode::InvalidationHint handle(Event*);
    virtual ~GameNavigation();

    VRS_TYPEINFO(GameNavigation, Manipulator);
    
private:

    BehaviorNode::InvalidationHint onTimer(TimeEvent* e);
        BehaviorNode::InvalidationHint onKey(KeyEvent* key);
        BehaviorNode::InvalidationHint turnAround();
    void rotate();


    // configuration variables (cannot changed via mouse or keyboard)
    double walkSpeed_;
        double runSpeed_;
    double verticalTime_;
    
    double minHeight_;
    double refHeight_;
        
    double horizontalAccelerationTime_;
        double verticalAccelerationTime_;

    double horizontalScaling_;
    double verticalScaling_;

    double sensitivity_;
    
    Vector onGroundPlane_;

    int keyTimeout_;

    // control keys
    unsigned int frontKey_;
        unsigned int backKey_;
        unsigned int rightKey_;
        unsigned int leftKey_;
        unsigned int upKey_;
        unsigned int downKey_;
        unsigned int runKey_;
        unsigned int turnAroundKey_;
    bool enableKeys_;

    // state variables    
    bool running_;
    
    bool forwardPressed_;   // key states
        bool backwardPressed_;
        bool leftPressed_;
        bool rightPressed_;
        bool upPressed_;
        bool downPressed_;
        
    double currentForwardSpeed_;    // can be negative
        double currentSidewardSpeed_;   // positive values for movement to the right
    double verticalSpeedAmount_;    // controls the vertical acceleration. 
                                                    
    // key timeouts
    int forwardTimeout_;
        int sidewardTimeout_;
        int upDownTimeout_;

        // other                        
    int lastX_;
    int lastY_;
        double dx_;
    double dy_;    
        int turnAroundSteps_; // countdown for the turn-around rotation. 
        
        SO<DirectionInterpolator> interpol_;

        static const double MaxAltitude; // threshold angle to avoid degenerated lookats    

        InputEvent::Button mouseButtonAccelerationButton_;
        bool enableMouseButtonAcceleration_;
    bool accelerationButtonPressed_;

    double elapsedTime_;
};

inline double GameNavigation::getSensitivity() const { return sensitivity_; }
inline Vector GameNavigation::getGroundPlaneVector() const { return onGroundPlane_; }
inline double GameNavigation::getMinHeight() const { return minHeight_; }
inline double GameNavigation::getReferenceHeight() const { return refHeight_; }
inline double GameNavigation::getWalkSpeed() const { return walkSpeed_; }
inline double GameNavigation::getRunSpeed() const { return runSpeed_; }
inline double GameNavigation::getVerticalTime() const { return verticalTime_; }
inline double GameNavigation::getHorizontalAccelerationTime() const { return horizontalAccelerationTime_; }
inline double GameNavigation::getVerticalAccelerationTime() const { return verticalAccelerationTime_; }
inline bool GameNavigation::isRunning() const { return running_; }
inline double GameNavigation::getHorizontalScaling() const { return horizontalScaling_; }
inline double GameNavigation::getVerticalScaling() const { return verticalScaling_; }

} // namespace VRS

#endif // VRS_SG_GAMENAVIGATION_H

---

Generated on Wed May 23 06:00:12 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact