• osgEarth示例分析——osgearth_manip

    前言

    本示例主要演示osgEarth的事件处理的用法，内容比较多，这部分功能也很重要。

    输入命令依然采用china-simple.earth的示例，加上了模型，但是模型并没有看到，可能是因为模型没有放大太小的原因。在代码中设置了不加载模型的话，会绘制两个半圆。

    1. // 加载模型，但是看不到，估计是模型太小，需要放大
    2. osgearth_manipd.exe earth_image/china-simple.earth --model axes.osgt
    3.  
    4. // 并没有加载模型
    5. osgearth_manipd.exe earth_image/china-simple.earth --model modelToLoad
    6.  
    7. // 不加载模型，会默认创建一个半球，距离太远的话，半球也看不到
    8. osgearth_manipd.exe earth_image/china-simple.earth

    执行效果

    按下W键，开启坐标，也就是黄色的两条线，交点始终跟随 Thing 1 节点。

    按键说明

    左上角操作说明
    *左键按住左键拖动地球*u看不出来，没啥变化
    *中键按住中键可以旋转地球*o切换操作器，地球会有大小变化
    *右键按住右键前后移动，缩放地球*8视角绑定thing 1，也可以说跟踪
    *

    右键/左键

    双击

    		越来越远/越来越近*9视角绑定thing 2，也可以说跟踪
    *滚轮滚动视角远近控制*t地球三种转动状态的切换
    *arrows

    shift+上/下/左/右键，

    好像没啥作用

    		*b解除绑定 '8' ‘9’，，或者说解除跟踪
    *shift+左键看不出来，没啥变化*a看不出来，没啥变化
    *q看不出来，没啥变化
    *k看不出来，没啥变化
    *L看不出来，没啥变化
    *j定位到可以看见一组点的视点
    *W绘制两条线，交点始终定位在thing 1上，屏幕坐标系

    [注] 必须在英文下输入，如果没有注意，在中文状态下输入字符，地球会被卡住。此时只能退出重新运行程序。

    thing1 thing 2,这两个文本是移动的。

    代码分析

    1. #include 
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26.  
    27. using namespace osgEarth::Util;
    28. using namespace osgEarth::Util::Controls;
    29. using namespace osgEarth::Annotation;
    30.  
    31. #define D2R (osg::PI/180.0)
    32. #define R2D (180.0/osg::PI)
    33.  
    34. namespace
    35. {
    36.     /**
    37.      * Tether callback test.是否绑定
    38.      */
    39.     struct TetherCB : public EarthManipulator::TetherCallback
    40.     {
    41.         void operator()(osg::Node* node)
    42.         {
    43.             if ( node ) {
    44.                 OE_WARN << "Tether on\n";
    45.             }
    46.             else {
    47.                 OE_WARN << "Tether off\n";
    48.             }
    49.         }
    50.     };
    51.  
    52.     /**
    53.      * Builds our help menu UI.创建左上角的说明文档
    54.      */
    55.     Container* createHelp( osgViewer::View* view )
    56.     {
    57.         const char* text[] =
    58.         {
    59.             "left mouse :",        "pan",
    60.             "middle mouse :",      "rotate",
    61.             "right mouse :",       "continuous zoom",
    62.             "double-click :",      "zoom to point",
    63.             "scroll wheel :",      "zoom in/out",
    64.             "arrows :",            "pan",
    65.             //"1-6 :",               "fly to preset viewpoints",
    66.             "shift-left-mouse :",  "locked pan",
    67.             "u :",                 "toggle azimuth lock",
    68.             "o :",                 "toggle perspective/ortho",
    69.             "8 :",                 "Tether to thing 1",
    70.             "9 :",                 "Tether to thing 2",
    71.             "t :",                 "cycle tethermode",
    72.             "b :",                 "break tether",
    73.             "a :",                 "toggle viewpoint arcing",
    74.             "q :",                 "toggle throwing",
    75.             "k :",                 "toggle collision",
    76.             "L :",                 "toggle log depth buffer"
    77. 			//"W :",				   "坐标系",		// 源代码并没有这两个提示
    78. 			//"j :",				   "定位到指定点组的视点",
    79.         };
    80.  
    81.         Grid* g = new Grid();// 创建网格
    82.         unsigned i, c, r;
    83. 		std::cout << sizeof(text) << std::endl;		// 存储所有指针占位多少
    84. 		std::cout << sizeof(text[0]) << std::endl;	// 每个指针占位多少
    85.         for( i=0; i<sizeof(text)/sizeof(text[0]); ++i )
    86.         {
    87.             c = i % 2;
    88.             r = i / 2;
    89.             g->setControl( c, r, new LabelControl(text[i]) );// 两列c，i行r,显示label控件
    90.         }
    91.  
    92.         VBox* v = new VBox();
    93.         v->addControl( g );// 将网格控件放入VBox控件中
    94.  
    95.         return v;
    96.     }
    97.  
    98.  
    99.     /**
    100.      * Some preset viewpoints to show off the setViewpoint function.
    101.      */
    102.     static Viewpoint VPs[] = {
    103.         Viewpoint( "Africa",            0.0,   0.0, 0.0, 0.0, -90.0, 10e6 ),
    104.         Viewpoint( "California",     -121.0,  34.0, 0.0, 0.0, -90.0, 6e6 ),
    105.         Viewpoint( "Europe",            0.0,  45.0, 0.0, 0.0, -90.0, 4e6 ),
    106.         Viewpoint( "Washington DC",   -77.0,  38.0, 0.0, 0.0, -90.0, 1e6 ),
    107.         Viewpoint( "Australia",       135.0, -20.0, 0.0, 0.0, -90.0, 2e6 ),
    108.         Viewpoint( "Boston",         -71.096936, 42.332771, 0, 0.0, -90, 1e5 )
    109.     };
    110.  
    111.  
    112.     /**
    113.      * Handler that demonstrates the "viewpoint" functionality in 
    114.      *  osgEarthUtil::EarthManipulator. Press a number key to fly to a viewpoint.
    115.      */
    116.     struct FlyToViewpointHandler : public osgGA::GUIEventHandler 
    117.     {
    118.         FlyToViewpointHandler( EarthManipulator* manip ) : _manip(manip) { }
    119.  
    120.         bool handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
    121.         {
    122.             if ( ea.getEventType() == ea.KEYDOWN && ea.getKey() >= '1' && ea.getKey() <= '6' )
    123.             {
    124.                 _manip->setViewpoint( VPs[ea.getKey()-'1'], 4.0 );// 根据设置好的位置，123456定位不同的地点
    125.                 aa.requestRedraw();
    126.             }
    127.             return false;
    128.         }
    129.  
    130.         osg::observer_ptr _manip;
    131.     };
    132.     
    133.  
    134.     /**
    135.      * Toggles the logarithmic depth buffer切换对数深度缓冲区
    136.      */
    137.     struct ToggleLDB : public osgGA::GUIEventHandler
    138.     {
    139.         ToggleLDB(char key) : _key(key), _installed(false) { }// key=L
    140.  
    141.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    142.         {
    143.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    144.             {
    145.                 if ( !_installed )
    146.                 {
    147.                     _nfratio = aa.asView()->getCamera()->getNearFarRatio();// 获取到近/远率
    148.                     _ldb.install(aa.asView()->getCamera());
    149.                     aa.asView()->getCamera()->setNearFarRatio(0.00001);
    150.                 }
    151.                 else
    152.                 {
    153.                     _ldb.uninstall(aa.asView()->getCamera());
    154.                     aa.asView()->getCamera()->setNearFarRatio(_nfratio);
    155.                 }
    156.  
    157.                 _installed = !_installed;// 每次切换
    158.                 return true;
    159.             }
    160.             return false;
    161.         }
    162.  
    163.         void getUsage(osg::ApplicationUsage& usage) const
    164.         {
    165.             using namespace std;
    166.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle LDB"));
    167.         }
    168.  
    169.         char _key;
    170.         float _nfratio;
    171.         bool _installed;
    172.         osgEarth::Util::LogarithmicDepthBuffer _ldb;
    173.     };
    174.  
    175.     /**
    176.      * Toggles screen space layout on the sismulated objects 切换模拟对象的屏幕空间布局
    177.      */
    178.     struct ToggleSSL : public osgGA::GUIEventHandler
    179.     {
    180.         ToggleSSL(osg::Group* g, char key) : _group(g), _key(key), _installed(false) { }// key=)
    181.  
    182.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    183.         {
    184.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    185.             {
    186.                 _installed = !_installed;
    187.                 ScreenSpaceLayout::setDeclutteringEnabled(_installed);// 启动或禁用清理
    188.                 return true;
    189.             }
    190.             return false;
    191.         }
    192.  
    193.         void getUsage(osg::ApplicationUsage& usage) const
    194.         {
    195.             using namespace std;
    196.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle SSL"));
    197.         }
    198.  
    199.         char _key;
    200.         osg::Group* _group;
    201.         bool _installed;
    202.     };
    203.  
    204.     /**
    205.      * Handler to toggle "azimuth locking", which locks the camera's relative Azimuth
    206.      * while panning. For example, it can maintain "north-up" as you pan around. The
    207.      * caveat is that when azimuth is locked you cannot cross the poles.
    208.      */
    209.     struct LockAzimuthHandler : public osgGA::GUIEventHandler // 锁定/解锁 方位角
    210.     {
    211.         LockAzimuthHandler(char key, EarthManipulator* manip) // 传入key = u
    212.             : _key(key), _manip(manip) { }
    213.  
    214.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    215.         {
    216.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    217.             {
    218.                 bool lockAzimuth = _manip->getSettings()->getLockAzimuthWhilePanning();
    219. 				std::cout << "按下 u" << std::endl;// 确实收到消息，但是在操作上并没有看到所定方位角
    220.                 _manip->getSettings()->setLockAzimuthWhilePanning(!lockAzimuth);// 设置为当前状态相反的状态
    221.                 aa.requestRedraw();
    222.                 return true;
    223.             }
    224.             return false;
    225.         }
    226.  
    227.         void getUsage(osg::ApplicationUsage& usage) const
    228.         {
    229.             using namespace std;
    230.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle azimuth locking"));
    231.         }
    232.  
    233.         char _key;
    234.         osg::ref_ptr _manip;
    235.     };
    236.  
    237.  
    238.     /**
    239.      * Handler to toggle "viewpoint transition arcing", which causes the camera to "arc"
    240.      * as it travels from one viewpoint to another.
    241.      */
    242.     struct ToggleArcViewpointTransitionsHandler : public osgGA::GUIEventHandler
    243.     {
    244.         ToggleArcViewpointTransitionsHandler(char key, EarthManipulator* manip)
    245.             : _key(key), _manip(manip) { }// key=a
    246.  
    247.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    248.         {
    249.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    250.             {
    251.                 bool arc = _manip->getSettings()->getArcViewpointTransitions();
    252. 				std::cout << "按下 a" << std::endl;// 确实收到消息，但是没看出什么变化
    253.                 _manip->getSettings()->setArcViewpointTransitions(!arc);
    254.                 aa.requestRedraw();
    255.                 return true;
    256.             }
    257.             return false;
    258.         }
    259.  
    260.         void getUsage(osg::ApplicationUsage& usage) const
    261.         {
    262.             using namespace std;
    263.             usage.addKeyboardMouseBinding(string(1, _key), string("Arc viewpoint transitions"));
    264.         }
    265.  
    266.         char _key;
    267.         osg::ref_ptr _manip;
    268.     };
    269.  
    270.  
    271.     /**
    272.      * Toggles the throwing feature.切换投掷功能。
    273.      */
    274.     struct ToggleThrowingHandler : public osgGA::GUIEventHandler
    275.     {
    276.         ToggleThrowingHandler(char key, EarthManipulator* manip)
    277.             : _key(key), _manip(manip)// key=q
    278.         {
    279.         }
    280.  
    281.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    282.         {
    283.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    284.             {
    285.                 bool throwing = _manip->getSettings()->getThrowingEnabled();
    286. 				std::cout << "按下 q" << std::endl;// 确实收到消息，但是没看出什么变化
    287.                 _manip->getSettings()->setThrowingEnabled( !throwing );
    288.                 aa.requestRedraw();
    289.                 return true;
    290.             }
    291.             return false;
    292.         }
    293.  
    294.         void getUsage(osg::ApplicationUsage& usage) const
    295.         {
    296.             using namespace std;
    297.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle throwing"));
    298.         }
    299.  
    300.         char _key;
    301.         osg::ref_ptr _manip;
    302.     };
    303.  
    304.     /**
    305.      * Toggles the collision feature.切换碰撞功能。
    306.      */
    307.     struct ToggleCollisionHandler : public osgGA::GUIEventHandler
    308.     {
    309.         ToggleCollisionHandler(char key, EarthManipulator* manip)
    310.             : _key(key), _manip(manip)// key=k
    311.         {
    312.         }
    313.  
    314.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    315.         {
    316.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    317.             {
    318.                 bool value = _manip->getSettings()->getTerrainAvoidanceEnabled();
    319. 				std::cout << "按下 k" << std::endl;// 确实收到消息，但是没看出什么变化
    320.                 _manip->getSettings()->setTerrainAvoidanceEnabled( !value );
    321.                 aa.requestRedraw();
    322.                 return true;
    323.             }
    324.             return false;
    325.         }
    326.  
    327.         void getUsage(osg::ApplicationUsage& usage) const
    328.         {
    329.             using namespace std;
    330.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle terrain avoidance"));
    331.         }
    332.  
    333.         char _key;
    334.         osg::ref_ptr _manip;
    335.     };
    336.  
    337.     /**
    338.      * Breaks a tether.三种状态的切换
    339.      */
    340.     struct CycleTetherMode : public osgGA::GUIEventHandler
    341.     {
    342.         CycleTetherMode(char key, EarthManipulator* manip)
    343.             : _key(key), _manip(manip) { }// key=t
    344.  
    345.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    346.         {
    347.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    348.             {
    349.                 EarthManipulator::TetherMode mode = _manip->getSettings()->getTetherMode();
    350.                 if ( mode == _manip->TETHER_CENTER ) { 
    351.                     _manip->getSettings()->setTetherMode( _manip->TETHER_CENTER_AND_HEADING );// 相机将跟随节点，仅跟随方向旋转
    352.                     OE_NOTICE << "Tether mode = TETHER_CENTER_AND_HEADING\n";
    353.                 }
    354.                 else if ( mode == _manip->TETHER_CENTER_AND_HEADING ) {
    355.                     _manip->getSettings()->setTetherMode( _manip->TETHER_CENTER_AND_ROTATION ); // 摄影机将跟随节点和节点所做的所有旋转
    356.                     OE_NOTICE << "Tether mode = TETHER_CENTER_AND_ROTATION\n";
    357.                 }
    358.                 else {
    359.                     _manip->getSettings()->setTetherMode( _manip->TETHER_CENTER );// 摄影机将跟随节点的中心。
    360.                     OE_NOTICE << "Tether mode = CENTER\n";
    361.                 }
    362.  
    363.                 aa.requestRedraw();
    364.                 return true;
    365.             }
    366.             return false;
    367.         }
    368.  
    369.         void getUsage(osg::ApplicationUsage& usage) const
    370.         {
    371.             using namespace std;
    372.             usage.addKeyboardMouseBinding(string(1, _key), string("Cycle Tether Mode"));
    373.         }
    374.  
    375.         char _key;
    376.         osg::ref_ptr _manip;
    377.     };
    378.  
    379.     /**
    380.      * Breaks a tether.解绑
    381.      */
    382.     struct BreakTetherHandler : public osgGA::GUIEventHandler
    383.     {
    384.         BreakTetherHandler(char key, EarthManipulator* manip)
    385.             : _key(key), _manip(manip) { }//key=b
    386.  
    387.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    388.         {
    389.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    390.             {
    391.                 _manip->clearViewpoint();// 解除所有操作器绑定，恢复自由状态。thing1和 thing2 的状态改变明显
    392.                 aa.requestRedraw();
    393.                 return true;
    394.             }
    395.             return false;
    396.         }
    397.  
    398.         void getUsage(osg::ApplicationUsage& usage) const
    399.         {
    400.             using namespace std;
    401.             usage.addKeyboardMouseBinding(string(1, _key), string("Break a tether"));
    402.         }
    403.  
    404.         char _key;
    405.         osg::ref_ptr _manip;
    406.     };
    407.     
    408.  
    409.     /**
    410.      * Adjusts the position offset.调整位置偏移。
    411.      */
    412.     struct SetPositionOffset : public osgGA::GUIEventHandler
    413.     {
    414.         SetPositionOffset(EarthManipulator* manip)
    415.             : _manip(manip) { }
    416.  
    417.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    418.         {
    419.             if (ea.getEventType() == ea.KEYDOWN && (ea.getModKeyMask() & ea.MODKEY_SHIFT) )
    420.             {
    421.                 Viewpoint oldvp = _manip->getViewpoint();
    422.  
    423.                 double seconds = 0.5; // 时间秒。每次切换都需要0.5秒
    424.  
    425.                 if ( ea.getKey() == ea.KEY_Left )// 左键
    426.                 {
    427.                     Viewpoint vp;
    428.                     vp.positionOffset() = oldvp.positionOffset().get() + osg::Vec3f(-1000,0,0);
    429.                     _manip->setViewpoint( vp, seconds );
    430.                 }
    431.                 else if ( ea.getKey() == ea.KEY_Right )// 右键
    432.                 {
    433.                     Viewpoint vp;
    434.                     vp.positionOffset() = oldvp.positionOffset().get() + osg::Vec3f(1000,0,0);
    435.                     _manip->setViewpoint( vp, seconds );
    436.                 }
    437.                 else if ( ea.getKey() == ea.KEY_Up )// 上键
    438.                 {
    439.                     Viewpoint vp;
    440.                     vp.positionOffset() = oldvp.positionOffset().get() + osg::Vec3f(0,0,1000);
    441.                     _manip->setViewpoint( vp, seconds );
    442.                 }
    443.                 else if ( ea.getKey() == ea.KEY_Down )// 下键
    444.                 {
    445.                     Viewpoint vp;
    446.                     vp.positionOffset() = oldvp.positionOffset().get() + osg::Vec3f(0,0,-1000);
    447.                     _manip->setViewpoint( vp, seconds );
    448.                 }
    449.                 aa.requestRedraw();
    450.                 return true;
    451.             }
    452.             return false;
    453.         }
    454.  
    455.         osg::ref_ptr _manip;
    456.     };
    457.  
    458.  
    459.     /**
    460.      * Toggles perspective/ortho projection matrix. 切换投影矩阵，透视投影矩阵和正射投影矩阵
    461.      */
    462.     struct ToggleProjMatrix : public osgGA::GUIEventHandler
    463.     {
    464.         ToggleProjMatrix(char key, EarthManipulator* manip)
    465.             : _key(key), _manip(manip)// ley=o
    466.         {
    467.         }
    468.  
    469.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    470.         {
    471.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    472.             {
    473.                 osg::Matrix proj = aa.asView()->getCamera()->getProjectionMatrix();
    474.                 if ( proj(3,3) == 0 )
    475.                 {
    476.                     OE_NOTICE << "Switching to orthographc.\n";
    477.                     proj.getPerspective(_vfov, _ar, _zn, _zf); // 获取值
    478.                     aa.asView()->getCamera()->setProjectionMatrixAsOrtho(-1, 1, -1, 1, _zn, _zf);// 正射投影矩阵
    479.                 }
    480.                 else
    481.                 {
    482.                     OE_NOTICE << "Switching to perspective.\n";
    483.                     aa.asView()->getCamera()->setProjectionMatrixAsPerspective(_vfov, _ar, _zn, _zf);// 透视矩阵
    484.                 }
    485.                 aa.requestRedraw();
    486.                 return true;
    487.             }
    488.             return false;
    489.         }
    490.  
    491.         void getUsage(osg::ApplicationUsage& usage) const
    492.         {
    493.             using namespace std;
    494.             usage.addKeyboardMouseBinding(string(1, _key), string("Toggle projection matrix type"));
    495.         }
    496.  
    497.         char _key;
    498.         osg::ref_ptr _manip;
    499.         double _vfov, _ar, _zn, _zf;
    500.     };
    501.     // 定位到某组点的视点，一组点都可以看到
    502.     struct FitViewToPoints : public osgGA::GUIEventHandler
    503.     {
    504.         std::vector _points;
    505.         const SpatialReference* _mapSRS;
    506.  
    507.         FitViewToPoints(char key, EarthManipulator* manip, const SpatialReference* mapSRS)
    508.             : _key(key), _manip(manip), _mapSRS(mapSRS)// key=j
    509.         {
    510.             // Set up a list of control points
    511.             const SpatialReference* srs = SpatialReference::get("wgs84");
    512.             _points.push_back(GeoPoint(srs, -120, 30, 0));
    513.             _points.push_back(GeoPoint(srs, -100, 45, 0));
    514.         }
    515.  
    516.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    517.         {
    518.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    519.             {
    520. 				// fitter 创建适合摄影机视图平截头体的视点，以尽可能紧密地包围一组地理空间点。
    521.                 ViewFitter fitter(_mapSRS, aa.asView()->getCamera());
    522.                 fitter.setBuffer( 100000.0 );
    523.                 Viewpoint vp;
    524.                 if (fitter.createViewpoint(_points, vp))// 根据_points重新生成一个vp视点
    525.                 {
    526.                     _manip->setViewpoint(vp);// 定位到vp视点
    527.                     aa.requestRedraw();
    528.                 }
    529.                 return true;
    530.             }
    531.             return false;
    532.         }
    533.  
    534.         void getUsage(osg::ApplicationUsage& usage) const
    535.         {
    536.             using namespace std;
    537.             usage.addKeyboardMouseBinding(string(1, _key), string("FitViewToPoints"));
    538.         }
    539.  
    540.         char _key;
    541.         osg::ref_ptr _manip;
    542.     };
    543.         
    544.  
    545.     /**
    546.      * A simple simulator that moves an object around the Earth. We use this to
    547.      * demonstrate/test tethering.
    548.      */
    549. 	// 一个简单的模拟器，可以使物体绕地球运动。用来演示跟踪thing
    550.     struct Simulator : public osgGA::GUIEventHandler
    551.     {
    552.         Simulator( osg::Group* root, EarthManipulator* manip, MapNode* mapnode, osg::Node* model, const char* name, char key)
    553.             : _manip(manip), _mapnode(mapnode), _model(model), _name(name), _key(key) // key=8 或 9
    554.         {
    555.             if ( !model )
    556.             { 
    557. 				// 模型不存在，则创建一个半球，半径和颜色
    558.                 _model = AnnotationUtils::createHemisphere(250.0, osg::Vec4(1,.7,.4,1));
    559. 				std::cout << "no model" << std::endl;
    560.             }
    561.  
    562.             _geo = new GeoPositionNode();
    563.             _geo->getPositionAttitudeTransform()->addChild(_model);
    564.  
    565.             Style style;
    566.             TextSymbol* text = style.getOrCreate();
    567.             text->size() = 32.0f;
    568.             text->declutter() = false;
    569.             text->pixelOffset()->set(50, 50);// 文本偏移像素点
    570.             
    571.             _label = new LabelNode(_name, style);// _name 即要显示的名称
    572.             _label->setDynamic( true );// 因为文本移动，所以此处设置为true
    573.             _label->setHorizonCulling(false);// 不需要裁剪
    574.  
    575.             _geo->getPositionAttitudeTransform()->addChild(_label);
    576.  
    577.             mapnode->addChild(_geo.get());
    578.         }
    579.  
    580.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    581.         {
    582.             if ( ea.getEventType() == ea.FRAME )// 此语段为标签添加了动画
    583.             {
    584.                 double t0 = osg::Timer::instance()->time_s();// 儒略日时间
    585.                 double t = fmod( t0, 6000.0 ) / 6000.0;// t0%6000/6000, 将数字控制在[0,1)范围内
    586.                 GeoPoint p = _start.interpolate(_end, t);// 差值，在_end和t之间
    587. 				// GeoMath::bearing 以弧度计算从一个点到下一个点的初始方位
    588.                 double bearing = GeoMath::bearing(_start.y(), _start.x(), p.y(), p.x());
    589.  
    590.                 float a = sin(t0*0.2);// a值没有被用
    591.                 float pitch = 0.0;
    592.  
    593.                 _geo->setPosition(p);
    594.  
    595.                 _geo->setLocalRotation(
    596.                     osg::Quat(pitch, osg::Vec3d(1, 0, 0)) *
    597.                     osg::Quat(bearing, osg::Vec3d(0, 0, -1)));
    598.             }
    599.             else if ( ea.getEventType() == ea.KEYDOWN )
    600.             {
    601.                 if ( ea.getKey() == _key )// 8 或 9
    602.                 {                                
    603.                     Viewpoint vp = _manip->getViewpoint();
    604.                     //vp.setNode( _pat.get() );
    605.                     vp.setNode(_model);
    606.                     vp.range() = 25000.0;
    607.                     vp.pitch() = -45.0;
    608.                     _manip->setViewpoint(vp, 2.0);// 2秒内飞到指定位置
    609.                 }
    610.                 return true;
    611.             }
    612.             return false;
    613.         }
    614.  
    615.         std::string                        _name;
    616.         char                               _key;
    617.         MapNode*                           _mapnode;
    618.         EarthManipulator*                  _manip;
    619.         GeoPoint                           _start, _end;
    620.         LabelNode*                         _label;
    621.         osg::Node*                         _model;
    622.         float                              _heading;
    623.         float                              _pitch;
    624.  
    625.         osg::ref_ptr      _geo;
    626.     };
    627.  
    628.     /**
    629.      * Place an X at the sim entity position, in screen space.
    630.      * The point of this is to test the EarthManipulator::UpdateCameraCallback
    631.      * which provides a frame-synched camera matrix (post-update traversal)
    632.      */
    633. 	// 创建一个十字坐标
    634.     struct CalculateWindowCoords : public osgGA::GUIEventHandler
    635.                                    
    636.     {
    637.         CalculateWindowCoords(char key, EarthManipulator* manip, Simulator* sim)
    638.             : _key(key), _active(false), _sim(sim), _xform(0L)
    639.         {
    640.             //nop
    641.         }
    642.  
    643.         void onUpdateCamera(const osg::Camera* cam)
    644.         {
    645.             if (_active)
    646.             {
    647.                 if (!_xform)
    648.                 {
    649.                     osg::Geometry* geom = new osg::Geometry();
    650.                     osg::Vec3Array* verts = new osg::Vec3Array();
    651.                     verts->push_back(osg::Vec3(-10000, 0, 0));
    652.                     verts->push_back(osg::Vec3( 10000, 0, 0));
    653.                     verts->push_back(osg::Vec3( 0, -10000, 0));
    654.                     verts->push_back(osg::Vec3( 0,  10000, 0));
    655.                     verts->push_back(osg::Vec3( 0, 0, -10000));
    656.                     verts->push_back(osg::Vec3( 0, 0,  10000));
    657.                     geom->setVertexArray(verts);
    658.                     osg::Vec4Array* colors = new osg::Vec4Array();
    659.                     colors->push_back(osg::Vec4(1, 1, 0, 1));// 黄色线
    660.                     colors->setBinding(colors->BIND_OVERALL);
    661.                     geom->setColorArray(colors);
    662.                     geom->addPrimitiveSet(new osg::DrawArrays(GL_LINES, 0, 6));// 6个点，绘制3条线，但屏幕上仅能看出2条线，水平和垂直
    663.                     geom->setCullingActive(false);// 不裁剪
    664.                     geom->getOrCreateStateSet()->setAttributeAndModes(new osg::Depth(osg::Depth::ALWAYS, 0, 1, true), 1);//深度设置
    665.  
    666.                     _xform = new osg::MatrixTransform();
    667.                     _xform->addChild(geom);
    668.  
    669.                     osg::View* view = const_cast(cam->getView());
    670.                     ControlCanvas::getOrCreate(view)->addChild(_xform);
    671.                 }
    672. 				/// 坐标变换 V_clip=M_projection⋅M_view⋅M_model⋅V_local  裁剪坐标=透视矩阵*观察矩阵*模型矩阵*本地坐标——来自OpenGL
    673.                 GeoPoint p = _sim->_geo->getPosition();// 获取thing1的坐标点
    674.  
    675.                 osg::Vec3d world;
    676.                 p.toWorld(world);// 转化为世界坐标
    677.  
    678.                 osg::Matrix worldToWindow =
    679.                     cam->getViewMatrix() *
    680.                     cam->getProjectionMatrix() *
    681.                     cam->getViewport()->computeWindowMatrix();// 世界坐标转到窗口坐标
    682.  
    683.                 osg::Vec3d win = world * worldToWindow;// 得到窗口坐标
    684.  
    685.                 _xform->setMatrix(osg::Matrix::translate(win));
    686.             }
    687.         }
    688.  
    689.         bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
    690.         {
    691.             if (ea.getEventType() == ea.KEYDOWN && ea.getKey() == _key)
    692.             {
    693.                 _active = !_active;
    694.                 aa.requestRedraw();
    695.                 return true;
    696.             }
    697.             
    698.             return false;
    699.         }
    700.  
    701.         void getUsage(osg::ApplicationUsage& usage) const
    702.         {
    703.             using namespace std;
    704.             usage.addKeyboardMouseBinding(string(1, _key), string("Show Window Coords"));
    705.         }
    706.  
    707.         osg::MatrixTransform* _xform;
    708.         Simulator* _sim;
    709.         bool _active;
    710.         char _key;
    711.     };
    712. 	// 更新相机回调
    713.     struct CameraUpdater : public EarthManipulator::UpdateCameraCallback
    714.     {
    715.         CalculateWindowCoords* _calc;
    716.  
    717.         CameraUpdater(CalculateWindowCoords* calc) : _calc(calc) { }
    718.         
    719.         void onUpdateCamera(const osg::Camera* cam)
    720.         {
    721.             _calc->onUpdateCamera(cam);// 当物体运动时，需要让十字线跟随物体运动
    722.         }
    723.     };
    724. }
    725.  
    726.  
    727. int main(int argc, char** argv)
    728. {
    729.     osg::ArgumentParser arguments(&argc,argv);
    730.  
    731.     if (arguments.read("--help") || argc==1)
    732.     {
    733.         OE_WARN << "Usage: " << argv[0] << " [earthFile] [--model modelToLoad]"
    734.             << std::endl;
    735.         return 0;
    736.     }
    737.  
    738.     osgViewer::Viewer viewer(arguments);
    739.  
    740.     // install the programmable manipulator.安装操作器
    741.     EarthManipulator* manip = new EarthManipulator();
    742.     viewer.setCameraManipulator( manip );
    743.  
    744.     // UI: 创建帮助说明控件，在左上角的位置。当鼠标移动到控件上之后，是无法点击到地球上的，没有鼠标穿透功能。
    745.     Container* help = createHelp(&viewer);
    746. 	// MapNodeHelper 显示帮助
    747. 	// load() 加载earth映射文件并处理所有内置示例命令行参数和XML外部变量(help)。
    748.     osg::Node* earthNode = MapNodeHelper().load( arguments, &viewer, help );
    749.     if (!earthNode)
    750.     {
    751.         OE_WARN << "Unable to load earth model." << std::endl;
    752.         return -1;
    753.     }
    754.  
    755.     osg::Group* root = new osg::Group();
    756.     root->addChild( earthNode );
    757. 	// 获取mapNode
    758.     osgEarth::MapNode* mapNode = osgEarth::MapNode::findMapNode( earthNode );
    759.  
    760.     // user model?
    761. 	// 加载模型,这里传入osg osgt格式的模型，并没有显示
    762.     osg::ref_ptr model;
    763.     std::string modelFile;
    764.     if (arguments.read("--model", modelFile))
    765.         model = osgDB::readRefNodeFile(modelFile + ".osgearth_shadergen");
    766.  
    767.     osg::Group* sims = new osg::Group();
    768.     root->addChild( sims );
    769.  
    770.     const SpatialReference* wgs84 = SpatialReference::get("wgs84");// 坐标系
    771.  
    772.     // Simulator for tethering: 系留模拟器
    773. 	// thing 1 和 thing 2 会随着时间移动
    774.     Simulator* sim1 = new Simulator(sims, manip, mapNode, model.get(), "Thing 1", '8');// 8：绑住第一个物体
    775. 	sim1->_name = "Thing 1";
    776.     sim1->_start = GeoPoint(wgs84, 45.0, 55.0, 10000);// 开始坐标点
    777.     sim1->_end = GeoPoint(wgs84, -45, -55.0, 10000);  // 结束坐标点
    778.     viewer.addEventHandler(sim1);	// 加入到操作器
    779.  
    780.     Simulator* sim2 = new Simulator(sims, manip, mapNode, model.get(), "Thing 2", '9');// 9：绑住第二个物体
    781.     sim2->_name = "Thing 2";
    782.     sim2->_start = GeoPoint(wgs84, 45.0, 54.0, 10000);
    783.     sim2->_end = GeoPoint(wgs84, -44.0, -54.0, 10000);
    784.     viewer.addEventHandler(sim2);
    785.  
    786.     manip->getSettings()->getBreakTetherActions().push_back( EarthManipulator::ACTION_GOTO );  // 操作器动作，直接过去  
    787.  
    788.     // Set the minimum distance to something larger than the default
    789. 	// 距离物体小于最小距离时，物体会变大
    790.     manip->getSettings()->setMinMaxDistance(10.0, manip->getSettings()->getMaxDistance());
    791.  
    792.     // Sets the maximum focal point offsets (usually for tethering)
    793.     manip->getSettings()->setMaxOffset(5000.0, 5000.0);
    794.     
    795.     // Pitch limits. 俯仰角范围
    796.     manip->getSettings()->setMinMaxPitch(-90, 90);
    797.  
    798.  
    799.     viewer.setSceneData( root );
    800. 	//为 鼠标左键按下、修改键、拖动鼠标的动作指定行为。
    801.     manip->getSettings()->bindMouse(
    802.         EarthManipulator::ACTION_EARTH_DRAG,
    803.         osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON,
    804.         osgGA::GUIEventAdapter::MODKEY_SHIFT );
    805.  
    806.     manip->getSettings()->bindMouseClick(
    807.         EarthManipulator::ACTION_GOTO,
    808.         osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON,
    809.         osgGA::GUIEventAdapter::MODKEY_SHIFT);
    810.  
    811.     manip->getSettings()->setArcViewpointTransitions( true );    
    812. 	// 设置tether连接和断裂时的动作回调
    813.     manip->setTetherCallback( new TetherCB() );
    814.     
    815.     //viewer.addEventHandler(new FlyToViewpointHandler( manip ));
    816. 	// 添加 自定义的各个事件处理
    817.     viewer.addEventHandler(new LockAzimuthHandler('u', manip));
    818.     viewer.addEventHandler(new ToggleArcViewpointTransitionsHandler('a', manip));
    819.     viewer.addEventHandler(new ToggleThrowingHandler('q', manip));
    820.     viewer.addEventHandler(new ToggleCollisionHandler('k', manip));
    821.     viewer.addEventHandler(new ToggleProjMatrix('o', manip));
    822.     viewer.addEventHandler(new BreakTetherHandler('b', manip));
    823.     viewer.addEventHandler(new CycleTetherMode('t', manip));
    824.     viewer.addEventHandler(new SetPositionOffset(manip));// 设置偏移
    825.     viewer.addEventHandler(new ToggleLDB('L'));
    826.     viewer.addEventHandler(new ToggleSSL(sims, ')'));
    827.     viewer.addEventHandler(new FitViewToPoints('j', manip, mapNode->getMapSRS()));
    828.     
    829. 	// 根据 thing 1 的位置，更新相机
    830.     CalculateWindowCoords* calc = new CalculateWindowCoords('W', manip, sim1);// 根据thing 1计算窗口坐标
    831.     viewer.addEventHandler(calc);
    832.     manip->setUpdateCameraCallback(new CameraUpdater(calc));// 相机回调
    833.  
    834.     viewer.getCamera()->setSmallFeatureCullingPixelSize(-1.0f);
    835.  
    836.     while(!viewer.done())
    837.     {
    838.         viewer.frame();
    839.  
    840.         // simulate slow frame rate
    841.         //OpenThreads::Thread::microSleep(1000*1000);
    842.     }
    843.     return 0;
    844. }

  • 相关阅读:
    常用黄芪泡水喝，身体能得到什么？学会搭配，养生效果或会翻倍
    MAC 如何配置 PCL 库并在 VS Code 中使用
    C++的指针
    CANopen扫盲
    11.Mogodb数据库基本使用
    如何确定自己的armbian系统是不是ARM64架构
    Qt基于Qml向左边滑动删除列表项
    【uniapp+vue3+u-picker】获取中国省市区数据结构，省市区数据三级联动json文件完整版，已实现三级联动效果
    【操作系统】第三章 —— 如何管理物理内存
    pytest自动化测试两种执行环境切换的解决方案
  • 原文地址：https://blog.csdn.net/qq_34732729/article/details/128035808