VRS - The Virtual Rendering System

version 3.3

physicalnavigation.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 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: physicalnavigation.h 6426 2008-07-04 14:00:57Z Stefan_Maass $

#ifndef VRS_SG_PHYSICALNAVIGATION_H
#define VRS_SG_PHYSICALNAVIGATION_H

#include <vrs/engine.h>
#include <vrs/filtertag.h>
#include <vrs/rayrequest.h>

#include <vrs/sg/canvas.h>
#include <vrs/sg/keyevent.h>
#include <vrs/sg/navigation.h>
#include <vrs/sg/physicalforce.h>

namespace VRS {

class VRS_CORE_API PhysicalNavigation : public Navigation {

public:
        PhysicalNavigation(
                LookAt* lookAt,
        InputEvent::Button button = InputEvent::MouseButton1,
        InputEvent::Modifier must_modifier = InputEvent::NoModifier,
        InputEvent::Modifier must_not_modifier = InputEvent::NoModifier,
                double meterDefinition = 1.0,
                FilterTag* filterTag = NULL,
                Vector gravitationDir = Vector(0.0, -1.0, 0.0),
                PhysicalForce::ForceMode forceMode = PhysicalForce::Spring
        );      
        double getMeterDefinition() const;
        virtual void setMeterDefinition(double);
        Vector getCurrentVelocity() const;
        float getViscosity() const;
        void setViscosity(float);
        void setSlowDownControlEnabled(bool);
        bool slowDownControlEnabled();
    virtual ~PhysicalNavigation();

    VRS_TYPEINFO(PhysicalNavigation, Navigation);
    VRS_SERIALIZABLE_ABSTRACT_CLASS(PhysicalNavigation);

protected:
        virtual void translateInteractionIntoTargetPos(
        Vector& target, Vector& dir,
        float x, float y,
                double time_now, double time_lastCalc
    ) = 0;
        virtual bool validateTargetPosition(Vector& target, const Vector& oldTarget, const Vector& dir);
        virtual void updateLookAt(const Vector& pos, const Vector& dir);
        virtual BehaviorNode::InvalidationHint processKeyEvent(KeyEvent*);
        virtual void storeInitialInteractionParams(int x, int y, ButtonEvent*);
        virtual void storeCurrentInteractionParams(int x, int y, MotionEvent*);
        virtual BehaviorNode::InvalidationHint wakeUpNavigation();
        virtual bool keyCanWakeUpNavigation(KeyEvent*);
        virtual void initPhysicalNavigation(const Vector&);
        virtual bool detectCollisionPoint(Vector& collisionPoint, const Vector& pos, const Vector& dir);
        virtual bool detectGroundPoint(Vector& groundPoint, const Vector& pos);
        virtual bool detectHeight(float& height, const Vector& pos);
        float meterDefinition_;
        Vector position_, velocity_, acceleration_;
        Vector d_position_, d_velocity_, d_acceleration_;
        
        Vector target_;
        Vector direction_;

        enum SlowDownControlState {SDC_DEACTIVATED, SDC_TURNON, SDC_TURNOFF};
        VRS_SERIALIZABLE_CLASS_ENUM(SlowDownControlState);

        SO<FilterTag> filterTag_;                       /* A filter tag is passed as parameter to define which scene objects are regarded
                                                                        as ground terrain. Without filter tag all scene objects define the ground terrain.*/
        Vector gravitationDir_;                 /* Defines the direction of the gravitation, e.g. it defines what "under" an
                                                                        object means. gravitationDir makes a definition of height possible. */
        Canvas* canvas_;


private:
        void updatePhysicalModelData(
        Vector& pos, Vector& vel, Vector& acc,
                const Vector& d_pos, const Vector& d_vel, const Vector& d_acc
    );
        void solveMotionEquations(
        Vector& d_pos, Vector& d_vel, Vector& d_acc,
        const Vector& pos, const Vector& vel, const Vector& acc,
        Vector& targetPos, Vector& oldTargetPos,
        float timestep
    );
        virtual void interpolatePosition(Vector& pos, double now);
protected:      
        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*);

    PhysicalNavigation() { } // only for serialization

        bool forceCalculation_;
        bool navigationIsSleeping_;
private:
        float physical_inverse_mass_;           
        float physical_viscosity_;
        float physical_viscosity_old_;
        SO<PhysicalForce> physical_force_;
        bool thisIsTheFirstCalculation_;
        double time_lastCalc_;
        double time_interactionStopped_;
        double timeout_;
        float time_calcInterval_;
        float referenceMousePos_x_, referenceMousePos_y_;
        float interaction_x_, interaction_y_;
        bool enableSlowDownControl_;
        SlowDownControlState slowDownControl_;



        SO<Engine> engine_;     
        SO<RayRequest> request_;

}; // class PhysicalNavigation

inline bool PhysicalNavigation::slowDownControlEnabled() {return enableSlowDownControl_;}
inline double PhysicalNavigation::getMeterDefinition() const {return (double)meterDefinition_;}
inline float PhysicalNavigation::getViscosity() const {return physical_viscosity_;}

} // namespace VRS

#endif // VRS_SG_PHYSICALNAVIGATION_H

---

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

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