परिचय

C ++ भाषा की एक विशेषता जिसके लिए इसकी अक्सर आलोचना की जाती है वह है मानक में एक घटना प्रसंस्करण तंत्र की कमी। इस बीच, यह तंत्र अन्य सॉफ्टवेयर घटकों और हार्डवेयर के साथ कुछ सॉफ्टवेयर घटकों की बातचीत के मुख्य तरीकों में से एक है, और इसे एक विशिष्ट ओएस के स्तर पर लागू किया जाता है। स्वाभाविक रूप से, प्रत्येक मंच में वर्णित तंत्र को लागू करने की अपनी बारीकियां हैं।

उपरोक्त सभी के संबंध में, C ++ में विकसित होने पर, एक या दूसरे तरीके से घटना प्रसंस्करण को लागू करने की आवश्यकता है, तीसरे पक्ष के पुस्तकालयों और चौखटे का उपयोग करके हल किया गया है। प्रसिद्ध Qt फ्रेमवर्क सिग्नल और स्लॉट के लिए एक तंत्र प्रदान करता है, जो QObject से विरासत में मिली कक्षाओं के इंटरैक्शन को व्यवस्थित करने की अनुमति देता है। घटनाओं के कार्यान्वयन को बढ़ावा देने वाली लाइब्रेरी में भी मौजूद है। और निश्चित रूप से, OpenSceneGraph इंजन अपने स्वयं के "साइकिल" के बिना नहीं कर सका, जिसके आवेदन पर लेख में चर्चा की जाएगी।

OSG एक अमूर्त ग्राफिक्स लाइब्रेरी है। एक ओर, यह ओपनजीएल प्रक्रियात्मक इंटरफ़ेस से सार करता है, डेवलपर को कक्षाओं के एक सेट के साथ प्रदान करता है जो ओपनीगेल एपीआई के पूरे यांत्रिकी को एन्क्रिप्ट करता है। दूसरी ओर, यह एक विशिष्ट ग्राफिकल यूजर इंटरफेस से भी अलग है, क्योंकि इसके कार्यान्वयन के दृष्टिकोण अलग-अलग प्लेटफ़ॉर्म के लिए अलग-अलग हैं और समान प्लेटफ़ॉर्म (उदाहरण के लिए MFC, Qt, .net for Windows) के भीतर भी हैं।

प्लेटफ़ॉर्म के बावजूद, एप्लिकेशन के दृष्टिकोण से, ग्राफ़िकल इंटरफ़ेस के साथ उपयोगकर्ता की बातचीत घटनाओं के अनुक्रम के तत्वों को उत्पन्न करने के लिए कम हो जाती है जो तब अनुप्रयोग के अंदर संसाधित होती हैं। अधिकांश ग्राफिकल फ्रेमवर्क इस दृष्टिकोण का उपयोग करते हैं, लेकिन एक ही मंच के भीतर भी, वे दुर्भाग्य से, एक दूसरे के साथ संगत नहीं हैं।

इस कारण से, OSG, ऑर्गेजा :: GUIEventHilller वर्ग के आधार पर विजेट विजेट ईवेंट्स और यूजर इनपुट से निपटने के लिए अपना बेसिक इंटरफेस प्रदान करता है। इस हैंडलर को addEventHandler () मेथड को हटाकर और RemoveEventHandler () मेथड द्वारा दर्शक से जोड़ा जा सकता है। स्वाभाविक रूप से, कंक्रीट हैंडलर वर्ग को ओशगा :: GUIEventHandler वर्ग से विरासत में मिला होना चाहिए, और इसमें हैंडल () विधि को फिर से परिभाषित किया जाना चाहिए। यह विधि दो तर्कों को स्वीकार करती है: osgGA :: GUIEventAdapter, जिसमें GUI और osg :: GUIActionAdepter की घटना कतार शामिल है, जिसका उपयोग प्रतिक्रिया के लिए किया जाता है। परिभाषा में विशिष्ट इस तरह के एक डिजाइन है

bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdepter &aa) { //        }

OsgGA :: GUIActionAdapter पैरामीटर डेवलपर को इवेंट के जवाब में कुछ कार्रवाई करने के लिए GUI से पूछने की अनुमति देता है। ज्यादातर मामलों में, इस पैरामीटर के माध्यम से एक दर्शक प्रभावित होता है, एक पॉइंटर जिसे डायनेमिक पॉइंटर रूपांतरण द्वारा प्राप्त किया जा सकता है

 osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer *>(&aa);

1. कीबोर्ड और माउस इवेंट हैंडलिंग

OsgGA :: GUIEventAdapter () वर्ग OSG द्वारा समर्थित सभी प्रकार की घटनाओं का प्रबंधन करता है, अपने मापदंडों को स्थापित करने और पुनर्प्राप्त करने के लिए डेटा प्रदान करता है। GetEventType () विधि ईवेंट क्यू में सम्‍मिलित वर्तमान GUI ईवेंट लौटाता है। हर बार, हैंडलर के हैंडल () विधि को ओवरराइड करते समय, इस तरीके को कॉल करते समय, आपको इस प्राप्तकर्ता को घटना को प्राप्त करने और इसके प्रकार का निर्धारण करने के लिए उपयोग करना चाहिए।

निम्न तालिका सभी उपलब्ध घटनाओं का वर्णन करती है।

घटना प्रकार	विवरण	घटना अधिग्रहण के तरीके
PUSH / RELEASE / DOUBLECLICK	क्लिक / रिलीज़ और माउस बटन पर डबल क्लिक करें	getX (), getY () - कर्सर स्थिति प्राप्त करना। getButton () - दबाए गए बटन का कोड (LEFT_MOUSE_BUTTON, RIGHT_MOUSE_BUTTON, MIDDLE_MOUSE_BUTTON
स्क्रॉल	स्क्रॉलिंग माउस व्हील (s)	getScrollingMotion () - SCROOL_UP, SCROLL_DOWN, SCROLL_LEFT, SCROLL_RIGHT देता है
खींचें	माउस खींचें	getX (), getY () - कर्सर स्थिति; getButtonMask () - getButton के समान मूल्य ()
चाल	मूषक चाल	getX (), getY () - कर्सर स्थिति
KEYDOWN / KEYUP	कीबोर्ड पर एक कुंजी को दबाना / जारी करना	getKey () - दबाए गए कुंजी का ASCII कोड या Key_Symbol एन्यूमरेटर का मूल्य (उदाहरण के लिए, KEY_BackSpace)
फ्रेम	फ्रेम रेंडर करते समय घटना उत्पन्न हुई	कोई इनपुट नहीं
उपयोगकर्ता	उपयोगकर्ता परिभाषित घटना	getUserDataPointer () - एक उपयोगकर्ता डेटा बफ़र को एक पॉइंटर लौटाता है (बफ़र को एक स्मार्ट पॉइंटर द्वारा नियंत्रित किया जाता है)

एक दबाए गए संशोधक कुंजी (प्रपत्र MODKEY_CTRL, MODKEY_SHIFT, MODKEY_ALT, और इसी तरह के रिटर्न के मूल्यों) के बारे में जानकारी प्राप्त करने के लिए एक getModKeyMask () विधि है, जिससे आप संशोधक का उपयोग करने वाले प्रमुख संयोजनों को संसाधित कर सकते हैं।

 if (ea.getModKeyMask() == osgGA::GUIEventAdapter::MODKEY_CTRL) { //    Ctrl }

ध्यान रखें कि सेटर के तरीके जैसे सेटएक्स (), सेटवाई (), सेटएवेंटटाइप (), आदि। संभाल () हैंडलर में इस्तेमाल नहीं किया। घटना को कतारबद्ध करने के लिए उन्हें OSG निम्न-स्तरीय ग्राफ़िकल विंडोिंग सिस्टम द्वारा बुलाया जाता है।

2. हम कीबोर्ड से सेसना को नियंत्रित करते हैं

हम पहले ही जानते हैं कि ऑस्ग :: मैट्रिक्सट्रांसफॉर्म कक्षाओं के माध्यम से दृश्य वस्तुओं को कैसे बदलना है। हमने osg :: AnimationPath और osg :: एनीमेशन कक्षाओं का उपयोग करके विभिन्न प्रकार के एनिमेशन की जांच की। लेकिन एक आवेदन की अन्तरक्रियाशीलता के लिए (उदाहरण के लिए, एक खेल), एनीमेशन और रूपांतरण स्पष्ट रूप से पर्याप्त नहीं हैं। अगला कदम उपयोगकर्ता इनपुट उपकरणों से चरण पर वस्तुओं की स्थिति को नियंत्रित करना है। आइए हमारे प्यारे सेसना को प्रबंधन तेज करने का प्रयास करें।

कीबोर्ड उदाहरण

main.h

 #ifndef MAIN_H #define MAIN_H #include <osg/MatrixTransform> #include <osgDB/ReadFile> #include <osgGA/GUIEventHandler> #include <osgViewer/Viewer> #endif

main.cpp

 #include "main.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ class ModelController : public osgGA::GUIEventHandler { public: ModelController( osg::MatrixTransform *node ) : _model(node) {} virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa); protected: osg::ref_ptr<osg::MatrixTransform> _model; }; //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ bool ModelController::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { (void) aa; if (!_model.valid()) return false; osg::Matrix matrix = _model->getMatrix(); switch (ea.getEventType()) { case osgGA::GUIEventAdapter::KEYDOWN: switch (ea.getKey()) { case 'a': case 'A': matrix *= osg::Matrix::rotate(-0.1, osg::Z_AXIS); break; case 'd': case 'D': matrix *= osg::Matrix::rotate( 0.1, osg::Z_AXIS); break; case 'w': case 'W': matrix *= osg::Matrix::rotate(-0.1, osg::X_AXIS); break; case 's': case 'S': matrix *= osg::Matrix::rotate( 0.1, osg::X_AXIS); break; default: break; } _model->setMatrix(matrix); break; default: break; } return true; } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ int main(int argc, char *argv[]) { (void) argc; (void) argv; osg::ref_ptr<osg::Node> model = osgDB::readNodeFile("../data/cessna.osg"); osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform; mt->addChild(model.get()); osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild(mt.get()); osg::ref_ptr<ModelController> mcontrol = new ModelController(mt.get()); osgViewer::Viewer viewer; viewer.addEventHandler(mcontrol.get()); viewer.getCamera()->setViewMatrixAsLookAt( osg::Vec3(0.0f, -100.0f, 0.0f), osg::Vec3(), osg::Z_AXIS ); viewer.getCamera()->setAllowEventFocus(false); viewer.setSceneData(root.get()); return viewer.run(); }

इस समस्या को हल करने के लिए, हम एक इनपुट ईवेंट हैंडलर क्लास लिखते हैं

 class ModelController : public osgGA::GUIEventHandler { public: ModelController( osg::MatrixTransform *node ) : _model(node) {} virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa); protected: osg::ref_ptr<osg::MatrixTransform> _model; };

इस वर्ग का निर्माण करते समय, एक पैरामीटर के रूप में, यह परिवर्तन नोड के लिए एक संकेतक पारित किया जाता है, जिसे हम हैंडलर में कार्य करेंगे। हैंडल () हैंडलर विधि को ही इस प्रकार पुनर्परिभाषित किया गया है

 bool ModelController::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { (void) aa; if (!_model.valid()) return false; osg::Matrix matrix = _model->getMatrix(); switch (ea.getEventType()) { case osgGA::GUIEventAdapter::KEYDOWN: switch (ea.getKey()) { case 'a': case 'A': matrix *= osg::Matrix::rotate(-0.1, osg::Z_AXIS); break; case 'd': case 'D': matrix *= osg::Matrix::rotate( 0.1, osg::Z_AXIS); break; case 'w': case 'W': matrix *= osg::Matrix::rotate(-0.1, osg::X_AXIS); break; case 's': case 'S': matrix *= osg::Matrix::rotate( 0.1, osg::X_AXIS); break; default: break; } _model->setMatrix(matrix); break; default: break; } return false; }

इसके कार्यान्वयन के आवश्यक विवरणों के बीच, यह ध्यान दिया जाना चाहिए कि हमें पहले नोड को नियंत्रित करने वाले परिवर्तन मैट्रिक्स को प्राप्त करना होगा

 osg::Matrix matrix = _model->getMatrix();

अगला, दो नेस्टेड स्विच () स्टेटमेंट इवेंट के प्रकार (कीस्ट्रोक) और दबाए गए कुंजी के कोड का विश्लेषण करते हैं। दबाए गए कुंजी के कोड के आधार पर, वर्तमान परिवर्तन मैट्रिक्स को संबंधित अक्ष के चारों ओर एक अतिरिक्त रोटेशन मैट्रिक्स द्वारा गुणा किया जाता है

 case 'a': case 'A': matrix *= osg::Matrix::rotate(-0.1, osg::Z_AXIS); break;

- जब आप "A" कुंजी दबाते हैं तो विमान को -0.1 रेडियन के yaw कोण पर घुमाएं।

कीस्ट्रोक को संसाधित करने के बाद, रूपांतरण नोड में एक नया परिवर्तन मैट्रिक्स लागू करना न भूलें

 _model->setMatrix(matrix);

मुख्य () फ़ंक्शन में, हवाई जहाज के मॉडल को लोड करें और इसके लिए एक पैरेंट ट्रांसफ़ॉर्मेशन नोड बनाएं, जिसके परिणामस्वरूप दृश्य के रूट नोड में सबग्राफ को जोड़ा जाएगा

 osg::ref_ptr<osg::Node> model = osgDB::readNodeFile("../data/cessna.osg"); osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform; mt->addChild(model.get()); osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild(mt.get());

उपयोगकर्ता इनपुट हैंडलर बनाएं और प्रारंभ करें

 osg::ref_ptr<ModelController> mcontrol = new ModelController(mt.get());

हमारे हैंडलर को इसमें जोड़कर एक दर्शक बनाएं

 osgViewer::Viewer viewer; viewer.addEventHandler(mcontrol.get());

कैमरा व्यू मैट्रिक्स सेट करें

 viewer.getCamera()->setViewMatrixAsLookAt( osg::Vec3(0.0f, -100.0f, 0.0f), osg::Vec3(), osg::Z_AXIS );

इनपुट उपकरणों से घटनाओं को प्राप्त करने के लिए कैमरे को मना करें

 viewer.getCamera()->setAllowEventFocus(false);

यदि ऐसा नहीं किया जाता है, तो कैमरे पर लटका हैंडलर डिफ़ॉल्ट रूप से सभी उपयोगकर्ता इनपुट को बाधित करेगा और हमारे हैंडलर के साथ हस्तक्षेप करेगा। हम दर्शक को दृश्य डेटा सेट करते हैं और इसे चलाते हैं

 viewer.setSceneData(root.get()); return viewer.run();

अब, कार्यक्रम को लॉन्च करने से, हम कुंजी ए, डी, डब्ल्यू और एस दबाकर अंतरिक्ष में विमान के उन्मुखीकरण को नियंत्रित करने में सक्षम होंगे।

एक दिलचस्प सवाल यह है कि इसे बाहर निकलते समय हैंडल () विधि क्या है। यदि सच लौटाया जाता है, तो हम OSG को इंगित करते हैं, तो हम पहले ही इनपुट ईवेंट संसाधित कर चुके हैं और आगे की प्रक्रिया की आवश्यकता नहीं है। सबसे अधिक बार, यह व्यवहार हमारे अनुरूप नहीं होगा, इसलिए हैंडलर से झूठे वापस आने के लिए यह अच्छा अभ्यास है ताकि अन्य हैंडलर द्वारा घटनाओं के प्रसंस्करण को बाधित न करें यदि वे दृश्य में अन्य नोड्स से जुड़े हैं।

3. इवेंट प्रोसेसिंग में आगंतुकों का उपयोग

इसे अपडेट करते समय किसी दृश्य ग्राफ को ट्रेस करने के दौरान इसे कैसे लागू किया जाता है, इसके समान, OSG उन घटनाओं से निपटने के लिए कॉलबैक का समर्थन करता है जो नोड्स और ज्यामितीय वस्तुओं से जुड़ी हो सकती हैं। इसके लिए, setEventCallback () और addEventCallback () का उपयोग किया जाता है, जो एक पैरामीटर के रूप में बच्चे को एक संकेत के रूप में लेते हैं osg :: NodeCallback। ऑपरेटर () ऑपरेटर में घटनाओं को प्राप्त करने के लिए, हम इसे पास किए गए पॉइंटर को साइट विज़िटर को osgGA :: EventVisitor में कनवर्ट कर सकते हैं, उदाहरण के लिए इस तरह

 #include <osgGA/EventVisitor> ... void operator()( osg::Node *node, osg::NodeVisitor *nv ) { std::list<osg::ref_ptr<osgGA::GUIEventAdapter>> events; osgGA::EventVisitor *ev = dynamic_cast<osgGA::EventVisitor *>(nv); if (ev) { events = ev->getEvents(); //       } }

4. कस्टम घटनाओं का निर्माण और प्रसंस्करण

OSG एक आंतरिक ईवेंट कतार (FIFO) का उपयोग करता है। कतार की शुरुआत में होने वाली घटनाओं को संसाधित और उससे हटा दिया जाता है। नव निर्मित घटनाओं को कतार के अंत में रखा गया है। प्रत्येक ईवेंट हैंडलर के हैंडल () विधि को कई बार निष्पादित किया जाएगा क्योंकि कतार में इवेंट होते हैं। घटना की कतार का वर्णन osgGA :: EventQueue वर्ग द्वारा किया जाता है, जो अन्य बातों के अलावा, आपको किसी भी समय addEvent () विधि को कॉल करके कतार में एक घटना डालने की अनुमति देता है। इस पद्धति का तर्क osgGA :: GUIEventAdapter के लिए एक संकेतक है, जिसे सेटएवेंटटाइप () विधियों और इसी तरह का उपयोग करके एक विशिष्ट व्यवहार पर सेट किया जा सकता है।

OsgGA के तरीकों में से एक :: EventQueue वर्ग userEvent () है, जो उपयोगकर्ता डेटा के साथ इसे जोड़कर एक उपयोगकर्ता ईवेंट सेट करता है, एक पॉइंटर जिसे पैरामीटर के रूप में इसे पास किया जाता है। इस डेटा का उपयोग किसी भी कस्टम ईवेंट का प्रतिनिधित्व करने के लिए किया जा सकता है।

इवेंट कतार की अपनी आवृत्ति बनाने में असमर्थ। यह उदाहरण पहले से ही बनाया गया है और दर्शक उदाहरण से जुड़ा हुआ है, इसलिए आप केवल इस सिंगलटन के लिए एक संकेतक प्राप्त कर सकते हैं

 viewer.getEventQueue()->userEvent(data);

उपयोगकर्ता डेटा ओएसजी :: संदर्भित से वारिस का एक ऑब्जेक्ट है, अर्थात, आप इसे एक स्मार्ट पॉइंटर बना सकते हैं।

जब कोई कस्टम ईवेंट प्राप्त होता है, तो डेवलपर getUserData () विधि को कॉल करके उसमें से डेटा निकाल सकता है और उसे ठीक वैसे ही प्रोसेस कर सकता है जैसा वह फिट देखता है।

5. उपयोगकर्ता टाइमर का कार्यान्वयन

जीयूआई को लागू करने वाले कई पुस्तकालय और रूपरेखा एक निश्चित समय अंतराल के बाद एक घटना उत्पन्न करने वाले टाइमर को लागू करने के लिए एक वर्ग डेवलपर प्रदान करते हैं। ओएसजी में टाइमर को लागू करने के नियमित साधन नहीं हैं, इसलिए चलो कस्टम घटनाओं को बनाने के लिए इंटरफ़ेस का उपयोग करके, अपने दम पर किसी प्रकार के टाइमर को लागू करने का प्रयास करें।

इस समस्या को हल करने पर हम क्या भरोसा कर सकते हैं? एक निश्चित आवधिक घटना के लिए जो रेंडर द्वारा लगातार उत्पन्न होती है, उदाहरण के लिए, FRAME पर, अगले फ्रेम को खींचने की घटना। इसके लिए हम सेसना के मॉडल को सामान्य से जलाने पर स्विच करने के साथ एक ही उदाहरण का उपयोग करते हैं।

समय का उदाहरण

main.h

 #ifndef MAIN_H #define MAIN_H #include <osg/Switch> #include <osgDB/ReadFile> #include <osgGA/GUIEventHandler> #include <osgViewer/Viewer> #include <iostream> #endif

main.cpp

 #include "main.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ struct TimerInfo : public osg::Referenced { TimerInfo(unsigned int c) : _count(c) {} unsigned int _count; }; //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ class TimerHandler : public osgGA::GUIEventHandler { public: TimerHandler(osg::Switch *sw, unsigned int interval = 1000) : _switch(sw) , _count(0) , _startTime(0.0) , _interval(interval) , _time(0) { } virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa); protected: osg::ref_ptr<osg::Switch> _switch; unsigned int _count; double _startTime; unsigned int _interval; unsigned int _time; }; //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ bool TimerHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { switch (ea.getEventType()) { case osgGA::GUIEventAdapter::FRAME: { osgViewer::Viewer *viewer = dynamic_cast<osgViewer::Viewer *>(&aa); if (!viewer) break; double time = viewer->getFrameStamp()->getReferenceTime(); unsigned int delta = static_cast<unsigned int>( (time - _startTime) * 1000.0); _startTime = time; if ( (_count >= _interval) || (_time == 0) ) { viewer->getEventQueue()->userEvent(new TimerInfo(_time)); _count = 0; } _count += delta; _time += delta; break; } case osgGA::GUIEventAdapter::USER: if (_switch.valid()) { const TimerInfo *ti = dynamic_cast<const TimerInfo *>(ea.getUserData()); std::cout << "Timer event at: " << ti->_count << std::endl; _switch->setValue(0, !_switch->getValue(0)); _switch->setValue(1, !_switch->getValue(1)); } break; default: break; } return false; } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ int main(int argc, char *argv[]) { (void) argc; (void) argv; osg::ref_ptr<osg::Node> model1 = osgDB::readNodeFile("../data/cessna.osg"); osg::ref_ptr<osg::Node> model2 = osgDB::readNodeFile("../data/cessnafire.osg"); osg::ref_ptr<osg::Switch> root = new osg::Switch; root->addChild(model1.get(), true); root->addChild(model2.get(), false); osgViewer::Viewer viewer; viewer.setSceneData(root.get()); viewer.addEventHandler(new TimerHandler(root.get(), 1000)); return viewer.run(); }

सबसे पहले, आइए उपयोगकर्ता संदेश में भेजे गए डेटा के प्रारूप को निर्धारित करें, इसे एक संरचना के रूप में परिभाषित करें

 struct TimerInfo : public osg::Referenced { TimerInfo(unsigned int c) : _count(c) {} unsigned int _count; };

_Count पैरामीटर में समसामयिक संख्या में मिलीसेकंड होंगे जो उस समय से समाप्त हो गए थे जब तक कि अगले टाइमर घटना प्राप्त नहीं हुई थी। संरचना ओएसजी से संदर्भित है :: संदर्भित वर्ग ताकि इसे ओएसजी स्मार्ट पॉइंटर्स के माध्यम से नियंत्रित किया जा सके। अब एक इवेंट हैंडलर बनाएं

 class TimerHandler : public osgGA::GUIEventHandler { public: TimerHandler(osg::Switch *sw, unsigned int interval = 1000) : _switch(sw) , _count(0) , _startTime(0.0) , _interval(interval) , _time(0) { } virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa); protected: osg::ref_ptr<osg::Switch> _switch; unsigned int _count; double _startTime; unsigned int _interval; unsigned int _time; };

इस हैंडलर में कई विशिष्ट संरक्षित सदस्य हैं। _Switch चर एक नोड को इंगित करता है जो विमान के मॉडल को स्विच करता है; _count - टाइमर घटना की अंतिम पीढ़ी के बाद से गुजरे समय की सापेक्ष उलटी गिनती, समय अंतराल की गणना करने का कार्य करता है; _startTime - दर्शक द्वारा आयोजित पिछली उलटी गिनती के भंडारण के लिए एक अस्थायी चर; _time - मिलीसेकंड में कार्यक्रम का कुल संचालन समय। क्लास कंस्ट्रक्टर स्विच नोड को एक पैरामीटर के रूप में स्वीकार करता है और, वैकल्पिक रूप से, स्विचिंग टाइमर के संचालन के लिए आवश्यक समय अंतराल।

इस वर्ग में, हम हैंडल () विधि को ओवरराइड करते हैं

 bool TimerHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { switch (ea.getEventType()) { case osgGA::GUIEventAdapter::FRAME: { osgViewer::Viewer *viewer = dynamic_cast<osgViewer::Viewer *>(&aa); if (!viewer) break; double time = viewer->getFrameStamp()->getReferenceTime(); unsigned int delta = static_cast<unsigned int>( (time - _startTime) * 1000.0); _startTime = time; if ( (_count >= _interval) || (_time == 0) ) { viewer->getEventQueue()->userEvent(new TimerInfo(_time)); _count = 0; } _count += delta; _time += delta; break; } case osgGA::GUIEventAdapter::USER: if (_switch.valid()) { const TimerInfo *ti = dynamic_cast<const TimerInfo *>(ea.getUserData()); std::cout << "Timer event at: " << ti->_count << std::endl; _switch->setValue(0, !_switch->getValue(0)); _switch->setValue(1, !_switch->getValue(1)); } break; default: break; } return false; }

यहां हम प्राप्त संदेश के प्रकार का विश्लेषण करते हैं। यदि यह FRAME है, तो निम्नलिखित क्रियाएं की जाती हैं:

दर्शक को एक संकेत मिलता है

 osgViewer::Viewer *viewer = dynamic_cast<osgViewer::Viewer *>(&aa);

सही पॉइंटर मिलने पर, प्रोग्राम शुरू होने के बाद का समय समाप्त हो गया है

 double time = viewer->getFrameStamp()->getReferenceTime();

मिलीसेकंड में एक फ्रेम प्रदान करने में बिताए समय की मात्रा की गणना करें

 unsigned int delta = static_cast<unsigned int>( (time - _startTime) * 1000.0);

और वर्तमान समय गणना याद रखें

 _startTime = time;

यदि काउंटर का मान _count आवश्यक समय अंतराल से अधिक हो जाता है (या _time अभी भी शून्य है, तो यह पहली कॉल है), हम उपयोगकर्ता संदेश को कतार में रखते हैं, उपरोक्त संरचना में प्रोग्राम टाइम को मिलीसेकंड में पास करते हुए। काउंटर _count शून्य पर रीसेट है

 if ( (_count >= _interval) || (_time == 0) ) { viewer->getEventQueue()->userEvent(new TimerInfo(_time)); _count = 0; }

_Count के मूल्य के बावजूद, हमें इसे बढ़ाना चाहिए और एक फ्रेम को खींचने के लिए आवश्यक विलंब की मात्रा से _time

 _count += delta; _time += delta;

यह कैसे टाइमर घटना उत्पन्न होगा। ईवेंट हैंडलिंग इस प्रकार कार्यान्वित की जाती है

 case osgGA::GUIEventAdapter::USER: if (_switch.valid()) { const TimerInfo *ti = dynamic_cast<const TimerInfo *>(ea.getUserData()); std::cout << "Timer event at: " << ti->_count << std::endl; _switch->setValue(0, !_switch->getValue(0)); _switch->setValue(1, !_switch->getValue(1)); } break;

यहां हम सूचक को स्विचिंग नोड की वैधता की जांच करते हैं, घटना से डेटा घटाते हैं, टिमरइन्फो संरचना से अग्रणी, स्क्रीन पर संरचना की सामग्री प्रदर्शित करते हैं और नोड की स्थिति को स्विच करते हैं।

मुख्य () फ़ंक्शन में कोड पिछले दो स्विचिंग उदाहरणों में कोड के समान है, इस अंतर के साथ कि हम इस घटना को दर्शक पर एक हैंडलर लटकाते हैं।

 viewer.addEventHandler(new TimerHandler(root.get(), 1000));

पॉइंटर नोड को पॉइंटर पास करना और आवश्यक स्विचिंग अंतराल को मिलीसेकंड में हैंडलर कंस्ट्रक्टर को भेजना। उदाहरण चलाते हुए, हम देखेंगे कि मॉडल एक दूसरे के अंतराल पर स्विच करते हैं, और कंसोल में हम उस समय का आउटपुट पाते हैं जिस पर स्विचिंग हुई है।

 Timer event at: 0 Timer event at: 1000 Timer event at: 2009 Timer event at: 3017 Timer event at: 4025 Timer event at: 5033

कार्यक्रम के निष्पादन के दौरान किसी भी समय एक कस्टम ईवेंट उत्पन्न किया जा सकता है, न कि केवल जब FRAME ईवेंट प्राप्त होता है, और यह प्रोग्राम के कुछ हिस्सों के बीच डेटा के आदान-प्रदान के लिए एक बहुत ही लचीली व्यवस्था देता है, उदाहरण के लिए जॉयस्टिक या वीआर दस्ताने जैसे गैर-मानक इनपुट डिवाइस से संकेतों को संसाधित करना संभव बनाता है।

जारी रखने के लिए ...

OpenSceneGraph: ईवेंट हैंडलिंग