Added beginnings of new TrackballManipulator
This commit is contained in:
Robert Osfield
parent
9097b2f23a
commit
b790fa59a8
@ -139,6 +139,10 @@ SOURCE=..\..\src\osgGA\TrackballManipulator.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\src\osgGA\TrackerManipulator.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\src\osgGA\Version.cpp
|
||||
# End Source File
|
||||
# End Group
|
||||
@ -203,6 +207,10 @@ SOURCE=..\..\Include\osgGA\TrackballManipulator
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\Include\osgGA\TrackerManipulator
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\Include\osgGA\Version
|
||||
# End Source File
|
||||
# End Group
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include <osg/GL>
|
||||
#include <osgProducer/Viewer>
|
||||
|
||||
#include <osg/Transform>
|
||||
#include <osg/MatrixTransform>
|
||||
#include <osg/Billboard>
|
||||
#include <osg/Geode>
|
||||
#include <osg/Group>
|
||||
@ -59,7 +59,10 @@ osg::Node* createLightPointsDatabase()
|
||||
end._position.set(500.0f,-500.0f,0.0f);
|
||||
end._color.set(1.0f,1.0f,1.0f,1.0f);
|
||||
|
||||
osg::Transform* transform = new osg::Transform;
|
||||
osg::MatrixTransform* transform = new osg::MatrixTransform;
|
||||
|
||||
transform->setDataVariance(osg::Object::STATIC);
|
||||
transform->setMatrix(osg::Matrix::scale(0.1,0.1,0.1));
|
||||
|
||||
osg::Vec3 start_delta(0.0f,10.0f,0.0f);
|
||||
osg::Vec3 end_delta(0.0f,10.0f,1.0f);
|
||||
|
||||
@ -18,6 +18,8 @@
|
||||
#include <osgParticle/FireEffect>
|
||||
#include <osgParticle/ParticleSystemUpdater>
|
||||
|
||||
#include <osgGA/TrackerManipulator>
|
||||
|
||||
// for the grid data..
|
||||
#include "../osghangglide/terrain_coords.h"
|
||||
|
||||
@ -59,6 +61,8 @@ osg::Node* createMovingModel(const osg::Vec3& center, float radius)
|
||||
osg::Node* glider = osgDB::readNodeFile("glider.osg");
|
||||
if (glider)
|
||||
{
|
||||
glider->setName("glider");
|
||||
|
||||
const osg::BoundingSphere& bs = glider->getBound();
|
||||
|
||||
float size = radius/bs.radius()*0.3f;
|
||||
@ -81,6 +85,8 @@ osg::Node* createMovingModel(const osg::Vec3& center, float radius)
|
||||
osg::Node* cessna = osgDB::readNodeFile("cessna.osg");
|
||||
if (cessna)
|
||||
{
|
||||
cessna->setName("cessna");
|
||||
|
||||
const osg::BoundingSphere& bs = cessna->getBound();
|
||||
|
||||
osgText::Text* text = new osgText::Text;
|
||||
@ -245,6 +251,29 @@ void build_world(osg::Group *root)
|
||||
}
|
||||
}
|
||||
|
||||
class FindNamedNodeVisitor : public osg::NodeVisitor
|
||||
{
|
||||
public:
|
||||
FindNamedNodeVisitor(const std::string& name):
|
||||
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
|
||||
_name(name) {}
|
||||
|
||||
virtual void apply(osg::Node& node)
|
||||
{
|
||||
if (node.getName()==_name)
|
||||
{
|
||||
_foundNodes.push_back(&node);
|
||||
}
|
||||
traverse(node);
|
||||
}
|
||||
|
||||
typedef std::vector< osg::ref_ptr<osg::Node> > NodeList;
|
||||
|
||||
std::string _name;
|
||||
NodeList _foundNodes;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// main()
|
||||
@ -268,6 +297,8 @@ int main(int argc, char **argv)
|
||||
// set up the value with sensible default event handlers.
|
||||
viewer.setUpViewer(osgProducer::Viewer::STANDARD_SETTINGS);
|
||||
|
||||
|
||||
|
||||
// get details on keyboard and mouse bindings used by the viewer.
|
||||
viewer.getUsage(*arguments.getApplicationUsage());
|
||||
|
||||
@ -294,6 +325,23 @@ int main(int argc, char **argv)
|
||||
// add a viewport to the viewer and attach the scene graph.
|
||||
viewer.setSceneData(root);
|
||||
|
||||
|
||||
FindNamedNodeVisitor fnnv("cessna");
|
||||
root->accept(fnnv);
|
||||
|
||||
if (!fnnv._foundNodes.empty())
|
||||
{
|
||||
osgGA::TrackerManipulator* tm = new osgGA::TrackerManipulator;
|
||||
tm->setTrackNode(fnnv._foundNodes[0].get());
|
||||
|
||||
std::cout<<"Found "<<std::endl;
|
||||
|
||||
unsigned int num = viewer.addCameraManipulator(tm);
|
||||
viewer.selectCameraManipulator(num);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// create the windows and run the threads.
|
||||
viewer.realize();
|
||||
|
||||
|
||||
@ -184,13 +184,13 @@ class SG_EXPORT NodeVisitor : public virtual Referenced
|
||||
* from the top most node applied down the graph to the current node.
|
||||
* Note, the user does not typically call pushNodeOnPath() as it
|
||||
* will be called automatically by the Node::accept() method.*/
|
||||
inline void pushOntoNodePath(Node* node) { _nodePath.push_back(node); }
|
||||
inline void pushOntoNodePath(Node* node) { if (_traversalMode!=TRAVERSE_PARENTS) _nodePath.push_back(node); else _nodePath.insert(_nodePath.begin(),node); }
|
||||
|
||||
/** Method callby osg::Node::accept() method after
|
||||
* a call the NodeVisitor::apply(..).
|
||||
* Note, the user does not typically call pushNodeOnPath() as it
|
||||
* will be called automatically by the Node::accept() method.*/
|
||||
inline void popFromNodePath() { _nodePath.pop_back(); }
|
||||
inline void popFromNodePath() { if (_traversalMode!=TRAVERSE_PARENTS) _nodePath.pop_back(); else _nodePath.erase(_nodePath.begin()); }
|
||||
|
||||
/** Get the non const NodePath from the top most node applied down
|
||||
* to the current Node being visited.*/
|
||||
|
||||
138
include/osgGA/TrackerManipulator
Normal file
138
include/osgGA/TrackerManipulator
Normal file
@ -0,0 +1,138 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
* (at your option) any later version. The full license is in LICENSE file
|
||||
* included with this distribution, and on the openscenegraph.org website.
|
||||
*
|
||||
* 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
|
||||
* OpenSceneGraph Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef OSGGA_TrackerMANIPULATOR
|
||||
#define OSGGA_TrackerMANIPULATOR 1
|
||||
|
||||
#include <osgGA/MatrixManipulator>
|
||||
#include <osg/Quat>
|
||||
|
||||
namespace osgGA{
|
||||
|
||||
class OSGGA_EXPORT TrackerManipulator : public MatrixManipulator
|
||||
{
|
||||
public:
|
||||
|
||||
TrackerManipulator();
|
||||
|
||||
virtual const char* className() const { return "Tracker"; }
|
||||
|
||||
void setTrackNode(osg::Node* node) { _trackNode = node; }
|
||||
osg::Node* getTrackNode() { return _trackNode.get(); }
|
||||
const osg::Node* getTrackNode() const { return _trackNode.get(); }
|
||||
|
||||
|
||||
enum RotationMode
|
||||
{
|
||||
ELEVATION_AZIM_ROLL,
|
||||
ELEVATION_AZIM,
|
||||
};
|
||||
|
||||
void setRotationMode(RotationMode mode);
|
||||
RotationMode getRotationMode() const { return _rotationMode; }
|
||||
|
||||
|
||||
/** set the position of the matrix manipulator using a 4x4 Matrix.*/
|
||||
virtual void setByMatrix(const osg::Matrixd& matrix);
|
||||
|
||||
/** set the position of the matrix manipulator using a 4x4 Matrix.*/
|
||||
virtual void setByInverseMatrix(const osg::Matrixd& matrix) { setByMatrix(osg::Matrixd::inverse(matrix)); }
|
||||
|
||||
/** get the position of the manipulator as 4x4 Matrix.*/
|
||||
virtual osg::Matrixd getMatrix() const;
|
||||
|
||||
/** get the position of the manipulator as a inverse matrix of the manipulator, typically used as a model view matrix.*/
|
||||
virtual osg::Matrixd getInverseMatrix() const;
|
||||
|
||||
/** Get the FusionDistanceMode. Used by SceneView for setting up setereo convergence.*/
|
||||
virtual osgUtil::SceneView::FusionDistanceMode getFusionDistanceMode() const { return osgUtil::SceneView::USE_FUSION_DISTANCE_VALUE; }
|
||||
|
||||
/** Get the FusionDistanceValue. Used by SceneView for setting up setereo convergence.*/
|
||||
virtual float getFusionDistanceValue() const { return _distance; }
|
||||
|
||||
/** Attach a node to the manipulator.
|
||||
Automatically detaches previously attached node.
|
||||
setNode(NULL) detaches previously nodes.
|
||||
Is ignored by manipulators which do not require a reference model.*/
|
||||
virtual void setNode(osg::Node*);
|
||||
|
||||
/** Return node if attached.*/
|
||||
virtual const osg::Node* getNode() const;
|
||||
|
||||
/** Return node if attached.*/
|
||||
virtual osg::Node* getNode();
|
||||
|
||||
/** Move the camera to the default position.
|
||||
May be ignored by manipulators if home functionality is not appropriate.*/
|
||||
virtual void home(const GUIEventAdapter& ea,GUIActionAdapter& us);
|
||||
|
||||
/** Start/restart the manipulator.*/
|
||||
virtual void init(const GUIEventAdapter& ea,GUIActionAdapter& us);
|
||||
|
||||
/** handle events, return true if handled, false otherwise.*/
|
||||
virtual bool handle(const GUIEventAdapter& ea,GUIActionAdapter& us);
|
||||
|
||||
/** Get the keyboard and mouse usage of this manipulator.*/
|
||||
virtual void getUsage(osg::ApplicationUsage& usage) const;
|
||||
|
||||
protected:
|
||||
|
||||
virtual ~TrackerManipulator();
|
||||
|
||||
/** Reset the internal GUIEvent stack.*/
|
||||
void flushMouseEventStack();
|
||||
/** Add the current mouse GUIEvent to internal stack.*/
|
||||
void addMouseEvent(const GUIEventAdapter& ea);
|
||||
|
||||
osg::Vec3d computeCenter() const;
|
||||
|
||||
void computePosition(const osg::Vec3d& eye,const osg::Vec3d& lv,const osg::Vec3d& up);
|
||||
|
||||
/** For the give mouse movement calculate the movement of the camera.
|
||||
Return true is camera has moved and a redraw is required.*/
|
||||
bool calcMovement();
|
||||
|
||||
void trackball(osg::Vec3& axis,double& angle, double p1x, double p1y, double p2x, double p2y);
|
||||
double tb_project_to_sphere(double r, double x, double y);
|
||||
|
||||
|
||||
/** Check the speed at which the mouse is moving.
|
||||
If speed is below a threshold then return false, otherwise return true.*/
|
||||
bool isMouseMoving();
|
||||
|
||||
|
||||
void clampOrientation();
|
||||
|
||||
|
||||
// Internal event stack comprising last three mouse events.
|
||||
osg::ref_ptr<const GUIEventAdapter> _ga_t1;
|
||||
osg::ref_ptr<const GUIEventAdapter> _ga_t0;
|
||||
|
||||
osg::ref_ptr<osg::Node> _node;
|
||||
osg::ref_ptr<osg::Node> _trackNode;
|
||||
|
||||
RotationMode _rotationMode;
|
||||
|
||||
bool _thrown;
|
||||
|
||||
osg::Vec3d _center;
|
||||
osg::Quat _rotation;
|
||||
float _distance;
|
||||
osg::Vec3d _previousUp;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -54,12 +54,12 @@ class OSGPRODUCER_EXPORT Viewer : public OsgCameraGroup, public osgGA::GUIAction
|
||||
DRIVE_MANIPULATOR = 2,
|
||||
FLIGHT_MANIPULATOR = 4,
|
||||
TERRAIN_MANIPULATOR = 8,
|
||||
STATE_MANIPULATOR = 16,
|
||||
HEAD_LIGHT_SOURCE = 32,
|
||||
SKY_LIGHT_SOURCE = 64,
|
||||
STATS_MANIPULATOR = 128,
|
||||
VIEWER_MANIPULATOR = 256,
|
||||
ESCAPE_SETS_DONE = 512,
|
||||
STATE_MANIPULATOR = 32,
|
||||
HEAD_LIGHT_SOURCE = 64,
|
||||
SKY_LIGHT_SOURCE = 128,
|
||||
STATS_MANIPULATOR = 256,
|
||||
VIEWER_MANIPULATOR = 512,
|
||||
ESCAPE_SETS_DONE = 1024,
|
||||
STANDARD_SETTINGS = TRACKBALL_MANIPULATOR|
|
||||
DRIVE_MANIPULATOR |
|
||||
FLIGHT_MANIPULATOR |
|
||||
|
||||
@ -13,6 +13,7 @@ CXXFILES = \
|
||||
SetSceneViewVisitor.cpp\
|
||||
StateSetManipulator.cpp\
|
||||
TerrainManipulator.cpp\
|
||||
TrackerManipulator.cpp\
|
||||
TrackballManipulator.cpp\
|
||||
Version.cpp\
|
||||
|
||||
|
||||
747
src/osgGA/TrackerManipulator.cpp
Normal file
747
src/osgGA/TrackerManipulator.cpp
Normal file
@ -0,0 +1,747 @@
|
||||
#include <osgGA/TrackerManipulator>
|
||||
#include <osg/Quat>
|
||||
#include <osg/Notify>
|
||||
#include <osg/Transform>
|
||||
#include <osgUtil/IntersectVisitor>
|
||||
|
||||
using namespace osg;
|
||||
using namespace osgGA;
|
||||
|
||||
|
||||
class CollectParentPaths : public osg::NodeVisitor
|
||||
{
|
||||
public:
|
||||
CollectParentPaths() :
|
||||
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_PARENTS) {}
|
||||
|
||||
virtual void apply(osg::Node& node)
|
||||
{
|
||||
if (node.getNumParents()==0)
|
||||
{
|
||||
_nodePaths.push_back(getNodePath());
|
||||
}
|
||||
traverse(node);
|
||||
}
|
||||
|
||||
osg::NodePath _nodePath;
|
||||
typedef std::vector< osg::NodePath > NodePathList;
|
||||
NodePathList _nodePaths;
|
||||
};
|
||||
|
||||
TrackerManipulator::TrackerManipulator()
|
||||
{
|
||||
_rotationMode =ELEVATION_AZIM;
|
||||
_distance = 1.0;
|
||||
|
||||
_thrown = false;
|
||||
|
||||
}
|
||||
|
||||
|
||||
TrackerManipulator::~TrackerManipulator()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::setRotationMode(RotationMode mode)
|
||||
{
|
||||
_rotationMode = mode;
|
||||
|
||||
// need to correct rotation.
|
||||
}
|
||||
|
||||
void TrackerManipulator::setNode(osg::Node* node)
|
||||
{
|
||||
_node = node;
|
||||
|
||||
if (_node.get())
|
||||
{
|
||||
const osg::BoundingSphere& boundingSphere=_node->getBound();
|
||||
const float minimumDistanceScale = 0.001f;
|
||||
_minimumDistance = osg::clampBetween(
|
||||
boundingSphere._radius * minimumDistanceScale,
|
||||
0.00001f,1.0f);
|
||||
|
||||
osg::notify(osg::INFO)<<"Setting Tracker manipulator _minimumDistance to "<<_minimumDistance<<std::endl;
|
||||
}
|
||||
if (getAutoComputeHomePosition()) computeHomePosition();
|
||||
}
|
||||
|
||||
|
||||
const osg::Node* TrackerManipulator::getNode() const
|
||||
{
|
||||
return _node.get();
|
||||
}
|
||||
|
||||
|
||||
osg::Node* TrackerManipulator::getNode()
|
||||
{
|
||||
return _node.get();
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::home(const GUIEventAdapter& ,GUIActionAdapter& us)
|
||||
{
|
||||
if (getAutoComputeHomePosition()) computeHomePosition();
|
||||
|
||||
computePosition(_homeEye, _homeCenter, _homeUp);
|
||||
us.requestRedraw();
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::init(const GUIEventAdapter& ,GUIActionAdapter& )
|
||||
{
|
||||
flushMouseEventStack();
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::getUsage(osg::ApplicationUsage& usage) const
|
||||
{
|
||||
usage.addKeyboardMouseBinding("Trackball: Space","Reset the viewing position to home");
|
||||
usage.addKeyboardMouseBinding("Trackball: +","When in stereo, increase the fusion distance");
|
||||
usage.addKeyboardMouseBinding("Trackball: -","When in stereo, reduse the fusion distance");
|
||||
}
|
||||
|
||||
bool TrackerManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
|
||||
{
|
||||
switch(ea.getEventType())
|
||||
{
|
||||
case(GUIEventAdapter::PUSH):
|
||||
{
|
||||
flushMouseEventStack();
|
||||
addMouseEvent(ea);
|
||||
if (calcMovement()) us.requestRedraw();
|
||||
us.requestContinuousUpdate(false);
|
||||
_thrown = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
case(GUIEventAdapter::RELEASE):
|
||||
{
|
||||
if (ea.getButtonMask()==0)
|
||||
{
|
||||
|
||||
if (isMouseMoving())
|
||||
{
|
||||
if (calcMovement())
|
||||
{
|
||||
us.requestRedraw();
|
||||
us.requestContinuousUpdate(true);
|
||||
_thrown = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
flushMouseEventStack();
|
||||
addMouseEvent(ea);
|
||||
if (calcMovement()) us.requestRedraw();
|
||||
us.requestContinuousUpdate(false);
|
||||
_thrown = false;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
flushMouseEventStack();
|
||||
addMouseEvent(ea);
|
||||
if (calcMovement()) us.requestRedraw();
|
||||
us.requestContinuousUpdate(false);
|
||||
_thrown = false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
case(GUIEventAdapter::DRAG):
|
||||
{
|
||||
addMouseEvent(ea);
|
||||
if (calcMovement()) us.requestRedraw();
|
||||
us.requestContinuousUpdate(false);
|
||||
_thrown = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
case(GUIEventAdapter::MOVE):
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
case(GUIEventAdapter::KEYDOWN):
|
||||
if (ea.getKey()==' ')
|
||||
{
|
||||
flushMouseEventStack();
|
||||
_thrown = false;
|
||||
home(ea,us);
|
||||
us.requestRedraw();
|
||||
us.requestContinuousUpdate(false);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case(GUIEventAdapter::FRAME):
|
||||
if (_thrown)
|
||||
{
|
||||
if (calcMovement()) us.requestRedraw();
|
||||
}
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool TrackerManipulator::isMouseMoving()
|
||||
{
|
||||
if (_ga_t0.get()==NULL || _ga_t1.get()==NULL) return false;
|
||||
|
||||
static const float velocity = 0.1f;
|
||||
|
||||
float dx = _ga_t0->getXnormalized()-_ga_t1->getXnormalized();
|
||||
float dy = _ga_t0->getYnormalized()-_ga_t1->getYnormalized();
|
||||
float len = sqrtf(dx*dx+dy*dy);
|
||||
float dt = _ga_t0->time()-_ga_t1->time();
|
||||
|
||||
return (len>dt*velocity);
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::flushMouseEventStack()
|
||||
{
|
||||
_ga_t1 = NULL;
|
||||
_ga_t0 = NULL;
|
||||
}
|
||||
|
||||
|
||||
void TrackerManipulator::addMouseEvent(const GUIEventAdapter& ea)
|
||||
{
|
||||
_ga_t1 = _ga_t0;
|
||||
_ga_t0 = &ea;
|
||||
}
|
||||
|
||||
void TrackerManipulator::setByMatrix(const osg::Matrixd& matrix)
|
||||
{
|
||||
|
||||
osg::Vec3 lookVector(- matrix(2,0),-matrix(2,1),-matrix(2,2));
|
||||
osg::Vec3 eye(matrix(3,0),matrix(3,1),matrix(3,2));
|
||||
|
||||
osg::notify(INFO)<<"eye point "<<eye<<std::endl;
|
||||
osg::notify(INFO)<<"lookVector "<<lookVector<<std::endl;
|
||||
|
||||
if (!_node)
|
||||
{
|
||||
_center = eye+ lookVector;
|
||||
_distance = lookVector.length();
|
||||
matrix.get(_rotation);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// need to reintersect with the Tracker
|
||||
osgUtil::IntersectVisitor iv;
|
||||
|
||||
const osg::BoundingSphere& bs = _node->getBound();
|
||||
float distance = (eye-bs.center()).length() + _node->getBound().radius();
|
||||
osg::Vec3d start_segment = eye;
|
||||
osg::Vec3d end_segment = eye + lookVector*distance;
|
||||
|
||||
//CoordinateFrame coordinateFrame = getCoordinateFrame(_center.x(), _center.y(), _center.z());
|
||||
//osg::notify(INFO)<<"start="<<start_segment<<"\tend="<<end_segment<<"\tupVector="<<getUpVector(coordinateFrame)<<std::endl;
|
||||
|
||||
osg::ref_ptr<osg::LineSegment> segLookVector = new osg::LineSegment;
|
||||
segLookVector->set(start_segment,end_segment);
|
||||
iv.addLineSegment(segLookVector.get());
|
||||
|
||||
_node->accept(iv);
|
||||
|
||||
bool hitFound = false;
|
||||
if (iv.hits())
|
||||
{
|
||||
osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segLookVector.get());
|
||||
if (!hitList.empty())
|
||||
{
|
||||
notify(INFO) << "Hit Tracker ok A"<< std::endl;
|
||||
osg::Vec3d ip = hitList.front().getWorldIntersectPoint();
|
||||
|
||||
_center = ip;
|
||||
|
||||
_distance = (eye-ip).length();
|
||||
|
||||
osg::Matrix rotation_matrix = osg::Matrixd::translate(0.0,0.0,-_distance)*
|
||||
matrix*
|
||||
osg::Matrixd::translate(-_center);
|
||||
|
||||
rotation_matrix.get(_rotation);
|
||||
|
||||
hitFound = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!hitFound)
|
||||
{
|
||||
CoordinateFrame eyePointCoordFrame = getCoordinateFrame( eye );
|
||||
|
||||
// clear the intersect visitor ready for a new test
|
||||
iv.reset();
|
||||
|
||||
osg::ref_ptr<osg::LineSegment> segDowVector = new osg::LineSegment;
|
||||
segLookVector->set(eye+getUpVector(eyePointCoordFrame)*distance,
|
||||
eye-getUpVector(eyePointCoordFrame)*distance);
|
||||
iv.addLineSegment(segLookVector.get());
|
||||
|
||||
_node->accept(iv);
|
||||
|
||||
hitFound = false;
|
||||
if (iv.hits())
|
||||
{
|
||||
osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segLookVector.get());
|
||||
if (!hitList.empty())
|
||||
{
|
||||
notify(INFO) << "Hit Tracker ok B"<< std::endl;
|
||||
osg::Vec3d ip = hitList.front().getWorldIntersectPoint();
|
||||
|
||||
_center = ip;
|
||||
|
||||
_distance = (eye-ip).length();
|
||||
|
||||
_rotation.set(0,0,0,1);
|
||||
|
||||
hitFound = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
_previousUp = getUpVector(coordinateFrame);
|
||||
|
||||
clampOrientation();
|
||||
}
|
||||
|
||||
osg::Vec3d TrackerManipulator::computeCenter() const
|
||||
{
|
||||
if (_trackNode.valid())
|
||||
{
|
||||
CollectParentPaths cpp;
|
||||
|
||||
TrackerManipulator* non_const_this = const_cast<TrackerManipulator*>(this);
|
||||
|
||||
non_const_this->_trackNode->accept(cpp);
|
||||
|
||||
if (!cpp._nodePaths.empty())
|
||||
{
|
||||
osg::Matrix localToWorld;
|
||||
localToWorld = osg::computeLocalToWorld(cpp._nodePaths[0]);
|
||||
|
||||
return _trackNode->getBound().center() * localToWorld;
|
||||
|
||||
}
|
||||
}
|
||||
return osg::Vec3d(0.0,0.0,0.0);
|
||||
}
|
||||
|
||||
osg::Matrixd TrackerManipulator::getMatrix() const
|
||||
{
|
||||
return osg::Matrixd::translate(0.0,0.0,_distance)*osg::Matrixd::rotate(_rotation)*osg::Matrix::translate(computeCenter());
|
||||
}
|
||||
|
||||
osg::Matrixd TrackerManipulator::getInverseMatrix() const
|
||||
{
|
||||
return osg::Matrix::translate(-computeCenter())*osg::Matrixd::rotate(_rotation.inverse())*osg::Matrixd::translate(0.0,0.0,-_distance);
|
||||
}
|
||||
|
||||
void TrackerManipulator::computePosition(const osg::Vec3d& eye,const osg::Vec3d& center,const osg::Vec3d& up)
|
||||
{
|
||||
if (!_node) return;
|
||||
|
||||
// compute rotation matrix
|
||||
osg::Vec3 lv(center-eye);
|
||||
_distance = lv.length();
|
||||
_center = center;
|
||||
|
||||
osg::notify(osg::INFO) << "In compute"<< std::endl;
|
||||
|
||||
if (_node.valid())
|
||||
{
|
||||
bool hitFound = false;
|
||||
|
||||
float distance = lv.length();
|
||||
float maxDistance = distance+2*(eye-_node->getBound().center()).length();
|
||||
osg::Vec3 farPosition = eye+lv*(maxDistance/distance);
|
||||
osg::Vec3 endPoint = center;
|
||||
for(int i=0;
|
||||
!hitFound && i<2;
|
||||
++i, endPoint = farPosition)
|
||||
{
|
||||
// compute the itersection with the scene.
|
||||
osgUtil::IntersectVisitor iv;
|
||||
|
||||
osg::ref_ptr<osg::LineSegment> segLookVector = new osg::LineSegment;
|
||||
segLookVector->set(eye,endPoint );
|
||||
iv.addLineSegment(segLookVector.get());
|
||||
|
||||
_node->accept(iv);
|
||||
|
||||
if (iv.hits())
|
||||
{
|
||||
osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segLookVector.get());
|
||||
if (!hitList.empty())
|
||||
{
|
||||
osg::notify(osg::INFO) << "Hit Tracker ok C"<< std::endl;
|
||||
osg::Vec3d ip = hitList.front().getWorldIntersectPoint();
|
||||
|
||||
_center = ip;
|
||||
_distance = (ip-eye).length();
|
||||
|
||||
hitFound = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// note LookAt = inv(CF)*inv(RM)*inv(T) which is equivilant to:
|
||||
// inv(R) = CF*LookAt.
|
||||
|
||||
osg::Matrixd rotation_matrix = osg::Matrixd::lookAt(eye,center,up);
|
||||
|
||||
rotation_matrix.get(_rotation);
|
||||
_rotation = _rotation.inverse();
|
||||
|
||||
CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
_previousUp = getUpVector(coordinateFrame);
|
||||
|
||||
clampOrientation();
|
||||
}
|
||||
|
||||
bool TrackerManipulator::calcMovement()
|
||||
{
|
||||
// return if less then two events have been added.
|
||||
if (_ga_t0.get()==NULL || _ga_t1.get()==NULL) return false;
|
||||
|
||||
double dx = _ga_t0->getXnormalized()-_ga_t1->getXnormalized();
|
||||
double dy = _ga_t0->getYnormalized()-_ga_t1->getYnormalized();
|
||||
|
||||
|
||||
// return if there is no movement.
|
||||
if (dx==0 && dy==0) return false;
|
||||
|
||||
|
||||
if (_trackNode.valid())
|
||||
{
|
||||
osg::notify(osg::NOTICE)<<"_trackNode="<<_trackNode->getName()<<std::endl;
|
||||
|
||||
CollectParentPaths cpp;
|
||||
_trackNode->accept(cpp);
|
||||
|
||||
osg::notify(osg::NOTICE)<<"number of nodepaths = "<<cpp._nodePaths.size()<<std::endl;
|
||||
|
||||
if (!cpp._nodePaths.empty())
|
||||
{
|
||||
osg::Matrix localToWorld;
|
||||
localToWorld = osg::computeLocalToWorld(cpp._nodePaths[0]);
|
||||
|
||||
_center = _trackNode->getBound().center() * localToWorld;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int buttonMask = _ga_t1->getButtonMask();
|
||||
if (buttonMask==GUIEventAdapter::LEFT_MOUSE_BUTTON)
|
||||
{
|
||||
|
||||
if (_rotationMode==ELEVATION_AZIM_ROLL)
|
||||
{
|
||||
// rotate camera.
|
||||
osg::Vec3 axis;
|
||||
double angle;
|
||||
|
||||
double px0 = _ga_t0->getXnormalized();
|
||||
double py0 = _ga_t0->getYnormalized();
|
||||
|
||||
double px1 = _ga_t1->getXnormalized();
|
||||
double py1 = _ga_t1->getYnormalized();
|
||||
|
||||
|
||||
trackball(axis,angle,px1,py1,px0,py0);
|
||||
|
||||
osg::Quat new_rotate;
|
||||
new_rotate.makeRotate(angle,axis);
|
||||
|
||||
_rotation = _rotation*new_rotate;
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::Matrix rotation_matrix;
|
||||
rotation_matrix.set(_rotation);
|
||||
|
||||
osg::Vec3d lookVector = -getUpVector(rotation_matrix);
|
||||
osg::Vec3d sideVector = getSideVector(rotation_matrix);
|
||||
osg::Vec3d upVector = getFrontVector(rotation_matrix);
|
||||
|
||||
CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
osg::Vec3d localUp = getUpVector(coordinateFrame);
|
||||
//osg::Vec3d localUp = _previousUp;
|
||||
|
||||
|
||||
osg::Vec3d forwardVector = localUp^sideVector;
|
||||
sideVector = forwardVector^localUp;
|
||||
|
||||
forwardVector.normalize();
|
||||
sideVector.normalize();
|
||||
|
||||
osg::Quat rotate_elevation;
|
||||
rotate_elevation.makeRotate(dy,sideVector);
|
||||
|
||||
osg::Quat rotate_azim;
|
||||
rotate_azim.makeRotate(-dx,localUp);
|
||||
|
||||
_rotation = _rotation * rotate_elevation * rotate_azim;
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
else if (buttonMask==GUIEventAdapter::MIDDLE_MOUSE_BUTTON ||
|
||||
buttonMask==(GUIEventAdapter::LEFT_MOUSE_BUTTON|GUIEventAdapter::RIGHT_MOUSE_BUTTON))
|
||||
{
|
||||
|
||||
// pan model.
|
||||
double scale = -0.3f*_distance;
|
||||
|
||||
osg::Matrix rotation_matrix;
|
||||
rotation_matrix.set(_rotation);
|
||||
|
||||
|
||||
// compute look vector.
|
||||
osg::Vec3d lookVector = -getUpVector(rotation_matrix);
|
||||
osg::Vec3d sideVector = getSideVector(rotation_matrix);
|
||||
osg::Vec3d upVector = getFrontVector(rotation_matrix);
|
||||
|
||||
// CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
// osg::Vec3d localUp = getUpVector(coordinateFrame);
|
||||
osg::Vec3d localUp = _previousUp;
|
||||
|
||||
osg::Vec3d forwardVector =localUp^sideVector;
|
||||
sideVector = forwardVector^localUp;
|
||||
|
||||
forwardVector.normalize();
|
||||
sideVector.normalize();
|
||||
|
||||
osg::Vec3d dv = forwardVector * (dy*scale) + sideVector * (dx*scale);
|
||||
|
||||
_center += dv;
|
||||
|
||||
// need to recompute the itersection point along the look vector.
|
||||
|
||||
if (_node.valid())
|
||||
{
|
||||
|
||||
// now reorientate the coordinate frame to the frame coords.
|
||||
CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
|
||||
// need to reintersect with the Tracker
|
||||
osgUtil::IntersectVisitor iv;
|
||||
|
||||
double distance = _node->getBound().radius()*0.1f;
|
||||
osg::Vec3d start_segment = _center + getUpVector(coordinateFrame) * distance;
|
||||
osg::Vec3d end_segment = start_segment - getUpVector(coordinateFrame) * (2.0f*distance);
|
||||
|
||||
osg::notify(INFO)<<"start="<<start_segment<<"\tend="<<end_segment<<"\tupVector="<<getUpVector(coordinateFrame)<<std::endl;
|
||||
|
||||
osg::ref_ptr<osg::LineSegment> segLookVector = new osg::LineSegment;
|
||||
segLookVector->set(start_segment,end_segment);
|
||||
iv.addLineSegment(segLookVector.get());
|
||||
|
||||
_node->accept(iv);
|
||||
|
||||
bool hitFound = false;
|
||||
if (iv.hits())
|
||||
{
|
||||
osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(segLookVector.get());
|
||||
if (!hitList.empty())
|
||||
{
|
||||
notify(INFO) << "Hit Tracker ok"<< std::endl;
|
||||
osg::Vec3d ip = hitList.front().getWorldIntersectPoint();
|
||||
_center = ip;
|
||||
|
||||
hitFound = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!hitFound)
|
||||
{
|
||||
// ??
|
||||
osg::notify(INFO)<<"TrackerManipulator unable to intersect with Tracker."<<std::endl;
|
||||
}
|
||||
|
||||
coordinateFrame = getCoordinateFrame(_center);
|
||||
osg::Vec3d new_localUp = getUpVector(coordinateFrame);
|
||||
|
||||
|
||||
osg::Quat pan_rotation;
|
||||
pan_rotation.makeRotate(localUp,new_localUp);
|
||||
|
||||
if (!pan_rotation.zeroRotation())
|
||||
{
|
||||
_rotation = _rotation * pan_rotation;
|
||||
_previousUp = new_localUp;
|
||||
//osg::notify(osg::NOTICE)<<"Rotating from "<<localUp<<" to "<<new_localUp<<" angle = "<<acos(localUp*new_localUp/(localUp.length()*new_localUp.length()))<<std::endl;
|
||||
|
||||
//clampOrientation();
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::INFO)<<"New up orientation nearly inline - no need to rotate"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
else if (buttonMask==GUIEventAdapter::RIGHT_MOUSE_BUTTON)
|
||||
{
|
||||
|
||||
// zoom model.
|
||||
|
||||
double fd = _distance;
|
||||
double scale = 1.0f+dy;
|
||||
if (fd*scale>_minimumDistance)
|
||||
{
|
||||
|
||||
_distance *= scale;
|
||||
|
||||
} else
|
||||
{
|
||||
_distance = _minimumDistance;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void TrackerManipulator::clampOrientation()
|
||||
{
|
||||
if (_rotationMode==ELEVATION_AZIM)
|
||||
{
|
||||
osg::Matrix rotation_matrix;
|
||||
rotation_matrix.set(_rotation);
|
||||
|
||||
osg::Vec3d lookVector = -getUpVector(rotation_matrix);
|
||||
osg::Vec3d upVector = getFrontVector(rotation_matrix);
|
||||
|
||||
CoordinateFrame coordinateFrame = getCoordinateFrame(_center);
|
||||
osg::Vec3d localUp = getUpVector(coordinateFrame);
|
||||
//osg::Vec3d localUp = _previousUp;
|
||||
|
||||
osg::Vec3d sideVector = lookVector ^ localUp;
|
||||
|
||||
if (sideVector.length()<0.1)
|
||||
{
|
||||
osg::notify(osg::INFO)<<"Side vector short "<<sideVector.length()<<std::endl;
|
||||
|
||||
sideVector = upVector^localUp;
|
||||
sideVector.normalize();
|
||||
|
||||
}
|
||||
|
||||
Vec3d newUpVector = sideVector^lookVector;
|
||||
newUpVector.normalize();
|
||||
|
||||
osg::Quat rotate_roll;
|
||||
rotate_roll.makeRotate(upVector,newUpVector);
|
||||
|
||||
if (!rotate_roll.zeroRotation())
|
||||
{
|
||||
_rotation = _rotation * rotate_roll;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This size should really be based on the distance from the center of
|
||||
* rotation to the point on the object underneath the mouse. That
|
||||
* point would then track the mouse as closely as possible. This is a
|
||||
* simple example, though, so that is left as an Exercise for the
|
||||
* Programmer.
|
||||
*/
|
||||
const float TRACKBALLSIZE = 0.8f;
|
||||
|
||||
/*
|
||||
* Ok, simulate a track-ball. Project the points onto the virtual
|
||||
* trackball, then figure out the axis of rotation, which is the cross
|
||||
* product of P1 P2 and O P1 (O is the center of the ball, 0,0,0)
|
||||
* Note: This is a deformed trackball-- is a trackball in the center,
|
||||
* but is deformed into a hyperbolic sheet of rotation away from the
|
||||
* center. This particular function was chosen after trying out
|
||||
* several variations.
|
||||
*
|
||||
* It is assumed that the arguments to this routine are in the range
|
||||
* (-1.0 ... 1.0)
|
||||
*/
|
||||
void TrackerManipulator::trackball(osg::Vec3& axis,double & angle, double p1x, double p1y, double p2x, double p2y)
|
||||
{
|
||||
/*
|
||||
* First, figure out z-coordinates for projection of P1 and P2 to
|
||||
* deformed sphere
|
||||
*/
|
||||
|
||||
osg::Matrix rotation_matrix(_rotation);
|
||||
|
||||
|
||||
osg::Vec3d uv = osg::Vec3d(0.0,1.0,0.0)*rotation_matrix;
|
||||
osg::Vec3d sv = osg::Vec3d(1.0,0.0,0.0)*rotation_matrix;
|
||||
osg::Vec3d lv = osg::Vec3d(0.0,0.0,-1.0)*rotation_matrix;
|
||||
|
||||
osg::Vec3d p1 = sv*p1x+uv*p1y-lv*tb_project_to_sphere(TRACKBALLSIZE,p1x,p1y);
|
||||
osg::Vec3d p2 = sv*p2x+uv*p2y-lv*tb_project_to_sphere(TRACKBALLSIZE,p2x,p2y);
|
||||
|
||||
/*
|
||||
* Now, we want the cross product of P1 and P2
|
||||
*/
|
||||
|
||||
// Robert,
|
||||
//
|
||||
// This was the quick 'n' dirty fix to get the trackball doing the right
|
||||
// thing after fixing the Quat rotations to be right-handed. You may want
|
||||
// to do something more elegant.
|
||||
// axis = p1^p2;
|
||||
axis = p2^p1;
|
||||
axis.normalize();
|
||||
|
||||
/*
|
||||
* Figure out how much to rotate around that axis.
|
||||
*/
|
||||
double t = (p2-p1).length() / (2.0*TRACKBALLSIZE);
|
||||
|
||||
/*
|
||||
* Avoid problems with out-of-control values...
|
||||
*/
|
||||
if (t > 1.0) t = 1.0;
|
||||
if (t < -1.0) t = -1.0;
|
||||
angle = inRadians(asin(t));
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
|
||||
* if we are away from the center of the sphere.
|
||||
*/
|
||||
double TrackerManipulator::tb_project_to_sphere(double r, double x, double y)
|
||||
{
|
||||
float d, t, z;
|
||||
|
||||
d = sqrt(x*x + y*y);
|
||||
/* Inside sphere */
|
||||
if (d < r * 0.70710678118654752440)
|
||||
{
|
||||
z = sqrt(r*r - d*d);
|
||||
} /* On hyperbola */
|
||||
else
|
||||
{
|
||||
t = r / 1.41421356237309504880;
|
||||
z = t*t / d;
|
||||
}
|
||||
return z;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user