On the synergy between EarthManipulator and osgManipulator::Dragger.

[luohuiiqng]

Hello! I'm currently trying to use the predefined node dragger in my project, and for the most part it works fine. However, when the Dragger was very small and close to the earth surface, I found that only EarthManipulator responded to the left mouse button click and drag event, while osgManipulator::Dragger did not respond. How can I modify them to make them work properly? Thank you!

Here is the dragger extension class I implemented:
.h

#ifndef __NODEAXLE_H__
#define __NODEAXLE_H__

#include <osg/Group>
#include <osg/Node>
#include <osgManipulator/ScaleAxisDragger>
#include <osgManipulator/Dragger>
#include <osgManipulator/TranslateAxisDragger>
#include <osgManipulator/TrackballDragger>
#include <osgUtil/Optimizer>


class NodeAxle: public osg::Group
{
public:
	NodeAxle(osg::Node *node,osg::Vec3d position, std::string &name);
	~NodeAxle() {};

	void setStatus(int s);
protected:
	osgManipulator::Dragger* createDragger(const std::string& name);
	void initDragger(osgManipulator::Dragger* dragger);
private:
	osg::ref_ptr<osgManipulator::Dragger> m_translated;
	osg::ref_ptr<osgManipulator::Dragger> m_rotated;
	osg::ref_ptr<osgManipulator::Dragger> m_scaled;
	osg::ref_ptr<osg::Node> m_node;
	osg::ref_ptr<osg::MatrixTransform> m_transform;
	//0,1,2,3
	int active_status = 0;
};

#endif

.cpp

#include "NodeAxle.h"

NodeAxle::NodeAxle(osg::Node* node, osg::Vec3d position, std::string& name) {
    node->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON);
    m_node = node;
    this->setName(name);

    m_transform = new osg::MatrixTransform;
    m_transform->addChild(node);
    m_transform->setMatrix(osg::Matrix::translate(position));


    m_translated = createDragger("TranslateAxisDragger");
    m_rotated = createDragger("TrackballDragger");
    m_scaled = createDragger("ScaleAxisDragger");
   

    this->addChild(m_transform);
    this->addChild(m_translated);
    this->addChild(m_rotated);
    this->addChild(m_scaled);

    initDragger(m_translated);
    initDragger(m_rotated);
    initDragger(m_scaled);
    osgUtil::Optimizer optimizer;
    optimizer.optimize(this);
    setStatus(1);
}



void NodeAxle::setStatus(int s)
{
    if (s == active_status) {
        return;
    }
    active_status = s;
    if (active_status == 1) {
        
        m_rotated->setNodeMask(0);        
        m_scaled->setNodeMask(0);

        m_scaled->setDraggerActive(false);
        m_rotated->setDraggerActive(false);

        m_translated->setDraggerActive(true);
        m_translated->setHandleEvents(true);
        m_translated->setNodeMask(1);        
    }
    else if (active_status == 2) {
      

        m_rotated->setNodeMask(0);        
        m_translated->setNodeMask(0);   

        m_translated->setDraggerActive(false);
        m_rotated->setDraggerActive(false);


      
        m_scaled->setNodeMask(1);
        m_scaled->setHandleEvents(true);
        m_scaled->setDraggerActive(true);
    }
    else if (active_status == 3) {
           
      
        m_scaled->setNodeMask(0);       
        m_translated->setNodeMask(0); 

        m_scaled->setDraggerActive(false);
        m_translated->setDraggerActive(false);  
        
      
        m_rotated->setNodeMask(1);
        m_rotated->setHandleEvents(true);
        m_rotated->setDraggerActive(true);
    }
    else if (active_status == 0) {
       

        m_scaled->setNodeMask(0);        
        m_translated->setNodeMask(0);        
        m_rotated->setNodeMask(0);

        m_scaled->setDraggerActive(false);
        m_translated->setDraggerActive(false);
        m_rotated->setDraggerActive(false);

        m_scaled->setHandleEvents(true);
        m_translated->setHandleEvents(true);
        m_rotated->setHandleEvents(true);
    }
}

osgManipulator::Dragger* NodeAxle::createDragger(const std::string& name) {
    osgManipulator::Dragger* dragger = 0;    
    if (name == "TranslateAxisDragger") {
        osgManipulator::TranslateAxisDragger* d = new osgManipulator::TranslateAxisDragger;
        d->setupDefaultGeometry();      
        d->setAxisLineWidth(5.0f);        
        d->setPickCylinderRadius(0.05f);       
        d->setConeHeight(0.2f);
        dragger = d;      
    }
    else if ("RotateCylinderDragger" == name)
    {
        osgManipulator::RotateCylinderDragger* d = new osgManipulator::RotateCylinderDragger();
        d->setupDefaultGeometry();
        dragger = d;
    }
    else if ("TrackballDragger" == name)
    {
        osgManipulator::TrackballDragger* d = new osgManipulator::TrackballDragger();
        d->setupDefaultGeometry();
        dragger = d;        
    }
    else if ("RotateSphereDragger" == name)
    {
        osgManipulator::RotateSphereDragger* d = new osgManipulator::RotateSphereDragger();
        d->setupDefaultGeometry();
        dragger = d;
    }
    else if ("ScaleAxisDragger" == name) {
        osgManipulator::ScaleAxisDragger* d = new osgManipulator::ScaleAxisDragger();
        d->setupDefaultGeometry();
        dragger = d;       
    }
    else {
    }
    return dragger;
}

void NodeAxle::initDragger(osgManipulator::Dragger* dragger)
{    
    dragger->setNodeMask(0);
    float scale = m_node->getBound().radius() * 1.6;
    dragger->setMatrix(osg::Matrix::scale(scale, scale, scale) * osg::Matrix::translate(m_transform->getBound().center()));
    dragger->addTransformUpdating(m_transform.get());
    dragger->setHandleEvents(false);
    dragger->setDraggerActive(false);
}

[gwaldron]

Hard to say. How small is "very small"? Maybe you just need to make the pick-geometry sizes bigger, or make them scale up if they get too small. Sorry; I don't have any experience with the osgManipulator toolkit.

[luohuiiqng]

Thanks you!
This problem can indeed be mitigated by magnification!