void FPSViewController::handleMouseEvent(ViewportMouseEvent& event)
{
if ( event.shift() )
{
setStatus( "<b>Left-Click:</b> Move X/Y. <b>Right-Click:</b>: Move Z." );
}
else
{
setStatus( "<b>Left-Click:</b> Rotate. <b>Middle-Click:</b> Move X/Y. <b>Right-Click:</b>: Zoom. <b>Shift</b>: More options." );
}
bool moved = false;
int32_t diff_x = 0;
int32_t diff_y = 0;
if( event.type == QEvent::MouseMove )
{
diff_x = event.x - event.last_x;
diff_y = event.y - event.last_y;
moved = true;
}
if( event.left() && !event.shift() )
{
setCursor( Rotate3D );
yaw( -diff_x*0.005 );
pitch( diff_y*0.005 );
}
else if( event.middle() || ( event.shift() && event.left() ))
{
setCursor( MoveXY );
move( diff_x*0.01, -diff_y*0.01, 0.0f );
}
else if( event.right() )
{
setCursor( MoveZ );
move( 0.0f, 0.0f, diff_y*0.1 );
}
else
{
setCursor( event.shift() ? MoveXY : Rotate3D );
}
if ( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
move( 0.0f, 0.0f, -diff * 0.01 );
moved = true;
}
if (moved)
{
context_->queueRender();
}
}
int PoseTool::processMouseEvent( ViewportMouseEvent& event )
{
int flags = 0;
if( event.leftDown() )
{
ROS_ASSERT( state_ == Position );
Ogre::Vector3 intersection;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, intersection ))
{
pos_ = intersection;
arrow_->setPosition( pos_ );
state_ = Orientation;
flags |= Render;
}
}
else if( event.type == QEvent::MouseMove && event.left() )
{
if( state_ == Orientation )
{
//compute angle in x-y plane
Ogre::Vector3 cur_pos;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, cur_pos ))
{
double angle = atan2( cur_pos.y - pos_.y, cur_pos.x - pos_.x );
arrow_->getSceneNode()->setVisible( true );
//we need base_orient, since the arrow goes along the -z axis by default (for historical reasons)
Ogre::Quaternion orient_x = Ogre::Quaternion( Ogre::Radian(-Ogre::Math::HALF_PI), Ogre::Vector3::UNIT_Y );
arrow_->setOrientation( Ogre::Quaternion( Ogre::Radian(angle), Ogre::Vector3::UNIT_Z ) * orient_x );
flags |= Render;
}
}
}
else if( event.leftUp() )
{
if( state_ == Orientation )
{
//compute angle in x-y plane
Ogre::Vector3 cur_pos;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, cur_pos ))
{
double angle = atan2( cur_pos.y - pos_.y, cur_pos.x - pos_.x );
onPoseSet(pos_.x, pos_.y, angle);
flags |= (Finished|Render);
}
}
}
return flags;
}
void XYOrbitViewController::handleMouseEvent(ViewportMouseEvent& event)
{
if ( event.shift() )
{
setStatus( "<b>Left-Click:</b> Move X/Y. <b>Right-Click:</b>: Zoom." );
}
else
{
setStatus( "<b>Left-Click:</b> Rotate. <b>Middle-Click:</b> Move X/Y. <b>Right-Click:</b>: Move Z. <b>Shift</b>: More options." );
}
int32_t diff_x = 0;
int32_t diff_y = 0;
bool moved = false;
if( event.type == QEvent::MouseButtonPress )
{
focal_shape_->getRootNode()->setVisible(true);
moved = true;
}
else if( event.type == QEvent::MouseButtonRelease )
{
focal_shape_->getRootNode()->setVisible(false);
moved = true;
}
else if( event.type == QEvent::MouseMove )
{
diff_x = event.x - event.last_x;
diff_y = event.y - event.last_y;
moved = true;
}
if( event.left() && !event.shift() )
{
setCursor( Rotate3D );
yaw( diff_x*0.005 );
pitch( -diff_y*0.005 );
}
else if( event.middle() || (event.left() && event.shift()) )
{
setCursor( MoveXY );
// handle mouse movement
int width = event.viewport->getActualWidth();
int height = event.viewport->getActualHeight();
Ogre::Ray mouse_ray = event.viewport->getCamera()->getCameraToViewportRay( event.x / (float) width,
event.y / (float) height );
Ogre::Ray last_mouse_ray =
event.viewport->getCamera()->getCameraToViewportRay( event.last_x / (float) width,
event.last_y / (float) height );
Ogre::Vector3 last_intersect, intersect;
if( intersectGroundPlane( last_mouse_ray, last_intersect ) &&
intersectGroundPlane( mouse_ray, intersect ))
{
Ogre::Vector3 motion = last_intersect - intersect;
// When dragging near the horizon, the motion can get out of
// control. This throttles it to an arbitrary limit per mouse
// event.
float motion_distance_limit = 1; /*meter*/
if( motion.length() > motion_distance_limit )
{
motion.normalise();
motion *= motion_distance_limit;
}
focal_point_property_->add( motion );
emitConfigChanged();
}
}
else if( event.right() )
{
setCursor( Zoom );
zoom( -diff_y * 0.1 * (distance_property_->getFloat() / 10.0f) );
}
else
{
setCursor( event.shift() ? MoveXY : Rotate3D );
}
if( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
zoom( diff * 0.001 * distance_property_->getFloat() );
moved = true;
}
if( moved )
{
context_->queueRender();
}
}
void InteractiveMarkerControl::handleMouseEvent( ViewportMouseEvent& event )
{
// * check if this is just a receive/lost focus event
// * try to hand over the mouse event to the parent interactive marker
// * otherwise, execute mouse move handling
// handle receive/lose focus
if( event.type == QEvent::FocusIn )
{
has_focus_ = true;
std::set<Ogre::Pass*>::iterator it;
setHighlight( HOVER_HIGHLIGHT );
event.panel->setCursor( cursor_ );
}
else if( event.type == QEvent::FocusOut )
{
has_focus_ = false;
setHighlight(0.0);
return;
}
// change dragging state
switch( interaction_mode_ )
{
case visualization_msgs::InteractiveMarkerControl::BUTTON:
if( event.leftUp() )
{
Ogre::Vector3 point_rel_world;
bool got_3D_point = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, point_rel_world );
visualization_msgs::InteractiveMarkerFeedback feedback;
feedback.event_type = visualization_msgs::InteractiveMarkerFeedback::BUTTON_CLICK;
feedback.control_name = name_;
feedback.marker_name = parent_->getName();
parent_->publishFeedback( feedback, got_3D_point, point_rel_world );
}
break;
case visualization_msgs::InteractiveMarkerControl::MOVE_AXIS:
case visualization_msgs::InteractiveMarkerControl::MOVE_PLANE:
case visualization_msgs::InteractiveMarkerControl::MOVE_ROTATE:
case visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS:
if( event.leftDown() )
{
parent_->startDragging();
dragging_ = true;
drag_viewport_ = event.viewport;
recordDraggingInPlaceEvent( event );
if( ! context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, grab_point_ ))
{
// If we couldn't get a 3D point for the grab, just use the
// current relative position of the control frame.
grab_point_ = control_frame_node_->getPosition();
}
else
{
// If we could get a 3D point for the grab, convert it from
// the world frame to the reference frame (in case those are different).
grab_point_ = reference_node_->convertWorldToLocalPosition(grab_point_);
}
grab_pixel_.x = event.x;
grab_pixel_.y = event.y;
parent_position_at_mouse_down_ = parent_->getPosition();
parent_orientation_at_mouse_down_ = parent_->getOrientation();
if( orientation_mode_ == visualization_msgs::InteractiveMarkerControl::VIEW_FACING &&
drag_viewport_ )
{
updateControlOrientationForViewFacing( drag_viewport_ );
}
control_frame_orientation_at_mouse_down_ = control_frame_node_->getOrientation();
rotation_at_mouse_down_ = rotation_;
rotation_axis_ = control_frame_node_->getOrientation() * control_orientation_.xAxis();
// Find rotation_center = 3D point closest to grab_point_ which is
// on the rotation axis, relative to the reference frame.
Ogre::Vector3 rotation_center_rel_ref = closestPointOnLineToPoint( parent_->getPosition(),
rotation_axis_,
grab_point_ );
Ogre::Matrix4 reference_rel_control_frame;
reference_rel_control_frame.makeInverseTransform( control_frame_node_->getPosition(),
Ogre::Vector3::UNIT_SCALE,
control_frame_node_->getOrientation() );
rotation_center_rel_control_ = reference_rel_control_frame * rotation_center_rel_ref;
grab_point_rel_control_ = reference_rel_control_frame * grab_point_;
}
if( event.leftUp() )
{
dragging_ = false;
drag_viewport_ = NULL;
parent_->stopDragging();
}
break;
default:
break;
}
if( event.leftDown() )
{
setHighlight( ACTIVE_HIGHLIGHT );
}
else if( event.leftUp() )
{
setHighlight( HOVER_HIGHLIGHT );
}
if (!parent_->handleMouseEvent(event, name_))
{
if( event.type == QEvent::MouseMove && event.left() )
{
recordDraggingInPlaceEvent( event );
handleMouseMovement( event );
}
}
}
