परिचय

जब एक बिंदु, रेखा या जटिल बहुभुज को त्रि-आयामी दुनिया में खींचा जाता है, तो अंतिम परिणाम अंततः एक फ्लैट, दो-आयामी स्क्रीन पर प्रदर्शित किया जाएगा। तदनुसार, तीन-आयामी ऑब्जेक्ट एक निश्चित परिवर्तन पथ से गुजरते हैं, दो-आयामी विंडो में प्रदर्शित पिक्सेल के एक सेट में बदल जाते हैं।

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

इस लेख में, हम ओएसजी में तीन आयामी वस्तुओं को समूहीकृत करने और बदलने के लिए तंत्र की समीक्षा करेंगे।

1. मॉडल मैट्रिक्स, व्यू मैट्रिक्स और प्रोजेक्शन मैट्रिक्स

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

मॉडल के मैट्रिक्स का उपयोग 3 डी दुनिया में ऑब्जेक्ट के स्थान का वर्णन करने के लिए किया जाता है। यह वस्तु के स्थानीय समन्वय प्रणाली से वर्टिकल को विश्व समन्वय प्रणाली में रूपांतरित करता है । वैसे, ओएसजी में सभी समन्वय प्रणाली दाएं हाथ के हैं ।

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

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

Ve = V * modelViewMatrix 

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

उपरोक्त परिवर्तनों के बाद प्राप्त समन्वय प्रणाली को उपकरण का सामान्यीकृत समन्वय प्रणाली कहा जाता है , प्रत्येक अक्ष पर -1 से 1 तक एक समन्वय सीमा होती है और बाएं हाथ से होती है। और, एक अंतिम चरण के रूप में, प्राप्त डेटा को विंडो के डिस्प्ले पोर्ट (व्यूपोर्ट) में पेश किया जाता है, जो विंडो के क्लाइंट क्षेत्र की आयत द्वारा परिभाषित होता है। उसके बाद, 3D दुनिया हमारी 2D स्क्रीन पर दिखाई देती है। वर्टिकल बनाम के स्क्रीन निर्देशांक का अंतिम मूल्य बनाम निम्नलिखित परिवर्तन द्वारा व्यक्त किया जा सकता है

 Vs = V * modelViewMatrix * projectionMatrix * windowMatrix 

या

 Vs = V * MVPW 

जहां MVPW तीन मैट्रिसेस के उत्पाद के बराबर ट्रांसफॉर्मेशन मैट्रिक्स है: मॉडल-व्यू मैट्रिसेस, प्रोजेक्शन मैट्रिसेस, और विंडो मैट्रिसेस।

बनाम इस स्थिति में एक त्रि-आयामी वेक्टर है जो गहराई मान के साथ 2 डी पिक्सेल की स्थिति निर्धारित करता है। समन्वय परिवर्तन ऑपरेशन में, हमें त्रि-आयामी अंतरिक्ष में एक पंक्ति मिलती है। इसलिए, एक 2 डी बिंदु को दो बिंदुओं के रूप में माना जा सकता है - एक निकट पर (जेड = 0), दूसरा दूर क्लिपिंग विमान (जेडएस = 1) पर। त्रि-आयामी अंतरिक्ष में इन बिंदुओं के निर्देशांक

 V0 = (Xs, Ys, 0) * invMVPW V1 = (Xs, Ys, 1) * invMVPW 

जहाँ invMVPW MVPW का विलोम है।

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

2. समूह नोड्स

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

Osg :: समूह वर्ग osg :: Node वर्ग से लिया गया है, और तदनुसार osg :: संदर्भित वर्ग से विरासत में मिला है। osg :: Group में चाइल्ड नोड्स की एक सूची होती है, जहाँ प्रत्येक बच्चे के नोड को स्मार्ट पॉइंटर द्वारा नियंत्रित किया जाता है। यह सुनिश्चित करता है कि किसी दृश्य वृक्ष की एक शाखा को कैस्केडिंग करते समय कोई मेमोरी लीक न हो। यह वर्ग कई सार्वजनिक तरीकों के साथ डेवलपर को प्रदान करता है।

1. addChild () - नोड को चाइल्ड नोड्स की सूची के अंत में जोड़ता है। दूसरी ओर, इंसर्ट चिल्ड () विधि है, जो सूची में एक विशिष्ट स्थान पर बच्चे के नोड को रखती है, जो एक पूर्णांक सूचकांक या नोड के लिए एक सूचक द्वारा निर्दिष्ट किया जाता है, एक पैरामीटर के रूप में पारित किया गया है।
   
2. removeChild () और removeChildren () - नोड्स के एक नोड या समूह को हटा दें।
   
3. getChild () - सूची में इसके सूचकांक द्वारा नोड को एक पॉइंटर प्राप्त करना
   
4. getNumChildren () - इस समूह से जुड़े बाल नोड्स की संख्या प्राप्त करना।
   

जनक नोड प्रबंधन

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

OSG दृश्य नोड्स को कई मूल नोड्स बनाने की अनुमति देता है (हम किसी दिन इस बारे में बात करेंगे)। इस बीच, हम osg :: Node में बताए गए तरीकों को देखेंगे जो कि मूल नोड्स में हेरफेर करने के लिए उपयोग किए जाते हैं:

1. getParent () - प्रकार का एक सूचक देता है osg :: समूह जिसमें मूल नोड्स की सूची होती है।
   
2. getNumParants () - मूल नोड्स की संख्या लौटाता है।
   
3. getParentalNodePath () - वर्तमान नोड से दृश्य के रूट नोड के लिए सभी संभव पथ देता है। यह osg :: NodePath प्रकार के चर की सूची देता है।
   

osg :: NodePath एक std है: सदिश बिंदुओं के नोड्स का वेक्टर।



उदाहरण के लिए, आकृति में दिखाए गए दृश्य के लिए, निम्न कोड

 osg::NodePath &nodePath = child3->getParentalNodePaths()[0]; for (unsigned int i = 0; i < nodePath.size(); ++i) { osg::Node *node = nodePath[i]; // -    } 

नोड्स रूट, चाइल्ड 1, चाइल्ड 2 लौटाएगा।

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

3. सीन ट्री में कई मॉडल जोड़ना

हम निम्नलिखित उदाहरण के साथ समूहों का उपयोग करने के लिए तंत्र का वर्णन करते हैं।


मौलिक रूप से, उदाहरण पिछले सभी से अलग है जिसमें हम दो तीन आयामी मॉडल लोड करते हैं, और उन्हें उस दृश्य में जोड़ने के लिए हम एक समूह रूट नोड बनाते हैं और हमारे मॉडल मॉडल को बाल नोड के रूप में जोड़ते हैं।

 osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild(model1.get()); root->addChild(model2.get()); 

नतीजतन, हमें एक दृश्य मिलता है जिसमें दो मॉडल शामिल हैं - एक हवाई जहाज और एक अजीब दर्पण गाय। वैसे, एक दर्पण गाय तब तक दर्पण नहीं होगी जब तक कि आप हमारी परियोजना के OpenSceneGraph-Data / Images / reflect.rgb से डेटा / छवियाँ निर्देशिका में इसकी बनावट की प्रतिलिपि नहीं बनाते हैं।

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

 osg::ref_ptr<osg::Group> model = dynamic_cast<osg::Group *>(osgDB::readNodeFile("../data/cessna.osg")); 

OsgDB :: readNodeFile () फ़ंक्शन द्वारा दिया गया मान हमेशा प्रकार का होता है osg :: Node *, लेकिन इसे इसके osg :: Group * descendant में बदला जा सकता है। यदि सेसना मॉडल नोड एक समूह नोड है, तो रूपांतरण सफल होगा, अन्यथा, रूपांतरण NULL वापस आ जाएगा।

आप समान चाल भी कर सकते हैं जो अधिकांश संकलक पर काम करती है

 //      osg::ref_ptr<osg::Group> group = ...; //     osg::Node* node1 = dynamic_cast<osg::Node*>( group.get() ); //      osg::Node* node2 = group.get(); 

प्रदर्शन-महत्वपूर्ण कोड स्थानों में, विशेष रूपांतरण विधियों का उपयोग करना बेहतर है

 osg::ref_ptr<osg::Node> model = osgDB::readNodeFile("cessna.osg"); osg::Group* convModel1 = model->asGroup(); //   osg::Geode* convModel2 = model->asGeode(); //  NULL. 

4. परिवर्तन के नोड्स

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



इस उदाहरण दृश्य ग्राफ को निम्नलिखित ओपन कोड में अनुवादित किया जा सकता है

 glPushMatrix(); glMultMatrix( matrixOfTransform1 ); renderGeode1(); glPushMatrix(); glMultMatrix( matrixOfTransform2 ); renderGeode2(); glPopMatrix(); glPopMatrix(); 

हम कह सकते हैं कि Geode1 की स्थिति निर्देशांक प्रणाली Transform1 में सेट की गई है, और Geode2 की स्थिति समन्वय प्रणाली Transform2 में सेट है, Transform1 के सापेक्ष ऑफसेट। उसी समय, ओएसजी में पूर्ण निर्देशांक में स्थिति को सक्षम किया जा सकता है, जिससे ग्लोग्लोमैटमैट्रिक्स () ओपनजीएल कमांड के परिणाम के बराबर ऑब्जेक्ट का व्यवहार होगा

 transformNode->setReferenceFrame( osg::Transform::ABSOLUTE_RF ); 

आप सापेक्ष स्थिति मोड में वापस जा सकते हैं

 transformNode->setReferenceFrame( osg::Transform::RELATIVE_RF ); 

5. एक समन्वय परिवर्तन मैट्रिक्स की अवधारणा

Osg :: मैट्रिक्स प्रकार एक मूल OSG प्रकार है जिसे स्मार्ट पॉइंटर्स द्वारा नियंत्रित नहीं किया जाता है। यह 4x4 मैट्रिसेस पर संचालन के लिए एक इंटरफ़ेस प्रदान करता है जो निर्देशांक के परिवर्तन का वर्णन करता है, जैसे कि हिलना, घूमना, स्केलिंग और गणना। मैट्रिक्स को स्पष्ट रूप से निर्दिष्ट किया जा सकता है।

 //   44 osg::Matrix mat(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ); 

Osg :: मैट्रिक्स क्लास निम्नलिखित सार्वजनिक तरीके प्रदान करता है:

1. PostMult () और ऑपरेटर * () - मैट्रिक्स या वेक्टर द्वारा वर्तमान मैट्रिक्स का सही गुणन एक पैरामीटर के रूप में पारित किया गया। PreMult () विधि बाईं गुणा करता है।
   
2. makeTranslate (), makeRotate () और makeScale () - वर्तमान मैट्रिक्स को रीसेट करें और 4x4 मैट्रिक्स बनाएं जो आंदोलन, रोटेशन और स्केलिंग का वर्णन करता है। उनके स्थिर संस्करण अनुवाद (), रोटेट () और स्केल () का उपयोग विशिष्ट मापदंडों के साथ मैट्रिक्स ऑब्जेक्ट बनाने के लिए किया जा सकता है।
   
3. पलटना () - वर्तमान मैट्रिक्स के व्युत्क्रम की गणना करता है। व्युत्क्रम का इसका स्थिर संस्करण () एक मैट्रिक्स को एक पैरामीटर के रूप में लेता है और दिए गए एक नए मैट्रिक्स को उलटा देता है।
   

OSG मैट्रिसेस को स्ट्रिंग्स के मैट्रिसेस के रूप में समझता है, और वैक्टर स्ट्रिंग्स के रूप में, इसलिए, वेक्टर के मैट्रिक्स रूपांतरण को लागू करने के लिए ऐसा करें

 osg::Matrix mat = …; osg::Vec3 vec = …; osg::Vec3 resultVec = vec * mat; 

मैट्रिक्स परिचालनों के क्रम को यह देखकर समझना आसान है कि एक समान रूपांतरण प्राप्त करने के लिए मैट्रिस को कैसे गुणा किया जाता है

 osg::Matrix mat1 = osg::Matrix::scale(sx, sy, sz); osg::Matrix mat2 = osg::Matrix::translate(x, y, z); osg::Matrix resultMat = mat1 * mat2; 

डेवलपर को रूपांतरण प्रक्रिया को बाएं से दाएं पढ़ना चाहिए। यह है, वर्णित कोड टुकड़ा में, वेक्टर पहले तराजू, और फिर उसका आंदोलन।

osg :: मैट्रिक्स में टाइप फ्लोट के तत्व होते हैं।

6. ओस्ग का उपयोग करना: मैट्रिक्सट्रांसफॉर्म क्लास

हम दृश्य में विभिन्न बिंदुओं पर दो विमान मॉडल लोड करके व्यवहार में प्राप्त सैद्धांतिक ज्ञान को लागू करते हैं।


उदाहरण वास्तव में काफी तुच्छ है। फ़ाइल से हवाई जहाज मॉडल लोड हो रहा है

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

एक परिवर्तन नोड बनाएँ

 osg::ref_ptr<osg::MatrixTransform> transform1 = new osg::MatrixTransform; 

हमने एक्स अक्ष 25 इकाइयों के साथ मॉडल को स्थानांतरित करने के लिए मॉडल को बाईं ओर परिवर्तन मैट्रिक्स के रूप में सेट किया है

 transform1->setMatrix(osg::Matrix::translate(-25.0, 0.0, 0.0)); 

हम परिवर्तन नोड के लिए अपने मॉडल को एक बच्चे के नोड के रूप में सेट करते हैं

 transform1->addChild(model.get()); 

हम दूसरे परिवर्तन के साथ भी ऐसा ही करते हैं, लेकिन एक मैट्रिक्स के रूप में हमने आंदोलन को 25 इकाइयों द्वारा दाईं ओर सेट किया है

 osg::ref_ptr<osg::MatrixTransform> transform2 = new osg::MatrixTransform; transform2->setMatrix(osg::Matrix::translate(25.0, 0.0, 0.0)); transform2->addChild(model.get()); 

हम एक रूट नोड बनाते हैं और इसके लिए ट्रांसफ़ॉर्मेशन नोड्स के रूप में हम ट्रांसफ़ॉर्म नोड्स ट्रांसफॉर्म 1 और ट्रांसफॉर्म 2 सेट करते हैं

 osg::ref_ptr<osg::Group> root = new osg::Group; root->addChild(transform1.get()); root->addChild(transform2.get()); 

एक दर्शक बनाएं और रूट नोड को दृश्य डेटा के रूप में पास करें

 osgViewer::Viewer viewer; viewer.setSceneData(root.get()); 

कार्यक्रम चलाने से ऐसी तस्वीर मिलती है



इस उदाहरण में दृश्य ग्राफ की संरचना इस प्रकार है।



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

अपनी कार्रवाई में, osg :: MatrixTransform वर्ग OpenGL कमांड glMultMatrix () और glLoadMatrix () के बराबर है, सभी प्रकार के स्थानिक परिवर्तनों को लागू करता है, लेकिन परिवर्तन मैट्रिक्स की गणना करने की आवश्यकता के कारण उपयोग करना मुश्किल है।

Osg :: PositionAttitudeTransform वर्ग OpenGL फ़ंक्शंस glTranslate (), glScale (), glRotate () की तरह काम करता है। यह बाल नोड्स को परिवर्तित करने के लिए सार्वजनिक तरीके प्रदान करता है:

1. setPosition () - नोड को दिए गए स्थान में osg :: Vec3 पैरामीटर द्वारा निर्दिष्ट बिंदु पर ले जाएं
   
2. setScale () - समन्वय अक्षों के साथ ऑब्जेक्ट को स्केल करें। संबंधित कुल्हाड़ियों के साथ स्केलिंग कारक ओएसजी :: वीईसी 3 प्रकार के पैरामीटर द्वारा निर्धारित किए जाते हैं
   
3. setAttitude () - वस्तु का स्थानिक अभिविन्यास सेट करें। एक पैरामीटर के रूप में, यह osg :: Quat रोटेशन रूपांतरण quaternion लेता है, जिसके निर्माता के पास कई ओवरलोड हैं जो आपको quaternion को सीधे (घटक) दोनों को निर्दिष्ट करने की अनुमति देते हैं और, उदाहरण के लिए, यूलर एंगस के माध्यम से osg :: Quat (xAngle, osg :: X_AXIS, yAngle, osgle) :: Y_AXIS, zAngle, osg :: Z_AXIS) (कोण राडार में दिए गए हैं)!
   

7. स्विच नोड्स

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

1. एक दूसरे पैरामीटर के रूप में ओवरलोडेड ऐड चिल्ड (), एक तार्किक कुंजी लेता है जो इंगित करता है कि यह नोड प्रदर्शित करना है या नहीं।
   
2. setValue () - दृश्यता / अदर्शन कुंजी सेट करें। यह हमारे लिए ब्याज की बाल नोड का सूचकांक और वांछित कुंजी मूल्य लेता है। तदनुसार, getValue () आपको हमारे लिए ब्याज के नोड के सूचकांक द्वारा वर्तमान कुंजी मूल्य प्राप्त करने की अनुमति देता है।
   
3. setNewChildDefaultValue () - बच्चों के रूप में जोड़ी गई सभी नई वस्तुओं की दृश्यता कुंजी के लिए डिफ़ॉल्ट मान सेट करता है।
   

एक उदाहरण के साथ इस वर्ग के आवेदन पर विचार करें।


उदाहरण तुच्छ है - हम दो मॉडल लोड करते हैं: एक पारंपरिक सेसना और एक सेसना एक जलते हुए इंजन के प्रभाव के साथ

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

हालाँकि, हम osg :: रूट नोड के रूप में स्विच करते हैं, जो हमें अनुमति देता है, जब उनमें से प्रत्येक के लिए दृश्यता कुंजी सेट करने के लिए मॉडल को बाल नोड्स के रूप में जोड़ते हैं।

 osg::ref_ptr<osg::Switch> root = new osg::Switch; root->addChild(model1.get(), false); root->addChild(model2.get(), true); 

यही है, मॉडल 1 का प्रतिपादन नहीं किया जाएगा, और मॉडल 2 होगा, जिसे हम कार्यक्रम चलाकर देखेंगे



कुंजियों के मूल्यों को बदलकर हम विपरीत तस्वीर देखेंगे

 root->addChild(model1.get(), true); root->addChild(model2.get(), false); 

दोनों चाबियों को मिलाते हुए, हम एक ही समय में दो मॉडल देखेंगे

 root->addChild(model1.get(), true); root->addChild(model2.get(), true); 

आप नोड के दृश्य और अदर्शन को सक्षम कर सकते हैं, osg का एक बच्चा :: स्विच, सही पर सेटवैल्यू () विधि का उपयोग करके

 switchNode->setValue(0, false); switchNode->setValue(0, true); switchNode->setValue(1, true); switchNode->setValue(1, false); 

निष्कर्ष

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

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