परिचय

यह लेख ग्राफिक्स पर इतना ध्यान केंद्रित नहीं करेगा, क्योंकि इसका उपयोग करने वाले एप्लिकेशन को कैसे व्यवस्थित किया जाना चाहिए, OpenSceneGraph इंजन की बारीकियों और इसके द्वारा प्रदान किए जाने वाले सॉफ़्टवेयर के बारे में।

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

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

1. पार्सिंग कमांड लाइन विकल्प

C / C ++ में, कमांड लाइन पैरामीटर को मुख्य () फ़ंक्शन के तर्कों के माध्यम से पारित किया जाता है। पिछले उदाहरणों में, हमने सावधानीपूर्वक इन मापदंडों को अप्रयुक्त के रूप में चिह्नित किया है, अब हम उनका उपयोग अपने कार्यक्रम को कुछ डेटा बताने के लिए करेंगे जब यह शुरू होता है।

OSG में अंतर्निहित कमांड लाइन पार्सिंग टूल है।

निम्न उदाहरण बनाएँ


QtCreator में प्रोग्राम स्टार्टअप पैरामीटर सेट करें



निष्पादन के लिए कार्यक्रम चलाना, हमें इसका परिणाम मिलता है ( उसी OpenSceneGraph-Data से लिया गया ट्रक मॉडल)



अब एक उदाहरण लाइन लाइन पर देखते हैं

 osg::ArgumentParser args(&argc, argv); 

osg का उदाहरण बनाता है :: ArgumentParser कमांड लाइन parser वर्ग। निर्मित होने पर, क्लास कंस्ट्रक्टर को ऑपरेटिंग सिस्टम से मुख्य () फ़ंक्शन द्वारा स्वीकार किए गए तर्कों को पारित किया जाता है।

 std::string filename; args.read("--model", filename); 

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

 osg::ref_ptr<osg::Node> root = osgDB::readNodeFile(filename); osgViewer::Viewer viewer; viewer.setSceneData(root.get()); return viewer.run(); 

ओस की पढ़ने () विधि :: ArgumentParser वर्ग में बहुत अधिक भार होते हैं, जिससे आप कमांड लाइन से न केवल स्ट्रिंग मानों को पढ़ सकते हैं, बल्कि पूर्णांक, फ्लोटिंग पॉइंट नंबर, वैक्टर आदि भी कर सकते हैं। उदाहरण के लिए, आप फ्लोट के एक निश्चित पैरामीटर को पढ़ सकते हैं

 float size = 0.0f; args.read("--size", size); 

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

2. अधिसूचना और लॉगिंग तंत्र

OpenSceneGraph में एक अधिसूचना तंत्र है जो आपको रेंडरिंग प्रक्रिया के दौरान डिबगिंग संदेशों को प्रदर्शित करने की अनुमति देता है, साथ ही डेवलपर द्वारा शुरू किया जाता है। किसी प्रोग्राम को ट्रेस और डीबग करते समय यह एक बड़ी मदद है। OSG अधिसूचना प्रणाली इंजन कोर स्तर पर नैदानिक ​​जानकारी (त्रुटियों, चेतावनियों, सूचनाओं) के आउटपुट और इसके प्लग-इन का समर्थन करती है। डेवलपर osg :: सूचित () फ़ंक्शन का उपयोग करके प्रोग्राम ऑपरेशन के दौरान एक नैदानिक ​​संदेश प्रदर्शित कर सकता है।

यह फ़ंक्शन ऑपरेटर ओवरलोडिंग << के माध्यम से मानक C ++ लाइब्रेरी के मानक आउटपुट स्ट्रीम के रूप में काम करता है। यह संदेश स्तर को एक तर्क के रूप में लेता है: ALWAYS, FATAL, WARN, NOTICE, INFO, DEBUG_INFO और DEBUG_FP। उदाहरण के लिए

 osg::notify(osg::WARN) << "Some warning message" << std::endl; 

उपयोगकर्ता द्वारा परिभाषित पाठ के साथ एक चेतावनी प्रदर्शित करता है।

ओएसजी नोटिफिकेशन में कार्यक्रम की स्थिति, कंप्यूटर के ग्राफिक्स सबसिस्टम के विस्तार, इंजन के साथ संभावित समस्याओं के बारे में महत्वपूर्ण जानकारी हो सकती है।

कुछ मामलों में, इस डेटा को कंसोल में नहीं, बल्कि इस आउटपुट को किसी फ़ाइल (लॉग के रूप में) या किसी अन्य इंटरफ़ेस में ग्राफ़िक विजेट सहित किसी अन्य इंटरफ़ेस पर पुनर्निर्देशित करने के लिए आवश्यक है। इंजन में एक विशेष वर्ग का ऑसग :: नोटिफ़ैंडलर होता है जो आउटपुट स्ट्रीम के लिए सूचनाओं का पुनर्निर्देशन प्रदान करता है जो डेवलपर को चाहिए।

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


आउटपुट को रीडायरेक्ट करने के लिए, हम LogFileHandler क्लास लिखते हैं, जो osg का उत्तराधिकारी है :: NotifyHandler। इस वर्ग के निर्माता और विध्वंसक _log आउटपुट स्ट्रीम के खुलने और बंद होने को नियंत्रित करते हैं जो पाठ फ़ाइल के साथ जुड़ा हुआ है। नोटिफिकेशन () विधि एक ऐसी ही बेस क्लास विधि है, जिसे हमने OSG द्वारा भेजे गए फाइल नोटिफिकेशन के लिए संदेश पैरामीटर के माध्यम से ऑपरेशन के दौरान भेज दिया था।

वर्ग LogFileHandler

 class LogFileHandler : public osg::NotifyHandler { public: LogFileHandler(const std::string &file) { _log.open(file.c_str()); } virtual ~LogFileHandler() { _log.close(); } virtual void notify(osg::NotifySeverity severity, const char *msg) { _log << msg; } protected: std::ofstream _log; }; 

अगला, मुख्य कार्यक्रम में, आवश्यक सेटिंग्स निष्पादित करें

 osg::setNotifyLevel(osg::INFO); 

INFO सूचनाओं के स्तर को सेट करें, अर्थात्, सामान्य संचालन की वर्तमान सूचनाओं सहित इंजन के संचालन के बारे में सभी जानकारी के लॉग में आउटपुट।

 osg::setNotifyHandler(new LogFileHandler("../logs/log.txt")); 

सूचना हैंडलर स्थापित करें। अगला, हम कमांड लाइन तर्क प्रक्रिया करते हैं जिसमें लोड किए गए मॉडल के लिए मार्ग पारित किए जाते हैं

 osg::ArgumentParser args(&argc, argv); osg::ref_ptr<osg::Node> root = osgDB::readNodeFiles(args); if (!root) { OSG_FATAL << args.getApplicationName() << ": No data loaded." << std::endl; return -1; } 

उसी समय, हम कमांड लाइन पर डेटा की कमी की स्थिति को संभालते हैं, OSG_FATAL मैक्रो का उपयोग करके मैन्युअल मोड में लॉग में एक संदेश प्रदर्शित करते हैं। निम्नलिखित तर्कों के साथ कार्यक्रम चलाएं



इस तरह एक लॉग फ़ाइल के लिए उत्पादन हो रही है


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

डिफ़ॉल्ट रूप से, OSG std :: cout standard output और error messages को std :: cerr stream को संदेश भेजता है। हालाँकि, अधिसूचना हैंडलर को ओवरराइड करके, जैसा कि उदाहरण में दिखाया गया है, इस आउटपुट को GUI तत्वों सहित किसी भी आउटपुट स्ट्रीम पर पुनर्निर्देशित किया जा सकता है।

ध्यान रखें कि उच्च स्तर की सूचनाएँ (उदाहरण के लिए, FATAL) सेट करते समय, सिस्टम निचले स्तर की सभी सूचनाओं को अनदेखा कर देता है। उदाहरण के लिए, एक समान मामले में

 osg::setNotifyLevel(osg::FATAL); . . . osg::notify(osg::WARN) << "Some message." << std::endl; 

एक कस्टम संदेश बस प्रदर्शित नहीं किया जाएगा।

3. ज्यामितीय विशेषताओं का अवरोधन

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

हालांकि, इंजन कई प्रकार के फंक्शनल को लागू करता है जो आपको किसी भी ऑब्जेक्ट की ज्यामिति विशेषताओं को फिर से पढ़ने और पॉलीगोनल मेष के टोपोलॉजी को मॉडल करने के लिए उपयोग करने की अनुमति देता है। C ++ में, एक फ़नकार एक निर्माण है जो आपको एक फ़ंक्शन के रूप में ऑब्जेक्ट का उपयोग करने की अनुमति देता है।

Osg :: ड्रा करने योग्य वर्ग डेवलपर को चार प्रकार के फ़ंक्शंस प्रदान करता है:

1. osg :: Drawable :: AttributeFunctor - संकेत की एक सरणी के रूप में कोने की विशेषताओं को पढ़ता है। इसमें विभिन्न डेटा प्रकारों के शीर्ष गुण को लागू करने के लिए कई आभासी तरीके हैं। इस फ़ंक्टर का उपयोग करने के लिए, आपको कक्षा का वर्णन करना चाहिए और इसके एक या अधिक तरीकों को ओवरराइड करना चाहिए, जिसके अंदर डेवलपर द्वारा आवश्यक कार्य किए जाते हैं
   

 virtual void apply( osg::Drawable::AttributeType type, unsigned int size, osg::Vec3* ptr ) { //  3-     ptr. //      } 

1. osg :: Drawable :: ConstAttributeFunctor - पिछले फ़नकार का केवल-पढ़ने का संस्करण: वैक्टर के एक सरणी के लिए एक पॉइंटर एक निरंतर पैरामीटर के रूप में पारित किया जाता है
   
2. osg :: PrimitiveFunctor - OpenGL वस्तुओं के प्रतिपादन की प्रक्रिया का अनुकरण करता है। किसी ऑब्जेक्ट को रेंडर करने की आड़ में, डेवलपर द्वारा ओवरराइड की गई फ़ंक्टर विधियों को कहा जाता है। इस फ़नकार के दो महत्वपूर्ण टेम्पलेट उपवर्ग हैं: ऑग :: टेम्प्लेटप्रिटिव फ़ंक्टर <> और ऑग :: ट्राएंगलफ़नक्टर <>। ये कक्षाएं पैरामीटर के रूप में आदिम कोने प्राप्त करती हैं और उन्हें ऑपरेटर () ऑपरेटर का उपयोग करके उपयोगकर्ता विधियों में पास करती हैं।
   
3. osg :: PrimitiveIndexFunctor - पिछले फनकार के समान कार्य करता है, लेकिन एक पैरामीटर के रूप में आदिम के शीर्ष सूचकांक को स्वीकार करता है।
   

Osg से व्युत्पन्न वर्ग :: ड्रा करने योग्य, जैसे कि osg :: ShapeDrawable और osg :: Geometry, में विभिन्न फंक्शन्स को लागू करने के लिए एक स्वीकार () विधि है।

4. आदिम कवक का उपयोग करने का उदाहरण

हम त्रिकोणीय चेहरे और पहले से निर्धारित कुछ ज्यामिति के बिंदुओं के बारे में जानकारी एकत्र करने के उदाहरण का उपयोग करके वर्णित कार्यक्षमता का वर्णन करते हैं।


हमारे द्वारा कई बार माना जाने वाली ज्यामिति बनाने की प्रक्रिया को स्वीकार करते हुए, हम निम्नलिखित पर ध्यान दें। हम एक फेसकोलर संरचना को परिभाषित करते हैं जिसके लिए हम ऑपरेटर () को निम्न प्रकार से परिभाषित करते हैं

 struct FaceCollector { void operator()(const osg::Vec3 &v1, const osg::Vec3 &v2, const osg::Vec3 &v3) { std::cout << "Face vertices: " << vec2str(v1) << "; " << vec2str(v2) << "; " << vec2str(v3) << std::endl; } }; 

यह ऑपरेटर, जिसे बुलाया जाता है, इंजन द्वारा इसके लिए प्रेषित तीन कोने के निर्देशांक प्रदर्शित करेगा। Vec2str फ़ंक्शन को osg :: Vec3 वेक्टर से std :: string के घटकों का अनुवाद करना आवश्यक है। फ़नकार को कॉल करने के लिए, इसका एक उदाहरण बनाएं और इसे स्वीकार () विधि के माध्यम से ज्यामिति ऑब्जेक्ट में पास करें

 osg::TriangleFunctor<FaceCollector> functor; geom->accept(functor); 

यह कॉल, जैसा कि ऊपर उल्लेख किया गया है, ज्यामिति के प्रतिपादन की नकल करता है, एक ओवरराइड फ़ंक्शनल विधि को बुलाकर ड्राइंग को प्रतिस्थापित करता है। इस मामले में, इसे प्रत्येक त्रिकोण के "ड्राइंग" के दौरान कहा जाएगा जो उदाहरण के ज्यामिति को बनाते हैं।

स्क्रीन पर हमें ऐसी ज्यामिति मिलती है



और कंसोल के लिए ऐसा निकास

 Face vertices: 0.000000 0.000000 0.000000; 0.000000 0.000000 1.000000; 1.000000 0.000000 0.000000 Face vertices: 0.000000 0.000000 1.000000; 1.000000 0.000000 1.500000; 1.000000 0.000000 0.000000 Face vertices: 1.000000 0.000000 0.000000; 1.000000 0.000000 1.500000; 2.000000 0.000000 0.000000 Face vertices: 1.000000 0.000000 1.500000; 2.000000 0.000000 1.000000; 2.000000 0.000000 0.000000 Face vertices: 2.000000 0.000000 0.000000; 2.000000 0.000000 1.000000; 3.000000 0.000000 0.000000 Face vertices: 2.000000 0.000000 1.000000; 3.000000 0.000000 1.500000; 3.000000 0.000000 0.000000 Face vertices: 3.000000 0.000000 0.000000; 3.000000 0.000000 1.500000; 4.000000 0.000000 0.000000 Face vertices: 3.000000 0.000000 1.500000; 4.000000 0.000000 1.000000; 4.000000 0.000000 0.000000 

वास्तव में, जब कॉलिंग जियोम-> स्वीकार करते हैं (...), त्रिकोण प्रदान नहीं किए जाते हैं, तो ओपनजीएल कॉल की नकल की जाती है, और इसके बजाय, त्रिकोण के कोने के बारे में डेटा, जिनमें से प्रतिपादन अनुकरण किया गया है



Osg :: TemplatePrimitiveFunctor वर्ग न केवल त्रिकोण के बारे में, बल्कि किसी भी अन्य OpenGL आदिम के बारे में भी डेटा एकत्र करता है। इस डेटा के प्रसंस्करण को कार्यान्वित करने के लिए, आपको टेम्पलेट तर्क में निम्नलिखित ऑपरेटरों को ओवरराइड करना होगा

 //   void operator()( const osg::Vec3&, bool ); //   void operator()( const osg::Vec3&, const osg::Vec3&, bool ); //   void operator()( const osg::Vec3&, const osg::Vec3&, const osg::Vec3&, bool ); //   void operator()( const osg::Vec3&, const osg::Vec3&, const osg::Vec3&, const osg::Vec3&, bool ); 

5. विज़िटर पैटर्न

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

OSG में इस तंत्र को लागू करने के लिए, ऑग :: NodeVisitor वर्ग को परिभाषित किया गया है। ओसग से विरासत में मिला वर्ग :: NodeVisitor दृश्य ग्राफ के चारों ओर चलता है, प्रत्येक नोड पर जाता है और डेवलपर द्वारा परिभाषित कार्यों को लागू करता है। यह नोड्स को अपडेट करने और अदृश्य नोड्स को क्लिप करने की प्रक्रिया में हस्तक्षेप करने के लिए इस्तेमाल किया जाने वाला मुख्य वर्ग है, साथ ही दृश्य नोड्स की ज्यामिति को संशोधित करने से संबंधित कुछ अन्य संचालन को लागू करता है, जैसे कि ऑसगुतिल :: स्मूथिंगवेटिटर, ऑसगुतिल :: सरलीकृत और ऑसगुतिल :: ट्राईस्ट्रिपविसीटर।

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

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

आवेदन के ओवरलोड () विधि में एकीकृत प्रारूप हैं

 virtual void apply( osg::Node& ); virtual void apply( osg::Geode& ); virtual void apply( osg::Group& ); virtual void apply( osg::Transform& ); 

विज़िटर ऑब्जेक्ट के लिए वर्तमान नोड के सबग्राफ को बायपास करने के लिए, आपको क्रॉल मोड सेट करना होगा, उदाहरण के लिए

 ExampleVisitor visitor; visitor->setTraversalMode( osg::NodeVisitor::TRAVERSE_ALL_CHILDREN ); node->accept( visitor ); 

बाईपास मोड कई प्रगणकों द्वारा निर्धारित किया जाता है

1. TRAVERSE_ALL_CHILDREN - सभी बच्चे नोड्स के माध्यम से आगे बढ़ रहे हैं।
   
2. TRAVERSE_PARENTS - वर्तमान नोड से वापस पास होते हैं, रूट नोड तक नहीं पहुंचते हैं
   
3. TRAVERSE_ACTIVE_CHILDREN - विशेष रूप से सक्रिय नोड्स को बायपास करता है, अर्थात, जिनकी दृश्यता osg :: स्विच नोड के माध्यम से सक्रिय होती है।
   

6. जलती हुई सेसना की संरचना का विश्लेषण

डेवलपर हमेशा दृश्य ग्राफ के उस हिस्से का विश्लेषण कर सकता है जो फ़ाइल से लोड किए गए मॉडल द्वारा उत्पन्न होता है।


हम InfoVisitor क्लास बनाते हैं, जो इसे osg :: NodeVisitor से विरासत में मिला है

 class InfoVisitor : public osg::NodeVisitor { public: InfoVisitor() : _level(0) { setTraversalMode(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN); } std::string spaces() { return std::string(_level * 2, ' '); } virtual void apply(osg::Node &node); virtual void apply(osg::Geode &geode); protected: unsigned int _level; }; 

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

अब नोड्स के लिए लागू () तरीकों को फिर से परिभाषित करें

 void InfoVisitor::apply(osg::Node &node) { std::cout << spaces() << node.libraryName() << "::" << node.className() << std::endl; _level++; traverse(node); _level--; } 

यहां हम वर्तमान नोड के प्रकार को आउटपुट करेंगे। नोड के लिए LibraryName () विधि OSG लाइब्रेरी का नाम प्रदर्शित करती है जहां यह नोड कार्यान्वित किया जाता है, और className विधि नोड वर्ग का नाम प्रदर्शित करती है। इन विधियों को OSG पुस्तकालयों के कोड में मैक्रोज़ के उपयोग के माध्यम से कार्यान्वित किया जाता है।

 std::cout << spaces() << node.libraryName() << "::" << node.className() << std::endl; 

उसके बाद, हम ग्राफ स्तर के काउंटर को बढ़ाते हैं और ट्रैवस () विधि को कॉल करते हैं, जिससे बच्चे के नोड तक उच्च स्तर पर संक्रमण शुरू होता है। ट्रैवर्स () से लौटने के बाद, हम फिर से काउंटर वैल्यू को कम करते हैं। यह अनुमान लगाना आसान है कि ट्रैवर्स () लागू करने के लिए एक बार-बार कॉल शुरू करता है () विधि, दोहराया नोड () पहले से ही एक नोड के लिए शुरू होता है। हम पुनरावर्ती आगंतुक निष्पादन प्राप्त करते हैं जब तक कि हम दृश्य ग्राफ के अंत नोड्स को नहीं मारते।

ओएसजी के अंतिम नोड के लिए :: जिओड, इसका ओवरलोड लागू () विधि से अधिक है

 void InfoVisitor::apply(osg::Geode &geode) { std::cout << spaces() << geode.libraryName() << "::" << geode.className() << std::endl; _level++; for (unsigned int i = 0; i < geode.getNumDrawables(); ++i) { osg::Drawable *drawable = geode.getDrawable(i); std::cout << spaces() << drawable->libraryName() << "::" << drawable->className() << std::endl; } traverse(geode); _level--; } 

इसी तरह काम करने वाले कोड के अलावा, हम वर्तमान ज्यामितीय नोड से जुड़ी सभी ज्यामितीय वस्तुओं पर डेटा प्रदर्शित करते हैं

 for (unsigned int i = 0; i < geode.getNumDrawables(); ++i) { osg::Drawable *drawable = geode.getDrawable(i); std::cout << spaces() << drawable->libraryName() << "::" << drawable->className() << std::endl; } 

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

 osg::ArgumentParser args(&argc, argv); osg::ref_ptr<osg::Node> root = osgDB::readNodeFiles(args); if (!root.valid()) { OSG_FATAL << args.getApplicationName() << ": No data leaded. " << std::endl; return -1; } 

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

 InfoVisitor infoVisitor; root->accept(infoVisitor); 

आगे दर्शक को लॉन्च करने के चरण हैं, जो हम पहले ही कई बार कर चुके हैं। मापदंडों के साथ कार्यक्रम शुरू करने के बाद

 $ visitor ../data/cessnafire.osg 

हम कंसोल के लिए निम्न आउटपुट देखेंगे

 osg::Group osg::MatrixTransform osg::Geode osg::Geometry osg::Geometry osg::MatrixTransform osgParticle::ModularEmitter osgParticle::ModularEmitter osgParticle::ParticleSystemUpdater osg::Geode osgParticle::ParticleSystem osgParticle::ParticleSystem osgParticle::ParticleSystem osgParticle::ParticleSystem 

वास्तव में, हमें लोडेड सीन का एक पूरा पेड़ मिला है। माफ करना, इतने सारे नोड्स कहाँ हैं? सब कुछ बहुत सरल है - * .osg प्रारूप के मॉडल स्वयं कंटेनर होते हैं जो न केवल मॉडल की ज्यामिति को स्टोर करते हैं, बल्कि ओएसजी दृश्य के एक सबग्राफ के रूप में इसकी संरचना के बारे में अन्य जानकारी भी देते हैं। मॉडल की ज्यामिति, रूपांतरण, कण प्रभाव जो धुएं और लौ का एहसास करते हैं, वे सभी OSG दृश्य ग्राफ के नोड हैं।किसी भी दृश्य को या तो * .osg से डाउनलोड किया जा सकता है या दर्शक से * .osg प्रारूप में अनलोड किया जा सकता है।

यह आगंतुक यांत्रिकी लागू करने का एक सरल उदाहरण है। वास्तव में, आगंतुकों के अंदर, आप प्रोग्राम के निष्पादन के दौरान नोड्स को संशोधित करने के लिए बहुत सारे ऑपरेशन कर सकते हैं।

7. अनुप्रस्थ () विधि को ओवरराइड करके दृश्य ग्राफ में नोड्स के व्यवहार को नियंत्रित करना

OSG के साथ काम करने का एक महत्वपूर्ण तरीका है ट्रैवर्स () विधि को ओवरराइड करना। हर बार फ्रेम तैयार होने पर इस विधि को कहा जाता है। वे प्रकार के एक पैरामीटर को स्वीकार करते हैं osg :: NodeVisitor और जो रिपोर्ट करता है कि दृश्य ग्राफ़ का कौन सा मार्ग वर्तमान में प्रदर्शन किया जा रहा है (अद्यतन, घटना प्रसंस्करण, या क्लिपिंग)। अधिकांश OSG होस्ट अपनी कार्यक्षमता को लागू करने के लिए इस विधि को ओवरराइड करते हैं।

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

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


आइए इस उदाहरण पर एक नज़र डालें। हम एक नया AnimatingSwitch क्लास बना रहे हैं जो osg से प्राप्त होता है :: स्विच।

 class AnimatingSwitch : public osg::Switch { public: AnimatingSwitch() : osg::Switch(), _count(0) {} AnimatingSwitch(const AnimatingSwitch &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY) : osg::Switch(copy, copyop), _count(copy._count) {} META_Node(osg, AnimatingSwitch); virtual void traverse(osg::NodeVisitor &nv); protected: unsigned int _count; }; void AnimatingSwitch::traverse(osg::NodeVisitor &nv) { if (!((++_count) % 60) ) { setValue(0, !getValue(0)); setValue(1, !getValue(1)); } osg::Switch::traverse(nv); } 

इस वर्ग में डिफ़ॉल्ट कंस्ट्रक्टर है।

 AnimatingSwitch() : osg::Switch(), _count(0) {} 

और प्रतिलिपि बनाने के लिए निर्माता, OSG की आवश्यकताओं के अनुसार बनाया गया

 AnimatingSwitch(const AnimatingSwitch &copy, const osg::CopyOp &copyop = osg::CopyOp::SHALLOW_COPY) : osg::Switch(copy, copyop), _count(copy._count) {} 

कॉपी करने के लिए कंस्ट्रक्टर में पैरामीटर के रूप में होना चाहिए: कॉपी करने के लिए क्लास इंस्टेंस का एक निरंतर संदर्भ और ओएसजी :: कॉपीऑप पैरामीटर क्लास की कॉपी सेटिंग्स को निर्दिष्ट करता है। सुंदर अजीब पत्र का पालन करें

 META_Node(osg, AnimatingSwitch); 

यह एक मैक्रो है जो कि ऑस्ग :: नोड से व्युत्पन्न एक वर्ग के वंशज के लिए आवश्यक संरचना बनाता है। जब तक हम इस मैक्रो को महत्व देते हैं, तब तक यह महत्वपूर्ण है कि यह सभी वंशजों को परिभाषित करते समय ओएसजी से स्विच करें: मौजूद होना चाहिए। वर्ग में संरक्षित फ़ील्ड _count शामिल है - बहुत काउंटर जिसके आधार पर हम स्विच करते हैं। हम पारगमन () विधि को ओवरराइड करते समय स्विचिंग को लागू करते हैं

 void AnimatingSwitch::traverse(osg::NodeVisitor &nv) { if (!((++_count) % 60) ) { setValue(0, !getValue(0)); setValue(1, !getValue(1)); } osg::Switch::traverse(nv); } 

नोड्स के प्रदर्शन की स्थिति स्विच करने पर हर बार काउंटर का मूल्य (प्रत्येक विधि कॉल को बढ़ाना) 60 का गुणक होगा। हम उदाहरण संकलित करते हैं और इसे चलाते हैं



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

क्लिपिंग पास को ऑग :: NodeVisitor to osg :: CullVisitor ऑब्जेक्ट में कनवर्ट करके पहचाना जा सकता है

 osgUtil::CullVisitor *cv = dynamic_cast<osgUtil::CullVisitor *>(&nv); if (cv) { ///  - ,     } 

8. कॉलबैक तंत्र

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

इंजन में कई तरह के कॉलबैक होते हैं। कॉलबैक को विशेष वर्गों द्वारा कार्यान्वित किया जाता है, जिसके बीच ऑस्ग :: NodeCallback को दृश्य नोड्स को अपडेट करने की प्रक्रिया को संभालने के लिए डिज़ाइन किया गया है, और osg :: Drawable: UpdateCallback, osg :: Drawable :: EventCallback और osg - ड्रॉबल: CullCallback - समान कार्य करते हैं, लेकिन ज्यामिति वस्तुओं के लिए।

Osg :: NodeCallback वर्ग के पास अपनी कार्यक्षमता को लागू करने के लिए डेवलपर द्वारा प्रदान किया गया एक अति-योग्य वर्चुअल ऑपरेटर () ऑपरेटर है। कार्य करने के लिए कॉलबैक के लिए, आपको कॉल क्लास का एक उदाहरण नोड से जोड़ना होगा, जिसके लिए इसे सेटअपडेट कॉलबैक () या ऐड यूपीडेट कॉलबैक () विधि से कॉल करके संसाधित किया जाएगा। प्रत्येक फ्रेम को प्रस्तुत करते समय ऑपरेटर () ऑपरेटर को स्वचालित रूप से नोड्स के दृश्य के अद्यतन के दौरान कहा जाता है।

निम्न तालिका OSG में डेवलपर के लिए उपलब्ध कॉलबैक को सूचीबद्ध करती है।

पहला नाम	कॉलबैक फ़नकार	आभासी विधि	किसी वस्तु से जुड़ने की विधि
नोड अपडेट	ऑसग :: नॉडकॉलबैक	ऑपरेटर ()	osg :: नोड :: setUpdateCallback ()
नोड घटना	ऑसग :: नॉडकॉलबैक	ऑपरेटर ()	osg :: नोड :: setEventCallback ()
नोड क्लिपिंग	ऑसग :: नॉडकॉलबैक	ऑपरेटर ()	osg :: नोड :: setCullCallback ()
ज्यामिति अद्यतन	osg::Drawable::UpdateCallback	update()	osg::Drawable::setUpdateCallback()
	osg::Drawable::EventCallback	event()	osg::Drawable::setEventCallback()
	osg::Drawable::CullCallback	cull()	osg::Drawable::setCullCallback()
	osg::StateAttributeCallback	operator()	osg::StateAttribute::setUpdateCallback()
	osg::StateAttributeCallback	operator()	osg::StateAttribute::setEventCallback()
	osg::Uniform::Callback	operator()	osg::Uniform::setUpdateCallback()
	osg::Uniform::Callback	operator()	osg::Uniform::setEvevtCallback()
	osg::Camera::DrawCallback	operator()	osg::Camera::PreDrawCallback()
	osg::Camera::DrawCallback	operator()	osg::Camera::PostDrawCallback()

9. osg::Switch

थोड़ा और ऊपर, हमने विमान के दो मॉडल स्विच करने के साथ एक उदाहरण लिखा। अब हम इस उदाहरण को दोहराएंगे, लेकिन हम ओएसजी कॉलबैक तंत्र का उपयोग करके सब कुछ सही ढंग से करेंगे।


आपको osg :: NodeCallback से विरासत में मिला हुआ एक वर्ग बनाना होगा, जो osg को नियंत्रित करता है :: स्विच नोड

 class SwitchingCallback : public osg::NodeCallback { public: SwitchingCallback() : _count(0) {} virtual void operator()(osg::Node *node, osg::NodeVisitor *nv); protected: unsigned int _count; }; 

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

 void SwitchingCallback::operator()(osg::Node *node, osg::NodeVisitor *nv) { osg::Switch *switchNode = static_cast<osg::Switch *>(node); if ( !((++_count) % 60) && switchNode ) { switchNode->setValue(0, !switchNode->getValue(0)); switchNode->setValue(1, !switchNode->getValue(0)); } traverse(node, nv); } 

जिस नोड पर काम किया गया है वह नोड पैरामीटर के माध्यम से इसे पारित किया गया है। चूँकि हम यह सुनिश्चित करते हैं कि यह एक प्रकार का नोड होगा जैसे ऑग :: स्विच, हम पॉइंटर को नोड से पॉइंटर को स्विच नोड के लिए एक स्थिर कास्ट करते हैं।

 osg::Switch *switchNode = static_cast<osg::Switch *>(node); 

हम इस पॉइंटर के वैध मान के साथ प्रदर्शित चाइल्ड नोड्स को स्विच करेंगे, और जब काउंटर वैल्यू 60 से अधिक होगी

 if ( !((++_count) % 60) && switchNode ) { switchNode->setValue(0, !switchNode->getValue(0)); switchNode->setValue(1, !switchNode->getValue(0)); } 

दृश्य ग्राफ के पुनरावर्ती ट्रावेल को जारी रखने के लिए ट्रैवर्स () विधि को कॉल करना न भूलें

 traverse(node, nv); 

प्रोग्राम प्रोग्राम का बाकी हिस्सा तुच्छ है, लाइन को छोड़कर

 root->setUpdateCallback( new SwitchingCallback ); 

जहाँ हम कॉलबैक असाइन करते हैं, वह हमने मूल नोड के प्रकार में बनाया है :: स्विच। कार्यक्रम पिछले उदाहरण के समान काम करता है



अब तक, हमने दो उद्देश्यों के लिए रहस्यमय पारगमन () पद्धति का उपयोग किया है: उत्तराधिकारी कक्षाओं में इस पद्धति को ओवरराइड करके और इस ग्राफ को ओएसजी :: NodeVisitor क्लास को कॉल करके दृश्य ग्राफ को जारी रखने के लिए।

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

AddUpdateCallback () विधियाँ नोड में कॉलबैक जोड़ने के लिए भी कार्य करती हैं। SetUpdateCallback () के विपरीत, इसका उपयोग मौजूदा वाले को एक और कॉलबैक जोड़ने के लिए किया जाता है। इस प्रकार, एक ही नोड के लिए कई कॉलबैक हो सकते हैं।

निष्कर्ष

हमने OpenSceneGraph ग्राफिक्स इंजन का उपयोग करके विकासशील अनुप्रयोगों में उपयोग की जाने वाली मूल तकनीकों की जांच की। हालाँकि, यह उन सभी बिंदुओं से दूर है जिन्हें मैं छूना चाहूंगा (इस तथ्य के बावजूद कि लेख काफी लंबा निकला), इसलिए

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