परिचय

एक ओर, OpenSceneGraph इंजन में स्वयं विंडोज़ के प्रबंधन, उपयोगकर्ता इनपुट घटनाओं को संसाधित करने, उपयोगकर्ता संदेश भेजने और प्राप्त करने के लिए एक उन्नत सबसिस्टम है। हमने इस श्रृंखला के पिछले लेखों में कुछ विस्तार से इस बारे में बात की थी। सामान्य तौर पर, C ++ / STL की क्षमताओं के साथ, यह मनमाने ढंग से जटिल अनुप्रयोगों को विकसित करने के लिए पर्याप्त है।

QtDesigner द्वारा विकसित एक एप्लीकेशन में OSG को एकीकृत करने का एक उदाहरण। इस उदाहरण पर नीचे विस्तार से चर्चा की जाएगी।


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

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

OSG और Qt को एकीकृत करने के लिए दो विकल्प हैं:

1. OSG एप्लिकेशन के भीतर ऑब्जेक्ट्स को इंटरैक्ट करने के लिए Qt सिग्नल और स्लॉट्स का उपयोग करना
   
2. OSG दर्शक का एकीकरण C ++ / Qt में विकसित एक चित्रमय इंटरफ़ेस में है, जिसमें QtDesigner फॉर्म डिज़ाइनर का उपयोग भी शामिल है।
   

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

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

1. QG सिग्नल एक OSG विंडो सिस्टम में

पहला उदाहरण कुछ हद तक सिंथेटिक होगा: हम एक आदिम दृश्य के साथ एक सरल ओएसजी एप्लिकेशन लिखते हैं; दो कक्षाएं बनाएं, जिनमें से एक कीस्ट्रोक्स को संभालेगी, और दूसरा कंसोल को संदेश प्रदर्शित करने के लिए कि किस कुंजी को दबाया गया है। इस मामले में, हैंडलर एक क्यूटी सिग्नल उत्पन्न करेगा, एक पैरामीटर के रूप में दबाए गए कुंजी के बारे में एक संदेश के साथ।

क्यूटी के साथ एकीकृत करने के लिए, यह निम्नलिखित तीन स्थितियों को पूरा करने के लिए पर्याप्त है

1. QObject से इनहेरिटिंग क्लासेस
   
2. सिग्नल प्रोसेसिंग लूप व्यवस्थित करें
   
3. अनुप्रयोग संचालन के दौरान स्मृति में मौजूद QApplication (या QCoreApplication) वर्ग का एक उदाहरण बनाएँ
   

पूर्ण उदाहरण कोड यहां मेरे OSG- पाठ भंडार में देखा जा सकता है , जिसमें इस चक्र के सभी पाठ हैं।

सबसे पहले, एक वर्ग बनाएं जो सिग्नल प्रोसेसिंग कतार को "ट्विस्ट" करेगा।

क्यूटी-events.h

#ifndef QT_EVENTS_H #define QT_EVENTS_H #include <osgGA/GUIEventHandler> #include <QCoreApplication> //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ class QtEventsHandler : public osgGA::GUIEventHandler { public: QtEventsHandler(); virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa); protected: }; #endif // QT_EVENTS_H 

क्यूटी-events.cpp

 #include "qt-events.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ QtEventsHandler::QtEventsHandler() { } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ bool QtEventsHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { Q_UNUSED(aa) switch (ea.getEventType()) { case osgGA::GUIEventAdapter::FRAME: { // Process qt signals and event QCoreApplication::processEvents(QEventLoop::AllEvents); break; } default: break; } return false; } 

सब कुछ बेहद सरल है - यह वर्ग एक मानक OSG ईवेंट हैंडलर है, जो एक फ्रेम को प्रस्तुत करते समय, कॉलिंग के साथ Qt सिग्नल क्यू प्रसंस्करण को आरंभ करता है

 QCoreApplication::processEvents(QEventLoop::AllEvents); 

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

keyhandler.h

 #ifndef KEY_HANDLER_H #define KEY_HANDLER_H #include <osgGA/GUIEventHandler> #include <QObject> //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ class KeyboardHandler : public QObject, public osgGA::GUIEventHandler { Q_OBJECT public: KeyboardHandler(QObject *parent = Q_NULLPTR) : QObject(parent) , osgGA::GUIEventHandler () { } bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa) { switch (ea.getEventType()) { case osgGA::GUIEventAdapter::KEYDOWN: emit sendMessage("Pressed key " + QString(ea.getKey())); break; default: break; } return false; } signals: void sendMessage(QString msg); private: }; #endif // KEY_HANDLER_H 

क्लास एक कुंजी दबाए जाने के बारे में एक संदेश संसाधित करेगा और एक संदेश को दबाए गए कुंजी के कोड के साथ एक संकेत भेजेगा। यह संकेत एक वर्ग द्वारा प्राप्त किया जाएगा जो कि OSG के साथ किसी भी तरह से जुड़ा नहीं है, जो QObject का वंशज है और इसमें एक एकल स्लॉट है जो मानक आउटपुट के लिए एक संदेश प्रिंट करता है

receiver.h

 #ifndef RECEIVER_H #define RECEIVER_H #include <QObject> #include <iostream> //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ class Receiver : public QObject { Q_OBJECT public: Receiver(QObject *parent = Q_NULLPTR) : QObject(parent) {} public slots: void printMessage(QString msg) { std::cout << msg.toStdString() << std::endl; } }; #endif // RECEIVER_H 

अब यह सब एक साथ एक OSG एप्लिकेशन लिखकर रखें

main.h

 #ifndef MAIN_H #define MAIN_H #include <osgViewer/Viewer> #include <osgDB/ReadFile> #include <QCoreApplication> #include "qt-events.h" #include "keyhandler.h" #include "receiver.h" #endif 

main.cpp

 #include "main.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); osg::ref_ptr<osg::Node> scene = osgDB::readNodeFile("../data/cessnafire.osg"); osgViewer::Viewer viewer; viewer.setSceneData(scene.get()); viewer.addEventHandler(new QtEventsHandler); viewer.setUpViewInWindow(0, 0, 1024, 768); KeyboardHandler *keyboardHandler = new KeyboardHandler; Receiver *receiver = new Receiver; QObject::connect(keyboardHandler, &KeyboardHandler::sendMessage, receiver, &Receiver::printMessage); viewer.addEventHandler(keyboardHandler); return viewer.run(); } 

सबसे पहले, हम QCoreApplication वर्ग का एक उदाहरण बनाते हैं।

 QCoreApplication app(argc, argv); 

यह वर्णित तकनीक के काम करने के लिए आवश्यक है। हालाँकि, हम QCoreApplication :: exec () विधि नहीं कहेंगे ! इसके बजाय, सिग्नल प्रोसेसिंग लूप हमारे osgViewer के अंदर स्पिन करेगा :: व्यूअर :: रन () लूप, जिसके लिए हम संबंधित हैंडलर बनाते हैं और उसे पंजीकृत करते हैं।

 viewer.addEventHandler(new QtEventsHandler); 

हम उन वर्गों के उदाहरण बनाते हैं जो क्यूटी संकेतों के माध्यम से बातचीत करेंगे, एक के संकेत को दूसरे के स्लॉट से जोड़ते हैं

 KeyboardHandler *keyboardHandler = new KeyboardHandler; Receiver *receiver = new Receiver; QObject::connect(keyboardHandler, &KeyboardHandler::sendMessage, receiver, &Receiver::printMessage); 

कीबोर्ड हैंडलर रजिस्टर करें

 viewer.addEventHandler(keyboardHandler); 

सभी दर्शक चलाते हैं

 return viewer.run(); 

और ऐसी तस्वीर देखें


हां, उदाहरण कुछ हद तक वंचित है, लेकिन यह QG तंत्रों का उपयोग करके कोड को एकीकृत करने के मुख्य सिद्धांतों को OSG का उपयोग करके दिखाता है। OpenSceneGraph 3. Cookbook से चमके इस विचार ने, मेरे और मेरी विकास टीम के लिए बहुत समय और नसों की बचत की, जिससे मुझे एक क्यूटी-आधारित मॉड्यूल का उपयोग करने की अनुमति मिली जो हमारे कोड बेस में हमारे कोड बेस के भीतर डीबग और मानकीकृत था।

लेकिन क्या होगा अगर हम अभी भी Qt GUI एप्लिकेशन के अंदर OSG का उपयोग करना चाहते हैं?

2. osgQt पुस्तकालय

osgQt एक एकीकरण पुस्तकालय है जिसके लिए डिज़ाइन किया गया है:

1. क्यूटी पर विकसित एक एप्लिकेशन के ग्राफिकल इंटरफ़ेस में ओएसजी पर लागू 3 डी दृश्य को एम्बेड करना
2. एक OSG दृश्य के अंदर एक 3 डी ज्यामिति सतह पर क्यूटी विगेट्स एम्बेड करना। जी हाँ, आपने सही सुना - क्यूटी विजेट्स आभासी दुनिया के अंदर चुपचाप काम कर सकते हैं। किसी दिन मैं निश्चित रूप से इसका प्रदर्शन करूंगा

इस लाइब्रेरी के साथ कुछ समस्याएं थीं, जिन्हें हमने इससे जुड़े उदाहरणों का सावधानीपूर्वक अध्ययन करने और पहले से उल्लेखित ओपनसेकेग्राफ को पढ़ने से दूर करने में कामयाब रहे । 3. कुकबुक

पुस्तकालय को इकट्ठा किया जाना चाहिए, और यह प्रक्रिया स्वयं इंजन की विधानसभा के समान है, जिसे चक्र के पहले लेख में विस्तार से वर्णित किया गया है । एकमात्र टिप्पणी यह ​​है कि -DCMAKE_INSTALL_PREFIX को उसी के साथ चुना जाना चाहिए जो इंजन का निर्माण करते समय निर्दिष्ट किया गया था - इसलिए इंजन के बगल में osgQt स्थापित किया जाएगा, और विकास के दौरान इसका उपयोग करना सुविधाजनक होगा।

3. ऑसगवॉयर का एकीकरण :: क्यूटी जीयूआई में दर्शक

निम्नलिखित उदाहरण काफी उपयोगी होगा। हम एक दर्शक लिखेंगे जो आपको मानक Qt नियंत्रणों का उपयोग करके * .osg प्रारूप मॉडल लोड करने की अनुमति देता है। इसके अलावा, एक ग्राफिकल इंटरफ़ेस विकसित करने के लिए, हम QtDeisgner का उपयोग करते हैं।

"Qt विजेट अनुप्रयोग" जैसी एक नई परियोजना बनाते हैं



इस मामले में, मुख्य एप्लिकेशन विंडो मेनू बार, टूलबार और स्टेटस बार के साथ उत्पन्न होगी। QtDesigner में, इस विंडो में QFrame घटक जोड़ें।



हम इस फ्रेम में OSG व्यूअर को जगह देंगे। OSG दर्शक अनिवार्य रूप से एक Qt विजेट होगा, इसके कार्यान्वयन के लिए हम QViewerWidget क्लास लिखेंगे। मैंने स्पॉइलर पर पूरे स्रोत डाल दिए हैं, ताकि कोड की शीट के साथ प्रस्तुति को धुंधला न करें



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

 osgQt::GraphicsWindowQt *QViewerWidget::createGraphicsWindow(const QRect &geometry) { osg::DisplaySettings *ds = osg::DisplaySettings::instance().get(); osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits; traits->windowName = ""; traits->windowDecoration = false; traits->x = geometry.x(); traits->y = geometry.y(); traits->width = geometry.width(); traits->height = geometry.height(); if (traits->height == 0) traits->height = 1; traits->doubleBuffer = true; traits->alpha = ds->getMinimumNumAlphaBits(); traits->stencil = ds->getMinimumNumStencilBits(); traits->sampleBuffers = ds->getMultiSamples(); traits->samples = ds->getNumMultiSamples(); return new osgQt::GraphicsWindowQt(traits.get()); } 

विंडो इनपुट के लिए प्रेषित ज्यामिति मापदंडों और ओएसजी 3 डी रेंडरिंग की आवश्यक सेटिंग्स के अनुसार कॉन्फ़िगर किया गया है। लौटा हुआ पॉइंटर OSG ग्राफिक्स संदर्भ है जिसे कैमरे को पास किया जाना चाहिए। इसलिए, अगला कदम कैमरा को इनिशियलाइज़ करना है

 void QViewerWidget::initCamera(const QRect &geometry) { osg::Camera *camera = viewer.getCamera(); osg::ref_ptr<osgQt::GraphicsWindowQt> gw = createGraphicsWindow(geometry); gw->setTouchEventsEnabled(true); camera->setGraphicsContext(gw.get()); const osg::GraphicsContext::Traits *traits = gw->getTraits(); camera->setClearColor(osg::Vec4(0.7f, 0.7f, 0.7f, 1.0f)); camera->setViewport(0, 0, traits->width, traits->height); double aspect = static_cast<double>(traits->width) / static_cast<double>(traits->height); camera->setProjectionMatrixAsPerspective(30.0, aspect, 1.0, 1000.0); } 

वास्तविक कॉल

 camera->setGraphicsContext(gw.get()); 

और कैमरे के लिए QGLWidget विजेट से जुड़े वांछित संदर्भ को पास करता है। हमने पूरे विजेट रूटीन को क्लास कंस्ट्रक्टर में डाल दिया

 QViewerWidget::QViewerWidget(const QRect &geometry) : QWidget() , scene(new osg::Group) { initCamera(geometry); viewer.setSceneData(scene); viewer.addEventHandler(new osgViewer::StatsHandler); viewer.setCameraManipulator(new osgGA::TrackballManipulator); viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded); osgQt::GraphicsWindowQt *gw = static_cast<osgQt::GraphicsWindowQt *>(viewer.getCamera()->getGraphicsContext()); QGridLayout *layout = new QGridLayout; if (layout != Q_NULLPTR) { layout->addWidget(gw->getGLWidget()); this->setLayout(layout); } } 

यहां हम दर्शक को कॉन्फ़िगर करते हैं और चुनौती पर विशेष ध्यान देते हैं

 viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded); 

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

 osgQt::GraphicsWindowQt *gw = static_cast<osgQt::GraphicsWindowQt *>(viewer.getCamera()->getGraphicsContext()); QGridLayout *layout = new QGridLayout; if (layout != Q_NULLPTR) { layout->addWidget(gw->getGLWidget()); this->setLayout(layout); } 

जिसमें हम एक परत बनाते हैं, कैमरे के ग्राफिक्स संदर्भ से लौटे QGLWidget के साथ हस्तक्षेप करते हुए, एक osgQt :: GraphicsWindows सूचक में परिवर्तित हो जाता है। हम कॉल करके अपने विजेट QViewerWidget में बनाई गई परत जोड़ते हैं

 this->setLayout(layout); 

हमारे विजेट के लिए, और इसके साथ, विंडो अपडेट होने पर दृश्य को अपडेट करने के लिए, आपको QPaintEvent ईवेंट हैंडलर को फिर से परिभाषित करना होगा।

 void QViewerWidget::paintEvent(QPaintEvent *) { viewer.frame(); } 

जिसमें हम osgViewer :: Viewer :: फ्रेम () विधि को कॉल करके फ्रेम के प्रतिपादन की शुरुआत करते हैं।

ठीक है, हमारे विजेट का कोड तैयार है, अब हम इसे फॉर्म में स्थित फ्रेम में एम्बेड करते हैं। ऐसा करने के लिए, मेनविंडो क्लास के कंस्ट्रक्टर में हम ऐसा कोड लिखते हैं

 MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) , ui(new Ui::MainWindow) , qviewer(Q_NULLPTR) { ui->setupUi(this); QGridLayout *layout = new QGridLayout; qviewer = new QViewerWidget(QRect(0, 0, ui->frame->width(), ui->frame->height())); layout->addWidget(qviewer); ui->frame->setLayout(layout); this->setCentralWidget(ui->frame); connect(&timer, &QTimer::timeout, this, &MainWindow::update); timer.start(40); connect(ui->actionQuit, &QAction::triggered, this, &MainWindow::quit); connect(ui->actionClean, &QAction::triggered, this, &MainWindow::clean); connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::open); this->setWindowTitle("QViewerWidget example"); } 

या इसके बजाय, हम अभी भी इसके इस भाग में रुचि रखते हैं

 QGridLayout *layout = new QGridLayout; qviewer = new QViewerWidget(QRect(0, 0, ui->frame->width(), ui->frame->height())); layout->addWidget(qviewer); ui->frame->setLayout(layout); this->setCentralWidget(ui->frame); 

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

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

 connect(&timer, &QTimer::timeout, this, &MainWindow::update); timer.start(40); 

पहले इस तरह से विंडो क्लास के लिए अपडेट स्लॉट निर्धारित किया गया है

 void MainWindow::update() { QMainWindow::update(this->geometry()); } 

ऐसा क्यों है, क्योंकि आप सीधे QMainWindow के साथ टाइमर सिग्नल को जोड़ सकते हैं :: अद्यतन स्लॉट उसी तरह से जैसे कि अधिकांश osgQb उदाहरण दिखाते हैं

 connect(&timer, SIGNAL(timeout), this, SLOT(update)); 

तथ्य यह है कि SIGNAL () और SLOT () मैक्रो के साथ वाक्यविन्यास पदावनत है, और Qt6 में संक्रमण की प्रत्याशा में, इसे छोड़ दिया जाना चाहिए। इसी समय, QMainWindow वर्ग में मापदंडों के बिना अपडेट () स्लॉट का अधिभार नहीं है, जो संकलन के दौरान बाइंड कॉल पर त्रुटि का कारण होगा। ऐसा करने के लिए, मुझे अपने अपडेट () स्लॉट को मापदंडों के बिना परिभाषित करना पड़ा, इसमें आधार QMainWindow :: update () को कॉल करते हुए, वहां विंडो के क्लाइंट एरिया को पास किया।

इस जगह को जोड़ने और कार्यक्रम चलाने के लिए, हम एक निश्चित परिणाम प्राप्त करेंगे



"S" दबाकर हम OSG सांख्यिकी मॉनिटर को सक्रिय कर सकते हैं और सुनिश्चित कर सकते हैं कि हमारा विजेट एक खाली दृश्य आरेखण के रूप में काम करना चाहिए।

4. हमारे दर्शक समाप्त करें: एक मेनू जोड़ें

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



अब हम उचित प्रोसेसर स्लॉट शुरू करेंगे, जिससे आप डायलॉग बॉक्स से चुने गए रास्ते के साथ मॉडल को लोड कर सकते हैं, सीन क्लियर कर सकते हैं और एप्लिकेशन से बाहर निकल जाएंगे


उसके बाद, हमें * .osg प्रारूप मॉडल का एक बहुत सुविधाजनक दर्शक मिलेगा।



उनके काम का एक प्रदर्शन वीडियो में लेख की शुरुआत में दिखाया गया है। इस उदाहरण के लिए पूर्ण स्रोत कोड यहां उपलब्ध है।

निष्कर्ष

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

यह लेख ओएसजी श्रृंखला की एक निरंतरता को खोलता है, जो जटिल विकास तकनीकों को रेखांकित करेगा। मुझे लगता है कि वह सफल रही। धन्यवाद और जल्द ही मिलते हैं!