VRS - The Virtual Rendering System

version 3.3

interactionconcept.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: interactionconcept.h 6753 2010-01-20 16:36:38Z Tassilo_Glander $
//
// $Log$
// Revision 1.6  2006/03/24 13:24:20  schmidt
// removed active_ flag and
// modified passive mode
//
// Revision 1.5  2006/03/15 09:59:45  schmidt
// added active_ flag
//
// Revision 1.4  2005/06/23 13:06:05  buchholz
//  - operator== for viewparameterset added
//  - lastLookat_ added to detect external lookat changes
//
// Revision 1.3  2005/05/08 21:51:41  buchholz
// initparentpointers() added. (needed to allow techniques referenced in
// multiple modes)
//
// Revision 1.2  2005/02/24 17:50:29  glander
// added support of a constrainchecker
//
// Revision 1.1  2005/02/23 14:48:57  glander
// *** empty log message ***
//
// Revision 1.1  2005/02/15 18:29:08  buchholz
// first check-in
//

#ifndef VRS_SG_INTERACTIONCONCEPT_H
#define VRS_SG_INTERACTIONCONCEPT_H

#include <vrs/sg/behaviornode.h>
#include <vrs/vector.h>
#include <vector>

namespace VRS {

class InteractionMode;
class LookAt;
class PhysicalModel;
class PhysicalModelSettings;
class ConstraintChecker;
template <typename S, typename T>
class Callback2;






class VRS_CORE_API InteractionConcept : public BehaviorNode {
    
public:

    InteractionConcept(SO<LookAt> lookAt = NULL);
    
    SO<LookAt> getLookAt() const;
    void setLookAt(SO<LookAt> lookAt);

    void addInteractionMode(SO<InteractionMode> mode);
    
    void removeInteractionMode(SO<InteractionMode> mode);
    
    SO<Iterator<SO<InteractionMode> > > interactionModeIterator() const;
    
    void selectInteractionMode(SO<InteractionMode> mode);    
    
    SO<InteractionMode> getSelectedInteractionMode() const;
    
        virtual void setConstraintChecker(ConstraintChecker* checker);

    virtual ConstraintChecker* getConstraintChecker() const;

    void initParentPointers();

    class VRS_CORE_API ViewParameterSet : public SharedObj {
    public:
        ViewParameterSet(Vector from, Vector to, Vector up);
        ViewParameterSet(SO<ViewParameterSet> source);
        void setFrom(const Vector& from);
        Vector getFrom() const;
        void setTo(const Vector& to);
        Vector getTo() const;
        void setUp(const Vector& up);
        Vector getUp() const;
        void setDirection(const Vector& dir);
        Vector getDirection() const;
        Vector getRight() const;
        void translate(const Vector& dir);
        void rotate(double angle, const Vector& axis);

        
        bool operator==(const ViewParameterSet& other) const;
                
        VRS_TYPEINFO(ViewParameterSet, SharedObj);
        VRS_SERIALIZABLE(ViewParameterSet);

    private:
        ViewParameterSet(); // only for serialization
        Vector from_;
        Vector to_;
        Vector up_;
    };
    
    virtual BehaviorNode::InvalidationHint handle(Event* event);
    
    void brake();
    
    SO<ViewParameterSet> getViewParameters() const;
    
    SO<ViewParameterSet> getPreviousViewParameters() const;
        
    void setMotionStateCallback(VRS::SO<VRS::Callback2<bool,bool> > callback);


    VRS_TYPEINFO(InteractionConcept, BehaviorNode);
    VRS_SERIALIZABLE(InteractionConcept);

private:

    SO<InteractionMode> activeInteractionMode_;
    std::vector<SO<InteractionMode> > interactionModes_;    
    SO<ViewParameterSet> viewParameters_;
    SO<ViewParameterSet> previousViewParameters_; 
    SO<LookAt> lookAt_;
    SO<LookAt> lastLookAt_; // Used to detect, whether the lookat has been changed from outside
    bool passiveMode_; // deactivates physical model as long as external lookat changes are detected.
    SO<PhysicalModel> physicalModel_;
    SO<PhysicalModelSettings> lastSettings_;
    SO<ConstraintChecker> constraintChecker_;
    SO<Callback2<bool, bool> > motionStateChangedCb_;

        bool active_;
    bool modeInitialized_; // If false, the selected mode will be activated with the next event

        SO<ViewParameterSet> viewParametersForStateChangeDetection_;
    bool inMotion_;
        bool inViewDirChange_;
};

inline InteractionConcept::ViewParameterSet::ViewParameterSet(Vector from, Vector to, Vector up) :
from_(from), to_(to), up_(up) {}
inline void InteractionConcept::ViewParameterSet::setFrom(const Vector& from) { from_ = from; }
inline Vector InteractionConcept::ViewParameterSet::getFrom() const { return from_; }
inline void InteractionConcept::ViewParameterSet::setTo(const Vector& to) { to_ = to; }
inline Vector InteractionConcept::ViewParameterSet::getTo() const { return to_; }
inline void InteractionConcept::ViewParameterSet::setUp(const Vector& up) { up_ = up; }
inline Vector InteractionConcept::ViewParameterSet::getUp() const { return up_; }
inline void InteractionConcept::ViewParameterSet::setDirection(const Vector& dir) { to_ = from_ + dir; }
inline Vector InteractionConcept::ViewParameterSet::getDirection() const { return to_ - from_; }
inline void InteractionConcept::ViewParameterSet::translate(const Vector& delta) { from_ += delta; to_ += delta; }
inline Vector InteractionConcept::ViewParameterSet::getRight() const { return up_ * getDirection(); }

} // namespace VRS

#endif // VRS_SG_INTERACTIONCONCEPT_H

---

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

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