परिचय

तीन-आयामी ग्राफिक्स के माध्यम से हल किए गए सबसे दिलचस्प कार्यों में से एक "बड़ी दुनिया" का निर्माण है - मंच के चारों ओर असीमित आंदोलन की संभावना के साथ बड़ी संख्या में वस्तुओं वाले लंबे दृश्य। इस समस्या का समाधान कंप्यूटर हार्डवेयर में निहित समझदार सीमाओं पर टिकी हुई है।

एक विशिष्ट उदाहरण: OSG इंजन पर रेलवे की कल्पना करते समय "बड़ी दुनिया"। वह सब याद आ रहा है जो ट्रेन के पीछे दुनिया को खा जाने वाले लंगूरों को ...


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

1. विस्तार के स्तर (LOD) का उपयोग करना

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

OSG इस तकनीक को लागू करने के लिए उपकरण प्रदान करता है osg :: LOD वर्ग, जो एक ही osg :: समूह से विरासत में मिला है। यह वर्ग आपको विस्तार के कई स्तरों में एक ही वस्तु का प्रतिनिधित्व करने की अनुमति देता है। विस्तार के प्रत्येक स्तर को पर्यवेक्षक के लिए न्यूनतम और अधिकतम दूरी की विशेषता है, जिसके पालन में वस्तु का प्रदर्शन इस स्तर के विस्तार में बदल जाता है।

osg :: LOD आपको इस रेंज को तुरंत निर्दिष्ट करने की अनुमति देता है जब एक बाल नोड को परिभाषित करते हुए, या बाद में सेटरेंज (अन्य तरीकों) का उपयोग कर

osg::ref_ptr<osg::LOD> lodNode = new osg::LOD; lodNode->addChild(node2, 500.0f, FLT_MAX); lodNode->addChild(node1); . . . lodNode->setRange(1, 0.0f, 500.0f); 

हम सेसना को पीड़ा देते हैं और एक उदाहरण के साथ वर्णित तकनीक का वर्णन करते हैं


सबसे पहले, मॉडल लोड करें

 osg::ref_ptr<osg::Node> modelL3 = osgDB::readNodeFile("../data/cessna.osg"); 

अब आपको निचले स्तर के विवरण के साथ कई (हम खुद को दो उदाहरणों तक सीमित करेंगे) मॉडल तैयार करने की आवश्यकता है। ऐसा करने के लिए, क्लोन () विधि द्वारा लागू नोड के लिए, कक्षा की तथाकथित "गहरी" प्रतिलिपि की तकनीक का उपयोग करके, दो बार भरी हुई नोड की प्रतिलिपि बनाएँ।

 osg::ref_ptr<osg::Node> modelL2 = dynamic_cast<osg::Node *>(modelL3->clone(osg::CopyOp::DEEP_COPY_ALL)); osg::ref_ptr<osg::Node> modelL1 = dynamic_cast<osg::Node *>(modelL3->clone(osg::CopyOp::DEEP_COPY_ALL)); 

अब हम इन मॉडलों की ज्यामिति को कम कर देते हैं osgUtil का उपयोग करते हुए :: सिंपलीफ़ायर क्लास। मॉडल के सरलीकरण की डिग्री इस वर्ग के सेटसम्पलियो अनुपात () विधि द्वारा निर्धारित की जाती है - पैरामीटर जितना छोटा होता है, कम प्रक्रिया को लागू करने के बाद मॉडल उतना ही कम विस्तृत होगा।

 osgUtil::Simplifier simplifer; simplifer.setSampleRatio(0.5f); modelL2->accept(simplifer); simplifer.setSampleRatio(0.1f); modelL1->accept(simplifer); 

जब हमारे पास विस्तार के विभिन्न स्तरों के मॉडल होते हैं, तो हम उन्हें मूल नोड में चार्ज कर सकते हैं, जिसे ऑसग :: LOD को स्मार्ट पॉइंटर के रूप में बनाया जाता है। प्रत्येक स्तर के विवरण के लिए, इस स्तर की प्रदर्शन दूरी निर्धारित करें

 osg::ref_ptr<osg::LOD> root = new osg::LOD; root->addChild(modelL1.get(), 200.0f, FLT_MAX); root->addChild(modelL2.get(), 50.0f, 200.0f); root->addChild(modelL3.get(), 0.0f, 50.0f); 

FLT_MAX का मतलब किसी तरह से पर्यवेक्षक के लिए "असीम" बड़ी दूरी है। दर्शक शुरू करने के बाद, हमें निम्नलिखित चित्र मिलता है

विवरण 3 का स्तर



विस्तार 2 का स्तर



विस्तार का स्तर 1



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

2. दृश्य नोड्स के लिए पृष्ठभूमि लोडिंग तकनीक

OSG इंजन ओस्ग :: प्रोक्सीनोड और ऑस्ग :: PagedLOD क्लासेस प्रदान करता है, जो दृश्य को प्रस्तुत करते समय लोड को संतुलित करने के लिए डिज़ाइन किया गया है। दोनों वर्गों को ऑर्ग :: समूह से विरासत में मिला है।

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

Osg :: PagedNode नोड को osg :: LOD विधियाँ और लोडिंग और विस्तार के स्तर को इस तरह से विरासत में मिला है, जैसे कि OpenGL पाइपलाइन को ओवरलोड करने और दृश्य के सुचारू प्रतिपादन को सुनिश्चित करने के लिए।

3. मॉडल का गतिशील (रनटाइम) लोड हो रहा है

आइए देखें कि ओएसजी का उपयोग करके मॉडल को लोड करने की प्रक्रिया :: ProxyNode होती है।


यहां डाउनलोड की प्रक्रिया थोड़ी अलग है

 osg::ref_ptr<osg::ProxyNode> root = new osg::ProxyNode; root->setFileName(0, "../data/cow.osg"); 

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



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



उपरोक्त उदाहरण में क्या होता है? osg :: ProxyNode और osg :: PagedLOD कंटेनर के रूप में इस मामले में काम करते हैं। OSG आंतरिक डेटा प्रबंधक अनुरोधों को भेज देगा और डेटा को दृश्य ग्राफ में लोड कर देगा क्योंकि मॉडल फ़ाइलों और विस्तार के स्तरों के लिए आवश्यकता उत्पन्न होती है।

यह तंत्र कई पृष्ठभूमि धाराओं में काम करता है और डिस्क और डायनामिक डेटा पर फ़ाइलों में स्थित स्थैतिक डेटा के लोडिंग को नियंत्रित करता है और प्रोग्राम निष्पादन के दौरान जोड़ा जाता है।

इंजन स्वचालित रूप से नोड्स को संसाधित करता है जो वर्तमान व्यूपोर्ट में प्रदर्शित नहीं होते हैं और रेंडर ओवरलोड होने पर उन्हें दृश्य ग्राफ से हटा देता है। हालाँकि, यह व्यवहार osg :: ProxyNode नोड्स को प्रभावित नहीं करता है।

प्रॉक्सी नोड की तरह, ओएसजी :: PagedLOD क्लास में लोड किए गए मॉडल के लिए पथ निर्दिष्ट करने के लिए एक सेटफिलनेम () विधि भी है, हालांकि, आपको इसके लिए दृश्यता रेंज सेट करना होगा, जैसा कि ओएसजी :: एलओडी नोड के लिए है। बशर्ते कि हमारे पास एक cessna.osg फ़ाइल और स्तर L1 का एक लो-पॉली मॉडल है, हम निम्न प्रकार से p नोड को व्यवस्थित कर सकते हैं:

 osg::ref_ptr<osg::PagedLOD> pagedLOD = new osg::PagedLOD; pagedLOD->addChild(modelL1, 200.0f, FLT_MAX ); pagedLOD->setFileName( 1, "cessna.osg" ); pagedLOD->setRange( 1, 0.0f, 200.0f ); 

आपको यह समझने की आवश्यकता है कि मॉडलएल 1 नोड को मेमोरी से अनलोड नहीं किया जा सकता है, क्योंकि यह एक सामान्य बच्चा गैर-प्रॉक्सी नोड है।

जब प्रतिपादन, ओएसजी के बीच अंतर :: LOD और osg :: PagedLOD बाहर से दिखाई नहीं देता है, यदि आप मॉडल के विवरण के केवल एक स्तर का उपयोग करते हैं। एक दिलचस्प विचार सेस :: मेट्रिक्सट्रांसफॉर्म क्लास का उपयोग करके सेसना मॉडलों के एक विशाल समूह को व्यवस्थित करना होगा। इसके लिए, आप ऐसे फ़ंक्शन का उपयोग कर सकते हैं

 osg::Node* createLODNode( const osg::Vec3& pos ) { osg::ref_ptr<osg::PagedLOD> pagedLOD = new osg::PagedLOD; … osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform; mt->setMatrix( osg::Matrix::translate(pos) ); mt->addChild( pagedLOD.get() ); return mt.release(); } 

एक उदाहरण कार्यक्रम जो 10,000 विमानों की पृष्ठभूमि लोडिंग को लागू करता है

main.h

 #ifndef MAIN_H #define MAIN_H #include <osg/PagedLOD> #include <osg/MatrixTransform> #include <osgViewer/Viewer> #endif 

main.cpp

 #include "main.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ osg::Node *createLODNode(const std::string &filepath, const osg::Vec3 &pos) { osg::ref_ptr<osg::PagedLOD> pagedLOD = new osg::PagedLOD; pagedLOD->setFileName(0, filepath); pagedLOD->setRange(0, 0.0f, FLT_MAX); osg::ref_ptr<osg::MatrixTransform> mt = new osg::MatrixTransform; mt->setMatrix(osg::Matrix::translate(pos)); mt->addChild(pagedLOD.get()); return mt.release(); } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ int main(int argc, char *argv[]) { (void) argc; (void) argv; osg::ref_ptr<osg::Group> root = new osg::Group; float dist = 50.0f; int N = 100; for (int i = 0; i < N; ++i) { float x = i * dist; for (int j = 0; j < N; ++j) { float y = j * dist; osg::Vec3 pos(x, y, 0.0f); osg::ref_ptr<osg::Node> node = createLODNode("../data/cessna.osg", pos); root->addChild(node.get()); } } osgViewer::Viewer viewer; viewer.setSceneData(root.get()); return viewer.run(); } 

यह माना जाता है कि विमान 50 समन्वय इकाइयों के अंतराल के साथ एक विमान पर स्थित होगा। लोड करते समय, हम देखेंगे कि केवल वे सेसना जो फ्रेम में आते हैं, लोड किए जाते हैं। वे विमान जो फ्रेम से गायब होते हैं वे दृश्य पेड़ से गायब हो जाते हैं।

निष्कर्ष

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

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

लेकिन मैं अलविदा नहीं कहता, आपके ध्यान के लिए धन्यवाद और जल्द ही मिलते हैं !