VRS - The Virtual Rendering System

version 3.3

jumpnavigation.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 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: jumpnavigation.h 6014 2007-08-09 07:51:16Z Konstantin_Baumann $
//
// $Log$
// Revision 1.25  2005/09/07 12:05:55  buchholz
// setKeyCodes extended by modifiers
//
// Revision 1.24  2005/07/15 12:08:27  baumann
// added "endUp" parameter to initPath()
//
// Revision 1.23  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.22  2004/11/21 19:42:17  baumann
// alternative interpolation technique implemented
//
// Revision 1.21  2004/11/08 10:35:02  schmidt
// added initMultiPathStep() again
//
// Revision 1.20  2004/10/28 14:16:01  basch
// Class comment changed (Doxygen style)
//
// Revision 1.19  2004/10/07 16:54:52  buchholz
//  - ascii-pathfile export added
//
// Revision 1.18  2004/09/07 10:04:45  schmidt
// removed initMultiStepPath()
// added members accelerate_ and decelerate_
// changed getLambda() to fly with constant speed, if desired
//
// Revision 1.17  2004/08/26 10:53:55  schmidt
// added method initMultiStepPath() for
// jumping to multiple destinations successively
//
// Revision 1.16  2004/08/26 05:50:41  baumann
// changed onTimer()  impl. to not rely on frame counting anymore
//
// Revision 1.15  2004/08/19 13:26:17  gerber
// added member duration_ and set- get-method to configure pathtime
//
// Revision 1.14  2004/08/13 09:13:34  buchholz
// pathActive() and stopPath() methods added
//
// Revision 1.13  2004/06/24 07:06:44  baumann
// changed ctor parameter "pathTime" to "duration" specified in seconds
//
// Revision 1.12  2004/03/12 16:28:41  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.11  2004/02/02 10:20:37  baumann
// chnaged mod key for storing of camera positions from "Shift" to "Ctrl"
//
// Revision 1.10  2004/01/30 12:38:15  baumann
// changed unsigned long to unsigned int
//
// Revision 1.9  2004/01/19 11:43:58  baumann
// serialization mechanism improved
//
// Revision 1.8  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.7  2003/07/05 17:32:03  baumann
// serialization added
//

#ifndef VRS_SG_JUMPNAVIGATION_H
#define VRS_SG_JUMPNAVIGATION_H

#include <vrs/sg/inputevent.h>
#include <vrs/sg/keyevent.h>
#include <vrs/sg/navigation.h>
#include <vrs/sg/timeevent.h>
#include <vrs/directioninterpolator.h>
#include <vrs/lookat.h>
#include <vrs/time.h>

namespace VRS {

class VRS_CORE_API JumpNavigation : public Navigation {

public:
    JumpNavigation(
        const Vector& onPlane,
        LookAt* lookAt,
        double duration = 6.0 // seconds
    );
    void setScaling(double horizontal = 1.0, double vertical = 1.0);
    double getHorizontalScaling() const;
    double getVerticalScaling() const;
    void setKeyCodes(
        Iterator<unsigned int>* startKeys, 
        Iterator<unsigned int>* storeKeys,
        InputEvent::Modifier startModifier = InputEvent::NoModifier,
        InputEvent::Modifier storeModifier = InputEvent::Ctrl
        );
    void initPath(const std::string& camName, bool accelerate = true, bool decelerate = true);
    void initPath(const Vector& endPos, const Vector& endDir, bool accelerate = true, bool decelerate = true, const Vector& endUp = Vector(0.0, 1.0, 0.0));
        void initMultiStepPath(Array<Vector>* positions, Array<Vector>* directions);
    void enableKeys();
    void disableKeys();
    void setNavMode(Navigation::NavMode mode);

        void setDuration(double duration);
        double getDuration() const;

    bool pathActive() const;

    void stopPath();

    virtual BehaviorNode::InvalidationHint handle(Event* event);
    /*< Event handling method. These method should (and need) not be called
        explicitly be the user. */

    void savePath(const std::string& fileName);
    void loadPath(const std::string& fileName);
    void enableLoadSaveKeys(const std::string& filename, unsigned char loadKey, unsigned char saveKey);
    void disableLoadSaveKeys();

    static void useAlternativeImplementation(bool yesNo);


    VRS_TYPEINFO(JumpNavigation, Navigation);
    VRS_SERIALIZABLE(JumpNavigation);

protected:
    JumpNavigation(); // only for serialization

private:
    BehaviorNode::InvalidationHint onTimer(double progress);
    BehaviorNode::InvalidationHint onKey(KeyEvent* e);
    void initPath(int index);

    SO<Array<bool> > targetStored_;
    SO<Array<Vector> > targetPos_;
    SO<Array<Vector> > targetDir_;

        bool interpolateUp_;

    SO<DirectionInterpolator> interpolDir_;
    SO<DirectionInterpolator> interpolUp_;
    VRS::Vector bezierPoints_[4];

    bool active_;

    InputEvent::Modifier startModifier_;
    InputEvent::Modifier storeModifier_;
    
    double arcHeight_;
    Vector onPlane_;
    int currentTarget_;
    bool shortPath_;
    double shortPathLengthLimit_;

        double duration_;

    double horScaling_;
    double vertScaling_;
    
    SO<Iterator<unsigned int> > startKeys_;
    SO<Iterator<unsigned int> > storeKeys_;

    Vector currentTargetPos_;
    Vector currentTargetDir_;
 
    bool enableKeys_;

    bool startTimeStampIsValid_;
    VRSTime startTimeStamp_;

        bool accelerate_;
        bool decelerate_; 

    // for loading and saving the path as ASCII
    static std::string KeyString;
    static std::string PathHeaderString;
    std::string pathASCIIFileName_;
    unsigned char loadKey_;
    unsigned char saveKey_;
    bool loadSaveEnabled_;    

        // for multi step paths
        bool multiStepPath_;
        SO<Array<Vector> > multiStepPositions_;
        SO<Array<Vector> > multiStepDirections_;
        unsigned int currentStep_;
};

} // namespace VRS

#endif // VRS_SG_JUMPNAVIGATION_H

---

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

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