परिचय

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

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

1. रेखापुंज छवि डेटा की प्रस्तुति। Osg वर्ग :: छवि

डिस्क से एक छवि को लोड करने का सबसे अच्छा तरीका है osgDB :: readImageFile () कॉल का उपयोग करना। यह osg :: readNodeFile () कॉल के समान है जो पहले से ही हमें ऊब चुका है। अगर हमारे पास picture.bmp नाम का बिटमैप है, तो इसे लोड करना इस तरह दिखेगा

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

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

1. टी (), एस () और आर () - छवि की चौड़ाई, ऊंचाई और गहराई लौटाएं।
   
2. data () - "अहस्ताक्षरित" छवि डेटा के लिए अहस्ताक्षरित char * का पॉइंटर देता है। इस सूचक के माध्यम से, डेवलपर छवि डेटा पर सीधे कार्य कर सकता है। आप getPixalFormat () और getDataType () विधियों का उपयोग करके छवि डेटा प्रारूप का विचार प्राप्त कर सकते हैं। उनके द्वारा लौटाए गए मान, OpenGL फ़ंक्शन glTexImage * () के प्रारूप और प्रकार के मापदंडों के बराबर हैं। उदाहरण के लिए, यदि चित्र में GL_RGB पिक्सेल प्रारूप है और प्रकार GL_UNSIGNED_BYTE है, तो RGB रंग घटक का प्रतिनिधित्व करने के लिए तीन स्वतंत्र तत्वों (अहस्ताक्षरित बाइट्स) का उपयोग किया जाता है
   

आप एक नई छवि ऑब्जेक्ट बना सकते हैं और इसके लिए मेमोरी आवंटित कर सकते हैं।

 osg::ref_ptr<osg::Image> image = new osg::Image; image->allocateImage(s, t, r, GL_RGB, GL_UNSIGNED_BYTE); unsigned char *ptr = image->data(); //         

यहाँ s, t, r छवि आकार हैं; GL_RGB पिक्सेल प्रारूप सेट करता है, और GL_UNSIGNED_BYTE एकल रंग घटक का वर्णन करने के लिए डेटा प्रकार सेट करता है। आवश्यक आकार का एक आंतरिक डेटा बफर स्मृति में आवंटित किया गया है और स्वचालित रूप से नष्ट हो जाता है अगर इस छवि का एक भी लिंक नहीं है।

OSG प्लग-इन सिस्टम लगभग सभी लोकप्रिय छवि प्रारूपों को डाउनलोड करने का समर्थन करता है: * .jpg, * .bmp, * * .ng, * .tif और इतने पर। यह सूची अपने स्वयं के प्लगइन को लिखकर विस्तार करना आसान है, लेकिन यह एक और चर्चा का विषय है।

2. बनावट की मूल बातें

तीन-आयामी मॉडल में बनावट लागू करने के लिए, आपको कई चरणों को करने की आवश्यकता है:

1. ज्यामितीय वस्तु (3 डी डिजाइनरों के वातावरण में, यह एक यूवी स्कैन कहा जाता है) के लिए कोने के बनावट निर्देशांक को परिभाषित करें।
   
2. 1 डी, 2 डी, 3 डी, या क्यूबिक बनावट के लिए एक बनावट विशेषता ऑब्जेक्ट बनाएं।
   
3. बनावट विशेषता के लिए एक या अधिक छवियां सेट करें।
   
4. तैयार की जा रही वस्तु पर लागू राज्यों के सेट के लिए एक बनावट विशेषता और मोड संलग्न करें।
   

ओएसजी ऑस्ग :: टेक्सचर क्लास को परिभाषित करता है, जो सभी तरह के टेक्सचर को इनकैप्स करता है। Subclasses osg :: Texture1D, osg :: Texture2D, osg :: Texture3D और osg :: TextureCubeMap को इससे विरासत में मिला है, जो ओपनजीएल में अपनाई गई विभिन्न बनावट तकनीकों का प्रतिनिधित्व करते हैं।

सबसे आम ओस्ग :: टेक्सचर क्लास विधि सेटिमेज () है, जो बनावट में उपयोग की जाने वाली छवि को सेट करती है, उदाहरण के लिए

 osg::ref_ptr<osg::Image> image = osgDB::readImageFile("picture.bmp"); osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D; texture->setImage(image.get()); 

या, आप टेक्सचर क्लास के कंस्ट्रक्टर को इमेज ऑब्जेक्ट को सीधे पास कर सकते हैं

 osg::ref_ptr<osg::Image> image = osgDB::readImageFile("picture.bmp"); osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D(image.get()); 

GetImage () विधि को कॉल करके छवि को बनावट ऑब्जेक्ट से पुनर्प्राप्त किया जा सकता है।

एक अन्य महत्वपूर्ण बिंदु ऑस्ग :: ज्योमेट्री ऑब्जेक्ट में प्रत्येक शीर्ष के लिए बनावट निर्देशांक सेट कर रहा है। इन निर्देशांकों का स्थानांतरण ऑस :: Vec2Array और osg :: Vec3Array ऐरे के माध्यम से setTexCoordArray () विधि से होता है।

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

 osf::ref_ptr<osg::Vec2Array> texcoord = new osg::Vec2Array; texcoord->push_back( osg::Vec2(...) ); ... geom->setTexCoordArray(0, texcoord.get()); 

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

 geom->getOrCreateStateSet()->setTextureAttributeAndModes(texture.get()); 

कृपया ध्यान दें कि OpenGL वीडियो कार्ड की ग्राफिक्स मेमोरी में छवि डेटा का प्रबंधन करता है, लेकिन सिस्टम डेटा में स्थित समान डेटा के साथ osg :: Image ऑब्जेक्ट। नतीजतन, हम इस तथ्य का सामना करेंगे कि हमने एक ही डेटा की दो प्रतियां संग्रहीत की हैं, जो प्रक्रिया मेमोरी पर कब्जा कर रही है। यदि यह चित्र कई बनावट विशेषताओं द्वारा साझा नहीं किया गया है, तो इसे OpenGL द्वारा वीडियो एडॉप्टर मेमोरी में स्थानांतरित करने के तुरंत बाद इसे सिस्टम मेमोरी से हटाया जा सकता है। ओएसजी :: बनावट वर्ग इस फ़ंक्शन को सक्षम करने के लिए उपयुक्त विधि प्रदान करता है।

 texture->setUnRefImageDataAfterApply( true ); 

3. एक 2 डी बनावट को लोड करें और लागू करें

सबसे अधिक इस्तेमाल की जाने वाली तकनीक 2 डी टेक्सचरिंग है - एक त्रि-आयामी सतह के किनारे पर एक दो-आयामी छवि (या छवियां) ओवरलेइंग। चतुष्कोणीय बहुभुज में एकल बनावट लागू करने के सबसे सरल उदाहरण पर विचार करें


चेहरे को कोने और मानदंड की एक सरणी बनाएँ

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

बनावट निर्देशांक की एक सरणी बनाएँ

 osg::ref_ptr<osg::Vec2Array> texcoords = new osg::Vec2Array; texcoords->push_back( osg::Vec2(0.0f, 0.0f) ); texcoords->push_back( osg::Vec2(0.0f, 1.0f) ); texcoords->push_back( osg::Vec2(1.0f, 1.0f) ); texcoords->push_back( osg::Vec2(1.0f, 0.0f) ); 

मुद्दा यह है कि त्रि-आयामी मॉडल के प्रत्येक शीर्ष को दो-आयामी बनावट पर एक बिंदु से मेल खाती है, और बनावट पर बिंदुओं के निर्देशांक सापेक्ष हैं - वे छवि की वास्तविक चौड़ाई और ऊंचाई के लिए सामान्यीकृत हैं। हम पूरी छवि को वर्ग पर लोड करना चाहते हैं, क्रमशः, वर्ग के कोने बनावट बिंदुओं (0, 0), (0, 1), (1, 1) और (1, 0) के अनुरूप होंगे। शीर्ष सरणी में कोने का क्रम बनावट के कोने के क्रम से मेल खाना चाहिए।

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

 osg::ref_ptr<osg::Geometry> quad = new osg::Geometry; quad->setVertexArray(vertices.get()); quad->setNormalArray(normals.get()); quad->setNormalBinding(osg::Geometry::BIND_OVERALL); quad->setTexCoordArray(0, texcoords.get()); quad->addPrimitiveSet( new osg::DrawArrays(GL_QUADS, 0, 4) ); 

एक बनावट वस्तु बनाएं और इसके लिए उपयोग की जाने वाली छवि को लोड करें।

 osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D; osg::ref_ptr<osg::Image> image = osgDB::readImageFile("../data/Images/lz.rgb"); texture->setImage(image.get()); 

दृश्य का रूट नोड बनाएं और हम वहां बनाई गई ज्यामिति डालें

 osg::ref_ptr<osg::Geode> root = new osg::Geode; root->addDrawable(quad.get()); 

और अंत में टेक्सचर विशेषता को उस नोड पर लागू करें जिसमें ज्यामिति रखी गई है

 root->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get()); 

Osg :: Texture2D वर्ग यह निर्धारित करता है कि क्या बनावट की छवि का आकार दो की शक्ति के गुणक हैं (उदाहरण के लिए, 64x64 या 256x512), स्वचालित रूप से उन छवियों को स्केल करना जो आकार के लिए अनुपयुक्त हैं, वास्तव में OpenGL gluScitImage () फ़ंक्शन का उपयोग कर रहे हैं। वहाँ एक setResizeNonPowerOfTwoHint () विधि है जो यह निर्धारित करती है कि छवि का आकार बदल सकता है या नहीं। कुछ वीडियो कार्डों को दो की शक्ति की एक छवि के आकार के एक से अधिक की आवश्यकता होती है, जबकि osg :: Texture2D वर्ग एक मनमाना बनावट आकार के साथ काम करने का समर्थन करता है।

बनावट सम्मिश्रण के बारे में कुछ

जैसा कि हमने पहले ही कहा है, बनावट के निर्देशांक 0 से 1. बिंदु (0, 0) से सामान्य होते हैं, छवि के ऊपरी बाएं कोने से मेल खाते हैं, और बिंदु (1, 1) निचले दाएं से मेल खाती है। यदि आप एक से अधिक बनावट निर्देशांक सेट करते हैं तो क्या होता है?

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

इस व्यवहार को osg :: Texture class के setWrap () विधि के माध्यम से नियंत्रित किया जा सकता है। पहले पैरामीटर के रूप में, विधि अक्ष के पहचानकर्ता को ले जाती है जिसमें मिश्रण मोड लागू किया जाना चाहिए, दूसरे पैरामीटर के रूप में पारित किया जाता है, उदाहरण के लिए

 //     s texture->setWrap( osg::Texture::WRAP_S, osg::Texture::REPEAT ); //     r texture->setWrap( osg::Texture::WRAP_R, osg::Texture::REPEAT ); 

यह कोड स्पष्ट रूप से एस और आर कुल्हाड़ियों के साथ बनावट को दोहराने के लिए इंजन को बताता है कि क्या बनावट का मान अधिक से अधिक है। बनावट मानचित्रण मोड की पूरी सूची:

1. REPEAT - बनावट दोहराएं।
   
2. MIRROR - इसे दोहराते हुए, बनावट को दोहराएं।
   
3. CLAMP_TO_EDGE - निर्देशांक जो 0 से 1 के पार जाते हैं, बनावट के संगत किनारे पर तड़क जाते हैं।
   
4. CLAMP_TO_BORDER - निर्देशांक जो 0 से 1 तक जाते हैं, उपयोगकर्ता द्वारा निर्धारित सीमा रंग देगा।
   

4. बनावट के लिए प्रतिपादन

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

एक बनावट को गतिशील रूप से बेक करने के लिए, आपको तीन चरण पूरे करने होंगे:

1. इसमें रेंडर करने के लिए एक टेक्सचर ऑब्जेक्ट बनाएं।
   
2. एक बनावट में दृश्य रेंडर करें।
   
3. इच्छित बनावट का उपयोग करें।
   

हमें एक खाली बनावट वस्तु बनानी चाहिए। ओएसजी आपको किसी दिए गए आकार की एक खाली बनावट बनाने की अनुमति देता है। SetTextureSize () विधि आपको बनावट की चौड़ाई और ऊंचाई, साथ ही साथ एक अतिरिक्त पैरामीटर (3 डी बनावट के लिए) की गहराई सेट करने की अनुमति देती है।

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

 camera->attach( osg::Camera::COLOR_BUFFER, texture.get() ); 

रेंडरिंग के लिए उपलब्ध फ्रेम बफर के अन्य भागों में DEPTH_BUFFER डेप्थ बफर, STENCIL_BUFFER स्टैंसिल बफर और COLOR_BUFFER0 से COLOR_BUFFER15 तक अतिरिक्त कलर बफ़र्स शामिल हैं। अतिरिक्त रंगीन बफ़र्स की उपस्थिति और उनकी संख्या वीडियो कार्ड के मॉडल द्वारा निर्धारित की जाती है।

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

5. बनावट को प्रस्तुत करने के कार्यान्वयन का एक उदाहरण

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


एक वर्ग बनाने के लिए, एक अलग मुफ्त फ़ंक्शन लिखें

 osg::Geometry *createQuad(const osg::Vec3 &pos, float w, float h) { osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array; vertices->push_back( pos + osg::Vec3( w / 2, 0.0f, -h / 2) ); vertices->push_back( pos + osg::Vec3( w / 2, 0.0f, h / 2) ); vertices->push_back( pos + osg::Vec3(-w / 2, 0.0f, h / 2) ); vertices->push_back( pos + osg::Vec3(-w / 2, 0.0f, -h / 2) ); osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array; normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f)); osg::ref_ptr<osg::Vec2Array> texcoords = new osg::Vec2Array; texcoords->push_back( osg::Vec2(1.0f, 1.0f) ); texcoords->push_back( osg::Vec2(1.0f, 0.0f) ); texcoords->push_back( osg::Vec2(0.0f, 0.0f) ); texcoords->push_back( osg::Vec2(0.0f, 1.0f) ); osg::ref_ptr<osg::Geometry> quad = new osg::Geometry; quad->setVertexArray(vertices.get()); quad->setNormalArray(normals.get()); quad->setNormalBinding(osg::Geometry::BIND_OVERALL); quad->setTexCoordArray(0, texcoords.get()); quad->addPrimitiveSet(new osg::DrawArrays(GL_QUADS, 0, 4)); return quad.release(); } 

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

मुख्य कार्यक्रम के शरीर में, सेसना के मॉडल को लोड करें

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

इस मॉडल को चेतन करने के लिए, Z अक्ष के चारों ओर रोटेशन परिवर्तन को बनाएँ और आरंभ करें

 osg::ref_ptr<osg::MatrixTransform> transform1 = new osg::MatrixTransform; transform1->setMatrix(osg::Matrix::rotate(0.0, osg::Vec3(0.0f, 0.0f, 1.0f))); transform1->addChild(sub_model.get()); 

अब मुख्य दृश्य के लिए एक मॉडल बनाएं - एक वर्ग जिस पर हम प्रस्तुत करेंगे

 osg::ref_ptr<osg::Geode> model = new osg::Geode; model->addChild(createQuad(osg::Vec3(0.0f, 0.0f, 0.0f), 2.0f, 2.0f)); 

आरजीबीए पिक्सेल प्रारूप के साथ 1024x1024 पिक्सेल वर्ग के लिए एक खाली बनावट बनाएं (अल्फा चैनल के साथ 32-बिट तीन-घटक रंग)

 int tex_widht = 1024; int tex_height = 1024; osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D; texture->setTextureSize(tex_widht, tex_height); texture->setInternalFormat(GL_RGBA); texture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR); texture->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::LINEAR); 

इस बनावट को चौकोर मॉडल पर लागू करें।

 model->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get()); 

फिर एक कैमरा बनाएं जो बनावट को सेंक देगा

 osg::ref_ptr<osg::Camera> camera = new osg::Camera; camera->setViewport(0, 0, tex_widht, tex_height); camera->setClearColor(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f)); camera->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

कैमरा व्यूपोर्ट बनावट के समान आकार का है। इसके अलावा, स्क्रीन और सफाई मास्क को साफ करते समय पृष्ठभूमि का रंग सेट करना न भूलें, रंग बफर और गहराई बफर दोनों को साफ करने का संकेत देते हैं। अगला, बनावट को प्रस्तुत करने के लिए कैमरे को कॉन्फ़िगर करें

 camera->setRenderOrder(osg::Camera::PRE_RENDER); camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); camera->attach(osg::Camera::COLOR_BUFFER, texture.get()); 

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

 camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF); camera->addChild(transform1.get()); 

मुख्य मॉडल (वर्ग) और इसमें एक कैमरा प्रसंस्करण बनावट जोड़कर एक रूट समूह नोड बनाएं

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

एक दर्शक बनाएं और अनुकूलित करें

 osgViewer::Viewer viewer; viewer.setSceneData(root.get()); viewer.setCameraManipulator(new osgGA::TrackballManipulator); viewer.setUpViewOnSingleScreen(0); 

कैमरे के लिए प्रक्षेपण मैट्रिक्स सेट करें - कतरन पिरामिड के मापदंडों के माध्यम से एक परिप्रेक्ष्य प्रक्षेपण

 camera->setProjectionMatrixAsPerspective(30.0, static_cast<double>(tex_widht) / static_cast<double>(tex_height), 0.1, 1000.0); 

हमने एक दृश्य मैट्रिक्स स्थापित किया है जो उप-सेसना की उत्पत्ति के संबंध में कैमरे की स्थिति को अंतरिक्ष में सेट करता है

 float dist = 100.0f; float alpha = 10.0f * 3.14f / 180.0f; osg::Vec3 eye(0.0f, -dist * cosf(alpha), dist * sinf(alpha)); osg::Vec3 center(0.0f, 0.0f, 0.0f); osg::Vec3 up(0.0f, 0.0f, -1.0f); camera->setViewMatrixAsLookAt(eye, center, up); 

अंत में, प्रत्येक फ्रेम में जेड अक्ष के आसपास विमान के रोटेशन के कोण को बदलते हुए, दृश्य को चेतन और प्रदर्शित करें

 float phi = 0.0f; float delta = -0.01f; while (!viewer.done()) { transform1->setMatrix(osg::Matrix::rotate(static_cast<double>(phi), osg::Vec3(0.0f, 0.0f, 1.0f))); viewer.frame(); phi += delta; } 

नतीजतन, हमें एक दिलचस्प तस्वीर मिलती है



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

6. रेंडरिंग रिजल्ट को फाइल में सेव करना

OSG कैमरे के लिए एक ऑग :: इमेज ऑब्जेक्ट को संलग्न करने की क्षमता का समर्थन करता है और फ्रेम बफर की सामग्री को इमेज डेटा बफर में सहेजता है। उसके बाद, यह डेटा को सहेजने के लिए संभव है osg :: writeImageFile () फ़ंक्शन का उपयोग करके डिस्क पर

 osg::ref_ptr<osg::Image> image = new osg::Image; image->allocateImage( width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE ); camera->attach( osg::Camera::COLOR_BUFFER, image.get() ); ... osgDB::writeImageFile( *image, "saved_image.bmp" ); 

निष्कर्ष

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

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