परिचय

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

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

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

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

1. कक्षाएं जियोड और ड्रॉएबल

ऑसग :: जिओड क्लास एक टर्मिनल है, जो दृश्य पेड़ का तथाकथित "पत्ता" नोड है। इसमें बाल नोड नहीं हो सकते हैं, लेकिन इसमें ज्यामिति के प्रतिपादन के लिए सभी आवश्यक जानकारी समाहित है। इसका नाम, जियोड, ज्यामिति नोड के लिए छोटा है।

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

ओएसजी :: जियोड क्लास ड्रॉइंग अटैच और डिटैच करने के लिए कई तरीके प्रदान करता है:

• सार्वजनिक विधि addDrawable () - ओस के एक उदाहरण में एक ड्रॉबल तत्व के लिए एक पॉइंटर पास करता है :: जिओड क्लास। ये सभी तत्व osg :: ref_ptr <> स्मार्ट पॉइंटर्स द्वारा नियंत्रित होते हैं।
  
• सार्वजनिक विधि हटाने योग्य () और हटाने योग्य () osg :: Geode से ऑब्जेक्ट को निकालता है और इसके लिए संदर्भ गणना को घटाता है। हटाने योग्य () विधि एक पैरामीटर को ब्याज के तत्व के लिए एक संकेतक के रूप में लेती है, और हटाए जाने योग्य () विधि में दो पैरामीटर होते हैं: प्रारंभिक सूचकांक और तत्वों की संख्या को ऑग से हटा दिया जाना :: जिओड ऑब्जेक्ट सरणी।
  
• GetDrawable () विधि एक पैरामीटर के रूप में पारित सूचकांक पर एक तत्व के लिए एक संकेतक लौटाती है।
  
• GetNumDrawables () विधि osg :: Geode से जुड़े तत्वों की कुल संख्या लौटाती है। उदाहरण के लिए, ओस्ग :: जियोड से सभी तत्वों को हटाने के लिए, आप ऐसे कोड का उपयोग कर सकते हैं
  

geode->removeDrawables(0, geode->getNumDrawables()); 

2. सरल आकृतियाँ बनाना

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

 shapeDrawable->setShape(new osg::Box(osg::Vec3(1.0f, 0.0f, 0.0f), 10.0f, 10.0f, 5.0f)); 

एक ज्यामितीय केंद्र के साथ बिंदु (1.0, 0.0, 0.0) की चौड़ाई और 10 की ऊंचाई और 5 इकाइयों की गहराई के साथ एक आयताकार बॉक्स बनाता है। Osg :: Vec3 वर्ग त्रि-आयामी अंतरिक्ष में एक वेक्टर को परिभाषित करता है (इसके अलावा, osg :: Vec2 और osg :: Vec4 इसी आयाम के वैक्टर का वर्णन करने वाले वर्ग भी प्रस्तुत किए गए हैं)।

OSG :: Box, osg :: Capsule, osg :: Cone, osg :: Cylinder and osg :: क्षेत्र।

इस तंत्र के अनुप्रयोग के एक उदाहरण पर विचार करें।

main.h

 #ifndef MAIN_H #define MAIN_H #include <osg/ShapeDrawable> #include <osg/Geode> #include <osgViewer/Viewer> #endif // MAIN_H 

main.cpp

 #include "main.h" int main(int argc, char *argv[]) { (void) argc; (void) argv; osg::ref_ptr<osg::ShapeDrawable> shape1 = new osg::ShapeDrawable; shape1->setShape(new osg::Box(osg::Vec3(-3.0f, 0.0f, 0.0f), 2.0f, 2.0f, 1.0f)); osg::ref_ptr<osg::ShapeDrawable> shape2 = new osg::ShapeDrawable; shape2->setShape(new osg::Cone(osg::Vec3(0.0f, 0.0f, 0.0f), 1.0f, 1.0f)); shape2->setColor(osg::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); osg::ref_ptr<osg::ShapeDrawable> shape3 = new osg::ShapeDrawable; shape3->setShape(new osg::Sphere(osg::Vec3(3.0f, 0.0f, 0.0f), 1.0f)); shape3->setColor(osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); osg::ref_ptr<osg::Geode> root = new osg::Geode; root->addDrawable(shape1.get()); root->addDrawable(shape2.get()); root->addDrawable(shape3.get()); osgViewer::Viewer viewer; viewer.setSceneData(root.get()); return viewer.run(); } 

इस उदाहरण को विशेष रूप से टिप्पणियों की आवश्यकता नहीं है: कार्यक्रम में तीन सरल आकार बनाए जाते हैं, संकलन और लॉन्च के बाद हम इस तरह के परिणाम देखेंगे



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

3. ज्योमेट्री डेटा का संग्रहण: ऑर्ग्स :: एरे और ऑसग :: ज्योमेट्री

Osg :: सरणी वर्ग एक मूल सार वर्ग है, जिसमें से कई वंशजों को विरासत में मिला है, जो OpenGL कार्यों के लिए पारित डेटा को संग्रहीत करने के लिए डिज़ाइन किया गया है। इस वर्ग के साथ काम करना सीडी मानक पुस्तकालय से std :: वेक्टर के साथ काम करने के समान है। निम्नलिखित कोड पुश_बैक () विधि का उपयोग करके एक सदिश को एक सदिश सरणी में जोड़ना दिखाता है

 vertices->push_back(osg::Vec3(1.0f, 0.0f, 0.0f)); 

OSG सरणियों को ढेर पर आवंटित किया जाता है और स्मार्ट पॉइंटर्स द्वारा प्रबंधित किया जाता है। हालांकि, यह सरणी तत्वों पर लागू नहीं होता है, जैसे कि ओएसजी :: वीईसी 3 या ओएसजी :: वीईसी 2, जो स्टैक पर भी बनाया जा सकता है।

ओएसजी :: ज्यामिति वर्ग ओपनप्ले कार्यों पर एक आवरण है जो शीर्ष सरणियों के साथ काम करता है। यह osg :: Drawable class से लिया गया है और इसे आसानी से osg :: Geode ऑब्जेक्ट सूची में जोड़ा जा सकता है। यह वर्ग इनपुट के रूप में ऊपर वर्णित सरणियों को लेता है और ओपनजीएल का उपयोग करके ज्यामिति उत्पन्न करने के लिए उनका उपयोग करता है।

4. कार्यक्षेत्र और उनकी विशेषताएँ

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

OpenSceneGraph में वर्टेक्स विशेषताएँ

गुण	डेटा प्रकार	Osg :: ज्यामिति विधि	समतुल्य OpenGL कॉल
स्थिति	3-वेक्टर	setVertexArray ()	glVertexPointer ()
साधारण	3-वेक्टर	setNormalArray ()	glNormalPointer ()
रंग	4-वेक्टर	setColorArray ()	glColorPointer ()
द्वितीयक रंग	4-वेक्टर	सेटसॉन्ड्रीकारेलअरे ()	glSecondaryColorPointerEXT ()
कोहरा निर्देशांक	नाव	setFogCoordArray ()	glFogCoordPointerEXT ()
बनावट समन्वय करती है	2- या 3-वेक्टर	सेटटेक्सोकार्डअरे ()	glTexCoordPointer ()
अन्य विशेषताएँ	उपयोगकर्ता परिभाषित	setVertexArribArray ()	glVertexAttribPointerARB ()

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

 geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX); 

इसका अर्थ है कि प्रत्येक शीर्ष और शीर्ष के प्रत्येक रंग एक-दूसरे से सहसंबंधित हैं। हालांकि, अगर आप ऐसे कोड को देखते हैं

 geom->setColorBinding(osg::Geometry::BIND_OVERALL); 

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

5. ज्यामिति आदिमों के समूह

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

• addPrimitiveSet () - एक ऑग्मेंट में सेटिमिटी के एक सेट में एक पॉइंटर को पास करता है :: ज्यामिति ऑब्जेक्ट।
  
• removePrimitiveSet () - आदिम का एक सेट निकालें। मापदंडों के रूप में, यह सेट के प्रारंभिक सूचकांक और हटाए जाने वाले सेट की संख्या लेता है।
  
• getPrimitiveSet () - एक पैरामीटर के रूप में पारित इंडेक्स पर प्राइमेट का एक सेट देता है।
  
• getNumPrimitiveSets () - इस ज्यामिति से जुड़े आदिम के सेट की कुल संख्या लौटाता है।
  

Osg :: PrimitiveSet वर्ग सार है और इसे तत्काल नहीं किया जा सकता है, लेकिन कई व्युत्पन्न वर्ग जो कि OpenGL के साथ संचालित होने वाली आदिमता के सेट को इनकैप्सुलेट करते हैं, जैसे कि osg :: DrawArrays और osg :: DrawElementsUInt, इससे विरासत में मिलते हैं।

Osg :: DrawArrays वर्ग एक ज्यामितीय आदिम निर्माण के लिए एक वर्टेक्स सरणी के कई लगातार तत्वों का उपयोग करता है। इसे एक विधि कहकर ज्यामिति से निर्मित और संलग्न किया जा सकता है।

 geom->addPrimitiveSet(new osg::DrawArrays(mode, first, count)); 

पहला पैरामीटर मोड आदिम प्रकार को संबंधित OpenGL के आदिम प्रकारों पर सेट करता है: GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS और GLAADADS।

पहले और दूसरे पैरामीटर में वर्टेक्स ऐरे में पहला इंडेक्स और उन वर्टिकल की संख्या को निर्दिष्ट किया जाता है जिनसे ज्यामिति उत्पन्न की जानी चाहिए। इसके अलावा, ओएसजी यह जांच नहीं करता है कि मोड द्वारा निर्दिष्ट ज्यामिति का निर्माण करने के लिए निर्दिष्ट संख्याओं की संख्या पर्याप्त है, जिससे एप्लिकेशन क्रैश हो सकता है!

6. उदाहरण - एक चित्रित वर्ग खींचना

हम उपरोक्त सभी को एक सरल उदाहरण के रूप में लागू करते हैं


संकलन और निष्पादन के बाद, हमें इसके समान परिणाम मिलता है



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

 osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array; vertices->push_back(osg::Vec3(0.0f, 0.0f, 0.0f)); vertices->push_back(osg::Vec3(1.0f, 0.0f, 0.0f)); vertices->push_back(osg::Vec3(1.0f, 0.0f, 1.0f)); vertices->push_back(osg::Vec3(0.0f, 0.0f, 1.0f)); 

अगला हम मानदंड की सरणी सेट करते हैं। हमारे सरल मामले में, हमें प्रत्येक शीर्ष के लिए एक सामान्य बनाने की आवश्यकता नहीं है - बस वर्ग के विमान के लंबवत निर्देशित एक इकाई वेक्टर का वर्णन करें

 osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array; normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); 

प्रत्येक शीर्ष के लिए एक रंग निर्धारित करें

 osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array; colors->push_back(osg::Vec4(1.0f, 0.0f, 0.0f, 1.0f)); colors->push_back(osg::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); colors->push_back(osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); colors->push_back(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f)); 

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

 osg::ref_ptr<osg::Geometry> quad = new osg::Geometry; quad->setVertexArray(vertices.get()); 

मानदंडों की एक सरणी को पास करते हुए, हम इंजन को सूचित करते हैं कि सभी एकल के लिए एक सामान्य उपयोग किया जाएगा, मानदंडों के बाइंडिंग विधि ("बाइंडिंग") को इंगित करके BIND_OVAERALL

 quad->setNormalArray(normals.get()); quad->setNormalBinding(osg::Geometry::BIND_OVERALL); 

शीर्षों के रंगों को पास करते हुए, इसके विपरीत, हम इंगित करते हैं कि प्रत्येक शीर्ष का अपना रंग होगा

 quad->setColorArray(colors.get()); quad->setColorBinding(osg::Geometry::BIND_PER_VERTEX); 

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

 quad->addPrimitiveSet(new osg::DrawArrays(GL_QUADS, 0, 4)); 

खैर, मुझे लगता है कि यह ज्यामिति के हस्तांतरण और रेंडर के लॉन्च के बारे में बताने लायक नहीं है

 osg::ref_ptr<osg::Geode> root = new osg::Geode; root->addDrawable(quad.get()); osgViewer::Viewer viewer; viewer.setSceneData(root.get()); return viewer.run(); 

उपरोक्त कोड शुद्ध OpenGL में निम्नलिखित डिज़ाइन के बराबर है

 static const GLfloat vertices[][3] = { … }; glEnableClientState( GL_VERTEX_ARRAY ); glVertexPointer( 4, GL_FLOAT, 0, vertices ); glDrawArrays( GL_QUADS, 0, 4 ); 

7. आदिम में अनुक्रमणिका अनुक्रमण

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



क्यूब के आठ कोने हैं। हालांकि, जैसा कि आंकड़े से देखा जा सकता है (हम विमान पर क्यूब के सामने की ओर देखते हैं) कुछ कोने एक से अधिक चेहरे के हैं। यदि आप 12 त्रिकोणीय चेहरों का एक घन बनाते हैं, तो ये कोने दोहराए जाएंगे, और 8 कोने की एक सरणी के बजाय, हमें 36 कोने की एक सरणी मिलती है, जिनमें से अधिकांश वास्तव में एक ही शीर्ष हैं!

OSG कक्षाएं osg :: DrawElementsUInt, osg :: DrawElementsUByte और osg :: DrawElementsUShort, जो डेटा के रूप में वर्टेक्स इंडेक्स सरणियों का उपयोग करते हैं, वर्णित समस्या को हल करने के लिए डिज़ाइन किए गए हैं। अनुक्रमित अनुक्रमणिकाएँ अनुक्रमणिकाएँ अनुदैर्ध्य के वर्टिकल का अनुक्रमण करती हैं जो चेहरे और ज्यामिति के अन्य तत्वों का वर्णन करते हैं। क्यूब के लिए इन कक्षाओं को लागू करते समय, यह आठ खांचों की एक सरणी को संग्रहीत करने के लिए पर्याप्त है जो सूचकांकों के सरणियों के माध्यम से चेहरे से जुड़े होते हैं।

प्रकार ऑग की कक्षाएं :: ड्रॉइलिश * का निर्माण उसी तरह से किया जाता है जैसे मानक वर्ग एसटीडी :: वेक्टर। इस तरह के कोड का इस्तेमाल सूचकांकों को जोड़ने के लिए किया जा सकता है।

 osg::ref_ptr<osg::DrawElementsUInt> de = new osg::DrawElementsUInt(GL_TRIANGLES); de->push_back(0); de->push_back(1); de->push_back(2); de->push_back(3); de->push_back(0); de->push_back(2); 

यह कोड आकृति में दिखाए गए क्यूब के सामने के भाग को परिभाषित करता है।

आइए एक और उदाहरणात्मक उदाहरण पर विचार करें - एक ऑक्टाहेड्रॉन



यह दिलचस्प है क्योंकि इसमें केवल छह कोने हैं, लेकिन प्रत्येक शीर्ष चार त्रिकोणीय चेहरों के रूप में प्रवेश करता है! हम osg :: DrawArrays का उपयोग करके सभी आठ चेहरों को प्रदर्शित करने के लिए 24 कोने की एक सरणी बना सकते हैं। हालांकि, हम अन्यथा करेंगे - हम छह तत्वों की एक सरणी में कोने को संग्रहीत करेंगे, और हम ऑग का उपयोग करके चेहरे उत्पन्न करते हैं :: DrawElementsUInt वर्ग।


आइए इस कोड का अधिक विस्तार से विश्लेषण करें। बेशक, हम जो पहली चीज़ करते हैं, वह छह सिरों की एक सरणी बनाता है

 osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array(6); (*vertices)[0].set( 0.0f, 0.0f, 1.0f); (*vertices)[1].set(-0.5f, -0.5f, 0.0f); (*vertices)[2].set( 0.5f, -0.5f, 0.0f); (*vertices)[3].set( 0.5f, 0.5f, 0.0f); (*vertices)[4].set(-0.5f, 0.5f, 0.0f); (*vertices)[5].set( 0.0f, 0.0f, -1.0f); 

हम पॉइंटर और ऑपरेटर [] ऑपरेटर (हम याद करते हैं कि osg :: Array अपने डिवाइस में std :: वेक्टर के समान है) के dereferencing ऑपरेशन का उपयोग करके सीधे अपने निर्देशांक के वेक्टर तक पहुँचने के द्वारा प्रत्येक शीर्ष को आरंभ करते हैं।

अब वर्टेक्स इंडेक्स की सूची के रूप में चेहरे बनाएं

 osg::ref_ptr<osg::DrawElementsUInt> indices = new osg::DrawElementsUInt(GL_TRIANGLES, 24); (*indices)[ 0] = 0; (*indices)[ 1] = 1; (*indices)[ 2] = 2; //  0 (*indices)[ 3] = 0; (*indices)[ 4] = 4; (*indices)[ 5] = 1; //  1 (*indices)[ 6] = 4; (*indices)[ 7] = 5; (*indices)[ 8] = 1; //  2 (*indices)[ 9] = 4; (*indices)[10] = 3; (*indices)[11] = 5; //  3 (*indices)[12] = 3; (*indices)[13] = 2; (*indices)[14] = 5; //  4 (*indices)[15] = 1; (*indices)[16] = 5; (*indices)[17] = 2; //  5 (*indices)[18] = 3; (*indices)[19] = 0; (*indices)[20] = 2; //  6 (*indices)[21] = 0; (*indices)[22] = 3; (*indices)[23] = 4; //  7 

चेहरे त्रिकोणीय होंगे, 8 होंगे, जिसका अर्थ है कि सूचकांकों की सूची में 24 तत्व शामिल होने चाहिए। इस सरणी में चेहरे के सूचकांक क्रमिक रूप से चलते हैं: उदाहरण के लिए, चेहरे 0 का गठन वर्टिकल 0, 1, और 2 से होता है; चेहरा 1 - कोने 0, 4 और 1; चेहरा 2 - कोने 4, 5 और 1 और इतने पर। यदि आप चेहरे के मुख को देखते हैं (तो ऊपर दी गई आकृति देखें) वर्टिकल को वामावर्त क्रम में सूचीबद्ध किया गया है।

पिछले उदाहरणों में हमने जो ज्यामिति बनाई है, उसे बनाने के लिए और कदम। केवल एक चीज जो हमने नहीं की वह थी स्मूथ (एवरेजेड) नॉर्म्स की ऑटोमैटिक जनरेशन, जिसे हम कॉल करके इस उदाहरण में करते हैं

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

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

octahedron.pro

 CONFIG(debug, debug|release) { TARGET = $$join(TARGET,,,_d) . . . LIBS += -L$$OSG_LIB_DIRECTORY -losgUtild } else { . . . LIBS += -L$$OSG_LIB_DIRECTORY -losgUtil } 

परिणामस्वरूप, हमें निम्नलिखित परिणाम मिलते हैं



यह समझने के लिए कि यह कैसे काम करता है, ओपनजीएल पाइपलाइन पर विचार करें



वर्टेक्स ऐरे मैकेनिज़्म ओपनजीएल कॉल की संख्या को कम करता है। यह एप्लिकेशन मेमोरी में वर्टेक्स डेटा संग्रहीत करता है, जिसका उपयोग क्लाइंट साइड पर किया जाता है। सर्वर साइड पर OpenGL पाइपलाइन को विभिन्न शीर्ष सरणियों तक पहुंच मिलती है। जैसा कि आरेख में दिखाया गया है, ओएनजीसीएल क्लाइंट साइड पर वर्टेक्स बफर से डेटा प्राप्त करता है और, एक क्रमबद्ध तरीके से, प्राइमेटरीज की असेंबली करता है। यह कैसे डेटा सेट * Array () के तरीकों का उपयोग कर संसाधित किया जाता है osg :: ज्यामिति वर्ग। Osg :: DrawArrays वर्ग इन सरणियों के माध्यम से सीधे जाता है और उन्हें प्रदर्शित करता है।

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

8. बहुभुज जाल प्रसंस्करण तकनीक

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

वर्णित तकनीकों में शामिल हैं:

1. ऑसगुतिल :: सरलीकृत - ज्यामिति में त्रिकोणों की संख्या को कम करना। मॉडल ज्यामिति को सरल बनाने के लिए सरल () सार्वजनिक विधि का उपयोग किया जाता है।
   
2. osgUtil :: SmootingVisitor - मानदंडों की गणना। चिकनी () विधि का उपयोग मॉडल के लिए चिकनी मानदंडों को उत्पन्न करने के लिए किया जा सकता है, बजाय उन्हें स्वतंत्र रूप से गणना करने और मानदंडों के एक सरणी के माध्यम से स्पष्ट रूप से स्थापित करने के लिए।
   
3. osgUtil :: TangentSpaceGenerator - मॉडल कोने के लिए स्पर्शरेखा आधार वैक्टर की पीढ़ी। यह जनरेट () विधि को कॉल करके लॉन्च किया गया है और getTangentArray (), getNormalArray (), और getBinormalArray () विधियों द्वारा लौटाए गए परिणाम को सहेजता है। GLSL में शेड्स लिखते समय इन परिणामों का उपयोग विभिन्न शीर्ष विशेषताओं के लिए किया जा सकता है।
   
4. osgUtil :: Tesselator - एक बहुभुज जाल के tessellation करता है - सरल (retesselatePolygons () विधि) के अनुक्रम में जटिल प्राइमेटिस को विभाजित करता है
   
5. osgUtil :: TriStripVisitor - एक ज्यामितीय सतह को त्रिकोणीय चेहरों के स्ट्रिप्स के एक सेट में परिवर्तित करता है, जो कुशल मेमोरी खपत के साथ प्रतिपादन की अनुमति देता है। स्ट्रिपिफाई () विधि GL_TRIANGLE_STRIP सेट के आधार पर मॉडल प्राइमेटरीज के एक सेट को ज्यामिति में परिवर्तित करता है।
   

सभी विधियाँ वस्तु के ज्यामिति को एक पैरामीटर के रूप में स्वीकार कर लेती हैं, जैसे ऑग्मेंट द्वारा पारित: ज्यामिति और लिंक, उदाहरण के लिए

 osgUtil::TriStripVisitor tsv; tsv.stripify(*geom); 

जहां जियोम एक स्मार्ट पॉइंटर द्वारा वर्णित ज्यामिति की एक आवृत्ति को संदर्भित करता है।

कक्षाएं osg :: सरलीकृत, osg :: SmoothingVisitor और osg :: TriStripVisitor सीधे दृश्य ग्राफ में नोड्स के साथ काम कर सकते हैं, उदाहरण के लिए

 osgUtil::TriStripVisitor tsv; node->accept(tsv); 

स्वीकार () विधि सभी बच्चे के नोड्स को संसाधित करती है जब तक कि निर्दिष्ट ऑपरेशन ऑसग के नोड्स में संग्रहीत दृश्य पेड़ के इस हिस्से के सभी टर्मिनल नोड्स पर लागू नहीं होता है: Geode प्रकार।

आइए व्यवहार में टेसेलेशन तकनीक का प्रयास करें।


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



इस समस्या को ठीक करने के लिए, निर्मित ज्यामिति को दर्शक के पास जाने से पहले उसे बंद कर दिया जाना चाहिए

 osgUtil::Tessellator ts; ts.retessellatePolygons(*geom); 

जिसके बाद हमें सही परिणाम मिलता है



यह कैसे काम करता है? एक गैर-उत्तल बहुभुज, सही टेसेलेशन के उपयोग के बिना प्रदर्शित नहीं किया जाएगा, जैसा कि हम उम्मीद करते हैं, चूंकि ओपनजीएल, प्रदर्शन का अनुकूलन करने की मांग कर रहा है, इसे एक सरल, उत्तल बहुभुज के रूप में माना जाएगा या बस इसे अनदेखा कर देगा, जो पूरी तरह से अप्रत्याशित परिणाम दे सकता है।

OsgUtil :: Tessellator वर्ग एक उत्तल बहुभुज को गैर-उत्तल की श्रृंखला में बदलने के लिए एल्गोरिदम का उपयोग करता है - हमारे मामले में, यह ज्यामिति को GL_TRIANGLE_STRIP में बदल देता है।



यह वर्ग छेद बहुभुज और स्व-प्रतिच्छेदन बहुभुज को संभाल सकता है। सार्वजनिक setWindsType () विधि का उपयोग करके, आप विभिन्न प्रसंस्करण नियमों को परिभाषित कर सकते हैं, जैसे GLU_TESS_WINDING_ODD या GLU_TESS_WINDING_NONZERO, जो एक जटिल एंटोनियो के आंतरिक और बाहरी क्षेत्रों को निर्दिष्ट करते हैं।

निष्कर्ष

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

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