परिचय

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

osgdb_< >.dll 

वह है, प्लगइन नाम में हमेशा osgdb_ उपसर्ग होता है। एक फ़ाइल एक्सटेंशन इंजन को बताता है कि इस एक्सटेंशन के साथ फ़ाइल डाउनलोड करने के लिए किस प्लग-इन का उपयोग किया जाना चाहिए। उदाहरण के लिए, जब हम कोड में एक फ़ंक्शन लिखते हैं

 osg::ref_ptr<osg::Node> model = osgDB::readNodeFile("cessna.osg"); 

इंजन osg एक्सटेंशन को देखता है और Linux के मामले में osgdb_osg.dll (या osgdb_osg.so) नामक एक प्लगइन को लोड करता है। प्लगइन कोड हमें एक पॉइंटर देता है जो हमें एक नोड को पॉइंटर देता है जो सेसना मॉडल का वर्णन करता है। इसी तरह, एक पीएनजी छवि लोड करने की कोशिश कर रहा है

 osg::ref_ptr<osg:Image> image = osgDB::readImageFile("picture.png"); 

कारण osgdb_png.dll प्लगइन को लोड किया जाएगा, जो PNG छवि से डेटा पढ़ने और इस डेटा को प्रकार osg :: छवि के ऑब्जेक्ट में रखने के लिए एक एल्गोरिथ्म को लागू करता है।

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

 $ osgconv cessna.osg cessna.3ds 

यह आसानी से और स्वाभाविक रूप से सेसना ओएसजी मॉडल को 3 डीएस प्रारूप में परिवर्तित करता है, जिसे बाद में 3 डी संपादक में आयात किया जा सकता है, उदाहरण के लिए, ब्लेंडर में (वैसे, सीधे ब्लेंडर के लिए ओएसजी के साथ काम करने के लिए एक एक्सटेंशन है )



उनके उद्देश्य के विवरण के साथ मानक ओएसजी प्लगइन्स की एक आधिकारिक सूची है, लेकिन यह लंबा है और मैं इसे यहां लाने के लिए बहुत आलसी हूं। बिन / ospPlugins-xyz फ़ोल्डर में लाइब्रेरी की स्थापना पथ को देखना आसान है, जहां x, y, z OSG संस्करण संख्या है। प्लगइन फ़ाइल के नाम से यह समझना आसान है कि यह किस प्रारूप में प्रक्रिया करता है।

यदि OSG को MinGW संकलक द्वारा संकलित किया जाता है, तो प्लगइन के मानक नाम में एक अतिरिक्त उपसर्ग mingw_ जोड़ा जाता है, अर्थात नाम इस तरह दिखेगा

 mingw_osgdb_< >.dll 

DEBUG कॉन्फ़िगरेशन में संकलित प्लगइन का संस्करण अतिरिक्त रूप से नाम के अंत में प्रत्यय d से सुसज्जित है, अर्थात् प्रारूप होगा

 osgdb_< >d.dll 

या

 mingw_osgdb_< >d.dll 

जब MinGW कोडांतरण।

1. प्लगइन्स छद्म लोडर

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

 $ osgviewer worldmap.shp.ogr 

इस स्थिति में, डिस्क पर फ़ाइल का वास्तविक नाम worldmap.shp है - यह फ़ाइल ESRI आकार स्वरूप में एक विश्व मानचित्र संग्रहीत करती है। प्रत्यय .ogr इस फ़ाइल को लोड करने के लिए osgdb_ogr प्लगइन का उपयोग करने के लिए osgDB लाइब्रेरी को बताता है; अन्यथा, osgdb_shp प्लगइन का उपयोग किया जाएगा।

एक और अच्छा उदाहरण osgdb_ffmpeg प्लगइन है। FFmpeg लाइब्रेरी 100 से अधिक विभिन्न कोडेक्स का समर्थन करती है। उनमें से किसी को भी पढ़ने के लिए, हम मीडिया फ़ाइल के नाम के बाद केवल प्रत्यय .ffmpeg जोड़ सकते हैं।

इसके अलावा, कुछ छद्म लोडर हमें कई प्रत्ययों के माध्यम से गुजरने की अनुमति देते हैं जो लोड की गई वस्तु की स्थिति को प्रभावित करते हैं, और हम पहले ही एनीमेशन के साथ एक उदाहरण में इसका सामना कर चुके हैं

 node = osgDB::readNodeFile("cessna.osg.0,0,90.rot"); 

लाइन 0.90 लोड किए गए मॉडल के प्रारंभिक अभिविन्यास के मापदंडों को ऑसग्डबोस प्लग को इंगित करता है। कुछ छद्म लोडरों को काम करने के लिए पूरी तरह से विशिष्ट मापदंडों की आवश्यकता होती है।

2. तृतीय-पक्ष प्लगइन्स विकसित करने के लिए एपीआई

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

प्लगइन का विकास ओएसजी द्वारा प्रदान किए गए वर्चुअल रीड / राइट इंटरफेस का विस्तार करना है। यह कार्यक्षमता osgDB :: ReaderWriter वर्चुअल क्लास द्वारा प्रदान की गई है। यह वर्ग प्लगइन डेवलपर द्वारा पुन: परिभाषित कई आभासी तरीके प्रदान करता है।

विधि	विवरण
समर्थन ()	यह दो स्ट्रिंग मापदंडों को स्वीकार करता है: फ़ाइल एक्सटेंशन और विवरण। विधि को हमेशा उपवर्ग के निर्माता में कहा जाता है।
स्वीकार्यता ()	लौटाया जाता है, यदि एक्सटेंशन तर्क के रूप में पारित हो जाता है, तो प्लगइन द्वारा समर्थित है
fileExists ()	आपको यह निर्धारित करने की अनुमति देता है कि क्या डिस्क पर कोई फ़ाइल मौजूद है (पथ को पैरामीटर के रूप में पास किया गया है)
readNode ()	एक ऑस्बीडी :: विकल्प ऑब्जेक्ट के रूप में फ़ाइल नाम और विकल्प स्वीकार करता है। डेवलपर द्वारा किसी फ़ाइल से डेटा पढ़ने के कार्य कार्यान्वित किए जाते हैं
राइटऑन	नोड नाम, वांछित फ़ाइल नाम और विकल्प स्वीकार करता है। डेवलपर को डेटा लिखने का कार्य डिस्क द्वारा कार्यान्वित किया जाता है
readImage ()	डिस्क बिटमैप डेटा पढ़ना
लिखनाइमेज ()	डिस्क पर एक बिटमैप लिखना

रीडऑनोड () पद्धति का कार्यान्वयन निम्नलिखित कोड द्वारा वर्णित किया जा सकता है

 osgDB::ReaderWriter::ReadResult readNode( const std::string &file, const osgDB::Options *options) const { //         bool recognizableExtension = ...; bool fileExists = ...; if (!recognizableExtension) return ReadResult::FILE_NOT_HANDLED; if (!fileExists) return ReadResult::FILE_NOT_FOUND; //          osg::Node *root = ...; //       -     . //    -      bool errorInParsing = ...; if (errorInParsing) return ReadResult::ERROR_IN_READING_FILE; return root; } 

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

एक अन्य उपयोगी वर्ग osgDB :: विकल्प है। यह आपको SetOptionString () और getOptionString () विधियों का उपयोग करके लोडिंग विकल्पों की एक स्ट्रिंग सेट या प्राप्त करने की अनुमति दे सकता है। इस स्ट्रिंग को इस वर्ग के कंस्ट्रक्टर को एक तर्क के रूप में पास करना भी अनुमति है।

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

 //    osg::Node* node1 = osgDB::readNodeFile("cow.osg"); //     string osg::Node* node2 = osgDB::readNodeFile("cow.osg", new osgDB::Options(string)); 

3. ओएसजी प्लगइन में डेटा प्रवाह प्रसंस्करण

बेस क्लास osgDB :: ReaderWriter में विधियों का एक सेट शामिल है जो मानक + ++ लाइब्रेरी द्वारा प्रदान किए गए इनपुट / आउटपुट स्ट्रीम के डेटा को संसाधित करता है। इन पढ़ने / लिखने के तरीकों और ऊपर चर्चा करने वालों के बीच का एकमात्र अंतर यह है कि फ़ाइल नाम के बजाय, वे std :: istream और input st स्ट्रीम या std :: ostream और आउटपुट स्ट्रीम स्वीकार करते हैं। फ़ाइल I / O स्ट्रीम का उपयोग करना फ़ाइल नाम का उपयोग करने के लिए हमेशा बेहतर होता है। फ़ाइल रीड ऑपरेशन करने के लिए हम निम्नलिखित इंटरफ़ेस डिज़ाइन का उपयोग कर सकते हैं:

 osgDB::ReaderWriter::ReadResult readNode( const std::string &file, const osgDB::Options *options) const { ... osgDB::ifstream stream(file.c_str(), std::ios::binary); if (!stream) return ReadResult::ERROR_IN_READING_FILE; return readNode(stream, options); } ... osgDB::ReaderWriter::ReadResult readNode( std::istream &stream, const osgDB::Options *options) const { //         osg::Node *root = ...; return root; } 

प्लगइन को लागू करने के बाद, हम मानक कार्यों का उपयोग कर सकते हैं osgDB :: readNodeFile () और osgDB :: readImageFile () मॉडल और छवियों को लोड करने के लिए, बस फ़ाइल पथ को निर्दिष्ट करके। OSG हमारे द्वारा लिखे गए प्लगइन को खोजेगा और डाउनलोड करेगा।

4. हम अपना खुद का प्लगइन लिखते हैं

इसलिए, कोई भी हमें त्रि-आयामी ज्यामिति पर डेटा संग्रहीत करने के लिए अपने स्वयं के प्रारूप के साथ आने के लिए परेशान नहीं करता है, और हम इसके साथ आएंगे

piramide.pmd

 vertex: 1.0 1.0 0.0 vertex: 1.0 -1.0 0.0 vertex: -1.0 -1.0 0.0 vertex: -1.0 1.0 0.0 vertex: 0.0 0.0 2.0 face: 0 1 2 3 face: 0 3 4 face: 1 0 4 face: 2 1 4 face: 3 2 4 

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

5. प्लगइन परियोजना सेटअप: स्क्रिप्ट सुविधाओं का निर्माण

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

plugin.pro

 TEMPLATE = lib CONFIG += plugin CONFIG += no_plugin_name_prefix TARGET = osgdb_pmd win32-g++: TARGET = $$join(TARGET,,mingw_,) win32 { OSG_LIB_DIRECTORY = $$(OSG_BIN_PATH) OSG_INCLUDE_DIRECTORY = $$(OSG_INCLUDE_PATH) DESTDIR = $$(OSG_PLUGINS_PATH) CONFIG(debug, debug|release) { TARGET = $$join(TARGET,,,d) LIBS += -L$$OSG_LIB_DIRECTORY -losgd LIBS += -L$$OSG_LIB_DIRECTORY -losgViewerd LIBS += -L$$OSG_LIB_DIRECTORY -losgDBd LIBS += -L$$OSG_LIB_DIRECTORY -lOpenThreadsd LIBS += -L$$OSG_LIB_DIRECTORY -losgUtild } else { LIBS += -L$$OSG_LIB_DIRECTORY -losg LIBS += -L$$OSG_LIB_DIRECTORY -losgViewer LIBS += -L$$OSG_LIB_DIRECTORY -losgDB LIBS += -L$$OSG_LIB_DIRECTORY -lOpenThreads LIBS += -L$$OSG_LIB_DIRECTORY -losgUtil } INCLUDEPATH += $$OSG_INCLUDE_DIRECTORY } unix { DESTDIR = /usr/lib/osgPlugins-3.7.0 CONFIG(debug, debug|release) { TARGET = $$join(TARGET,,,d) LIBS += -losgd LIBS += -losgViewerd LIBS += -losgDBd LIBS += -lOpenThreadsd LIBS += -losgUtild } else { LIBS += -losg LIBS += -losgViewer LIBS += -losgDB LIBS += -lOpenThreads LIBS += -losgUtil } } INCLUDEPATH += ./include HEADERS += $$files(./include/*.h) SOURCES += $$files(./src/*.cpp) 

हम व्यक्तिगत बारीकियों का अधिक विस्तार से विश्लेषण करेंगे

 TEMPLATE = lib 

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

 CONFIG += plugin 

इसके बाद, हम उस उपसर्ग की पीढ़ी को बाहर कर देते हैं, जो gcc परिवार के संकलक का उपयोग करते समय जोड़ी जाती है और पुस्तकालय को लोड करते समय रनटाइम वातावरण द्वारा ध्यान में रखा जाता है।

 CONFIG += no_plugin_name_prefix 

लाइब्रेरी फ़ाइल का नाम सेट करें

 TARGET = osgdb_pmd 

जहाँ pmd 3 डी मॉडल प्रारूप का फ़ाइल एक्सटेंशन है, जिसका हमने आविष्कार किया था। इसके अलावा, हमें संकेत देना चाहिए कि मिगव असेंबली के मामले में, उपसर्ग mingw_

 win32-g++: TARGET = $$join(TARGET,,mingw_,) 

लायब्रेरी बिल्ड पथ निर्दिष्ट करें: Windows के लिए

 DESTDIR = $$(OSG_PLUGINS_PATH) 

linux के लिए

 DESTDIR = /usr/lib/osgPlugins-3.7.0 

लिनक्स के लिए, पथ के ऐसे संकेत के साथ (जो निस्संदेह एक बैसाखी है, लेकिन मुझे अभी तक एक और समाधान नहीं मिला है) हम एक सामान्य उपयोगकर्ता से ओएसजी प्लगइन्स के साथ निर्दिष्ट फ़ोल्डर में लिखने का अधिकार देते हैं

 # chmod 666 /usr/lib/osgPlugins-3.7.0 

अन्य सभी बिल्ड सेटिंग्स पहले से उपयोग किए गए नमूना अनुप्रयोगों की असेंबली के समान हैं।

6. प्लगइन परियोजना सेटअप: डिबग मोड सुविधाएँ

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

 node = osdDB::readNodeFile("piramide.pmd"); 

इस स्थिति में, हमारा प्लगइन लोड होगा। इस तरह के कार्यक्रम को स्वयं नहीं लिखने के लिए, हम एक तैयार किए गए समाधान का उपयोग करेंगे - मानक ऑग्गीविअर दर्शक, जो इंजन के वितरण पैकेज में शामिल है। यदि कंसोल में निष्पादित

 $ osgviewer piramide.pmd 

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



अब हम प्लगइन चला सकते हैं और सीधे QtCreator IDE से डिबग कर सकते हैं।

6. हम प्लगइन फ्रेमवर्क को लागू करते हैं

यह उदाहरण कुछ हद तक उस ज्ञान को सामान्य करता है जो हमने पिछले पाठों से ओएसजी के बारे में प्राप्त किया है। एक प्लगइन लिखते समय, हमें करना होगा

1. मॉडल फ़ाइल से पढ़ी गई मॉडल ज्यामिति की जानकारी संग्रहीत करने के लिए एक डेटा संरचना का चयन करें
   
2. मॉडल डेटा फ़ाइल पढ़ें और पार्स करें
   
3. सही ढंग से osg :: फ़ाइल से पढ़े गए डेटा के आधार पर ड्रा करने योग्य ज्यामितीय वस्तु को कॉन्फ़िगर करें
   
4. लोडेड मॉडल के लिए एक दृश्य सबग्राफ बनाएँ
   

इसलिए, परंपरा से, मैं प्लगइन का संपूर्ण स्रोत कोड दूंगा


पहले, चलो ज्यामिति डेटा संग्रहीत करने के लिए संरचनाओं का ध्यान रखें।

 struct face_t { std::vector<unsigned int> indices; }; 

- इस चेहरे से संबंधित कोने के सूचकांकों की सूची द्वारा परिभाषित चेहरे का वर्णन करता है। एक पूरे के रूप में मॉडल को ऐसी संरचना द्वारा वर्णित किया जाएगा

 struct pmd_mesh_t { osg::ref_ptr<osg::Vec3Array> vertices; osg::ref_ptr<osg::Vec3Array> normals; std::vector<face_t> faces; pmd_mesh_t() : vertices(new osg::Vec3Array) , normals(new osg::Vec3Array) { } osg::Vec3 calcFaceNormal(const face_t &face) const { osg::Vec3 v0 = (*vertices)[face.indices[0]]; osg::Vec3 v1 = (*vertices)[face.indices[1]]; osg::Vec3 v2 = (*vertices)[face.indices[2]]; osg::Vec3 n = (v1 - v0) ^ (v2 - v0); return n * (1 / n.length()); } }; 

संरचना में डेटा संग्रहीत करने के लिए सदस्य चर होते हैं: रेखांकन - एक ज्यामितीय वस्तु के कोने की एक सरणी के भंडारण के लिए; मानदंड - वस्तु के चेहरों को मानदंडों का एक सरणी; चेहरे - वस्तु के चेहरों की एक सूची। संरचना निर्माता तुरंत स्मार्ट पॉइंटर्स को इनिशियलाइज़ करता है

 pmd_mesh_t() : vertices(new osg::Vec3Array) , normals(new osg::Vec3Array) { } 

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

इस प्रकार, हमने उन संरचनाओं पर निर्णय लिया, जिसमें हम ज्यामिति डेटा संग्रहीत करेंगे। अब हम अपने प्लगइन के फ्रेमवर्क को लिखते हैं, जिसका नाम है, हम ऑस्बीडी :: रीडरवर्टर इनहेरिटर क्लास लागू करते हैं

 class ReaderWriterPMD : public osgDB::ReaderWriter { public: ReaderWriterPMD(); virtual ReadResult readNode(const std::string &filename, const osgDB::Options *options) const; virtual ReadResult readNode(std::istream &stream, const osgDB::Options *options) const; private: pmd_mesh_t parsePMD(std::istream &stream) const; std::vector<std::string> parseLine(const std::string &line) const; }; 

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

 ReaderWriterPMD::ReaderWriterPMD() { supportsExtension("pmd", "PMD model file"); } 

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

 osgDB::ReaderWriter::ReadResult ReaderWriterPMD::readNode( const std::string &filename, const osgDB::Options *options) const { //       std::string ext = osgDB::getLowerCaseFileExtension(filename); // ,      if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED; // ,       std::string fileName = osgDB::findDataFile(filename, options); if (fileName.empty()) return ReadResult::FILE_NOT_FOUND; //      std::ifstream stream(fileName.c_str(), std::ios::in); if (!stream) return ReadResult::ERROR_IN_READING_FILE; //      readNode() return readNode(stream, options); } 

दूसरे अधिभार में, हम OSG के लिए ऑब्जेक्ट जेनरेशन एल्गोरिथम लागू करते हैं

 osgDB::ReaderWriter::ReadResult ReaderWriterPMD::readNode( std::istream &stream, const osgDB::Options *options) const { (void) options; //   *.pmd       pmd_mesh_t mesh = parsePMD(stream); //    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry; //    geom->setVertexArray(mesh.vertices.get()); //    for (size_t i = 0; i < mesh.faces.size(); ++i) { //    GL_POLYGON      (  - 0) osg::ref_ptr<osg::DrawElementsUInt> polygon = new osg::DrawElementsUInt(osg::PrimitiveSet::POLYGON, 0); //       for (size_t j = 0; j < mesh.faces[i].indices.size(); ++j) polygon->push_back(mesh.faces[i].indices[j]); //     geom->addPrimitiveSet(polygon.get()); } //    geom->setNormalArray(mesh.normals.get()); //  OpenGL,       geom->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE_SET); //             osg::ref_ptr<osg::Geode> geode = new osg::Geode; geode->addDrawable(geom.get()); //     return geode.release(); } 

Main.cpp फ़ाइल के अंत में, REGISTER_OSGPLUGIN () मैक्रो को कॉल करें।

 REGISTER_OSGPLUGIN( pmd, ReaderWriterPMD ) 

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

7. पारसिम 3 डी मॉडल फ़ाइल

अब प्लगइन की सभी कार्यक्षमता parsePMD () विधि के कार्यान्वयन पर टिकी हुई है

 pmd_mesh_t ReaderWriterPMD::parsePMD(std::istream &stream) const { pmd_mesh_t mesh; //    while (!stream.eof()) { //      std::string line; std::getline(stream, line); //     -     std::vector<std::string> tokens = parseLine(line); //    -  if (tokens[0] == "vertex") { //       osg::Vec3 point; std::istringstream iss(tokens[1]); iss >> point.x() >> point.y() >> point.z(); //      mesh.vertices->push_back(point); } //    -  if (tokens[0] == "face") { //         unsigned int idx = 0; std::istringstream iss(tokens[1]); face_t face; while (!iss.eof()) { iss >> idx; face.indices.push_back(idx); } //      mesh.faces.push_back(face); //     mesh.normals->push_back(mesh.calcFaceNormal(face)); } } return mesh; } 

ParseLine () मेथड फ़ाइल की पार्स लाइन

 std::vector<std::string> ReaderWriterPMD::parseLine(const std::string &line) const { std::vector<std::string> tokens; //   ,        ( Windows) std::string tmp = delete_symbol(line, '\r'); size_t pos = 0; std::string token; //      ,     : //      while ( (pos = tmp.find(':')) != std::string::npos ) { //     (vertex  face   ) token = tmp.substr(0, pos); //         tmp.erase(0, pos + 1); if (!token.empty()) tokens.push_back(token); } //        tokens.push_back(tmp); return tokens; } 

यह विधि स्ट्रिंग "वर्टेक्स: 1.0 -1.0 0.0" को दो लाइनों "वर्टेक्स" और "1.0 -1.0 0.0" की सूची में बदल देगी। पहली पंक्ति पर हम डेटा प्रकार की पहचान करते हैं - शीर्ष या चेहरा, दूसरी से हम डेटा को वर्टेक्स के निर्देशांक पर निकालते हैं। इस पद्धति के संचालन को सुनिश्चित करने के लिए, हमें सहायक फ़ंक्शन delete_symbol () की आवश्यकता है, जो स्ट्रिंग से दिए गए वर्ण को हटा देता है और एक स्ट्रिंग देता है जिसमें यह वर्ण नहीं होता है

 std::string delete_symbol(const std::string &str, char symbol) { std::string tmp = str; tmp.erase(std::remove(tmp.begin(), tmp.end(), symbol), tmp.end()); return tmp; } 

यही है, अब हमने अपने प्लगइन की सभी कार्यक्षमता को लागू किया है और इसका परीक्षण कर सकते हैं।

8. प्लगइन का परीक्षण

हम प्लगइन संकलित करते हैं और डीबगिंग (F5) चलाते हैं। मानक osgviewerd दर्शक का एक डीबग संस्करण लॉन्च किया जाएगा, जो इसके पास दिए गए पाइरामाइड.पीएमडी फ़ाइल का विश्लेषण करेगा, हमारे प्लगइन को लोड करेगा और इसके रीडऑन () विधि को कॉल करेगा। यदि हमने सब कुछ ठीक किया, तो हमें ऐसा परिणाम मिलेगा।



यह पता चलता है कि 3 डी मॉडल की हमारी आविष्कार की गई फ़ाइल में कोने और चेहरे की सूची ने एक चतुष्कोणीय पिरामिड छिपाया है।

हमने खुद मानदंडों की गणना क्यों की? पाठों में से एक में, हमें स्मूथ मानदंडों की स्वचालित गणना की निम्न विधि की पेशकश की गई थी

 osgUtil::SmoothingVisitor::smooth(*geom); 

हम अपने स्वयं के मानदंडों को निर्दिष्ट करने के बजाय, इस फ़ंक्शन को हमारे उदाहरण में लागू करते हैं

 //geom->setNormalArray(mesh.normals.get()); //geom->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE_SET); osgUtil::SmoothingVisitor::smooth(*geom); 

और हमें निम्नलिखित परिणाम मिलते हैं।



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