🕌 🗓️ 👶🏾 गेमप्ले 3 डी फ्रेमवर्क - 3 डी गेम के क्रॉस-प्लेटफॉर्म विकास के लिए एक आसान शुरुआत 🛵 🦕 ✊🏻

अच्छा समय, प्रिय harazhiteli!

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

इस ढांचे का नाम गेमप्ले 3 डी है। इंटरनेट पर इसके बारे में अधिक जानकारी नहीं है, हम रनेट के बारे में क्या कह सकते हैं। यह C ++ में प्रोग्रामिंग गेम्स के लिए C ++ में लिखा गया एक ओपन सोर्स फ्रेमवर्क है, जो इससे होने वाले सभी फायदे और नुकसान के साथ है। परियोजना के लेखक इसे एक सार्वभौमिक उपकरण, 3 डी गेम के लिए एक तरह के कोकोस 2 डी एनालॉग के रूप में रखते हैं। GamePlay 3D पर लिखना शुरू करने के लिए, आपको OpenGL, GLSL या 3D गणित का गहरा ज्ञान होना आवश्यक नहीं है, लेकिन हम सभी समझते हैं कि एक अच्छा परिणाम प्राप्त करने का कोई तरीका नहीं है। विवरण और कटौती के तहत शुरू करने के लिए एक छोटा सा उदाहरण।

मैं शुरू करूँगा, शायद, इंजन की मुख्य विशेषताओं की एक छोटी सूची के साथ:

लिनक्स, विंडोज, मैक ओएस एक्स, एंड्रॉइड, आईओएस और ब्लैकबेरी ओएस के लिए समर्थन
C ++ API, Lua गेम स्क्रिप्ट
OpenGL 3.2+ और OpenGL ES 2.0
एक क्लिक में अलग ओएस के तहत परियोजना की विधानसभा *
दृश्यों का सरल और सुविधाजनक विन्यास (वस्तुएं, सामग्री, भौतिकी, एनीमेशन)
भौतिकी इंजन बुलेट (ठीक है, यह मानक की तरह है)
3 डी दृश्यों और फोंट को अपने द्विआधारी प्रारूप में परिवर्तित करने के लिए तैयार उपकरण
कीबोर्ड, माउस, जॉयस्टिक, स्क्रीन जॉयस्टिक और सेंसर इनपुट सपोर्ट
3 डी में ध्वनि (लहराती, ogg) के साथ सुविधाजनक काम
बटन, चेकबॉक्स, स्लाइडर्स, आदि के साथ अपना GUI
और भी बहुत कुछ।

* अच्छा, लगभग एक ...

प्रोजेक्ट साइट से सुविधाओं की एक पूरी सूची

पूर्ण विशेषताओं वाले OpenGL 3.2+ (डेस्कटॉप) और OpenGL ES 2.0 (मोबाइल) आधारित प्रतिपादन प्रणाली
निर्मित आम शैडर पुस्तकालय के साथ शेडर आधारित सामग्री प्रणाली
रोशनी, कैमरा, मॉडल, कण उत्सर्जक और भौतिकी टकराव की वस्तुओं के समर्थन के साथ नोड-आधारित दृश्य ग्राफ प्रणाली
कई सतह परतों और LOD के साथ ऊँचाई आधारित भूभाग
घोषणात्मक दृश्य बाइंडिंग (सामग्री) और नोड संलग्नक (कण उत्सर्जक, भौतिकी टकराव की वस्तुएं, 3 डी ऑडियो स्रोत)
घोषणात्मक कण प्रणाली
उपयोग में आसान पाठ और स्प्राइट प्रतिपादन
भौतिकी प्रणाली (बुलेट भौतिकी का उपयोग)
- वाहन भौतिकी
- चरित्र भौतिकी
- कठोर शरीर की गतिशीलता
- की कमी
- भूत की वस्तु
सुयोग्य यूआई और 3 डी रूपों के समर्थन के साथ घोषणात्मक यूआई प्रणाली। निम्नलिखित अंतर्निहित कोर नियंत्रण और लेआउट शामिल हैं:
- बटन
- लेबल
- पाठ बॉक्स
- स्लाइडर
- चेक बॉक्स
- रेडियो बटन
- पूर्ण लेआउट
- ऊर्ध्वाधर लेआउट
- प्रवाह लेआउट
कंकाल चरित्र एनीमेशन समर्थन के साथ पूरी तरह से एक्स्टेंसिबल एनीमेशन सिस्टम
WAV और OGG सपोर्ट के साथ 3D ऑडियो सिस्टम को पूरा करें
2 डी / 3 डी गणित और 3 डी ऑब्जेक्ट कुलिंग समर्थन के साथ पूर्ण वेक्टर गणित पुस्तकालय
माउस, कीबोर्ड, टच, जेस्चर और गेमपैड सपोर्ट
लुआ स्क्रिप्ट बाइंडिंग और बाइंडिंग जनरेटर टूल
ऐ राज्य मशीन

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

हम लिनक्स पर अपना पहला डेमो बना रहे होंगे। हमें आवश्यकता होगी:

पसंदीदा आईडीई या पाठ संपादक
सीमेक, मेक, जीसीसी
कोलाडा में निर्यात समर्थन के साथ ब्लेंडर

इंजन के निर्माण में जीथब से स्रोत कोड डाउनलोड करना, निर्भरता स्थापित करना और सीमेक चलाना शामिल है ... && बिल्ड निर्देशिका में बनाते हैं (Windows और Mac OS X उपयोगकर्ता क्रमशः एक मौजूदा Visual Studio या Xcode प्रोजेक्ट खोलते हैं, और एक क्लिक के साथ संकलित करते हैं)। संकलन सफलतापूर्वक पूरा होने के बाद, हम फ्रेमवर्क की मूल निर्देशिका में स्क्रिप्ट गेमप्ले-न्यूप्रोजेक्ट (Sh | bat) निष्पादित करके अपनी परियोजना बनाना शुरू करेंगे। स्क्रिप्ट कई प्रश्न पूछेगा, जिनके उत्तर में हम उस परियोजना की तैयार मछली प्राप्त करेंगे जिसे हमने निर्दिष्ट किया है। चलो डेमो प्रेकैट को कॉल करें और वर्तमान निर्देशिका (इंजन की रूट डायरेक्टरी) को पथ के रूप में निर्दिष्ट करें।

परियोजना

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

cd Demo/build cmake .. make

परिणामी बाइनरी चलाएँ:

 cd ../bin/linux ./Demo

यदि सब कुछ ठीक है, तो आपको कुछ इस तरह से देखना चाहिए:

तो, वीएस, Xcode और cmake प्रोजेक्ट फ़ाइलों को छोड़कर हम गेम फ़ोल्डर में क्या देखते हैं?
game.config - एक बुनियादी कॉन्फ़िगरेशन जैसे कि अनुमति, पूर्ण स्क्रीन या विंडो, आदि।
रेस / - खेल संसाधनों के साथ निर्देशिका
Res / box.gpb - खेल दृश्य (सिर्फ एक कैमरा और प्रकाश स्रोत के साथ एक घन), देशी प्रारूप में एन्कोडेड
box.dae - अपने कच्चे रूप में खेल का दृश्य, इस मामले में कोलाडा प्रारूप में
रंगीन (नाजुक | लंबवत) - क्यूब सामग्री में उपयोग किए जाने वाले शेड्स
Res / box.material - घन सामग्री का विवरण
src / - स्रोत
src / Demo। (cpp | h) - बेस क्लास
Android / - Android के लिए एक खेल के निर्माण के लिए परियोजना
बिन / - संकलित बायनेरिज़

लेकिन एक घूर्णन क्यूब के साथ एक समाप्त उदाहरण बहुत सरल और उबाऊ है, इसके अलावा हम इंजन में थोड़ी गहराई खोदना चाहते हैं: अधिक क्यूब्स और यहां तक कि गेंदें जोड़ें, उनके भौतिक गुणों और सामग्रियों को निर्धारित करें।

परिणाम के रूप में हमें यहाँ मिलता है:

सबसे पहले, ब्लेंडर में एक दृश्य बनाएं: क्यूब्स एक निश्चित सतह पर लटकाते हैं, पूरी खुशी के लिए कुछ गेंदों के ऊपर। इस तथ्य पर ध्यान देना महत्वपूर्ण है कि गेम में ऊंचाई y अक्ष द्वारा निर्धारित की जाती है, न कि z , ब्लेंडर के विपरीत (वास्तव में, यह मायने नहीं रखता है, लेकिन ऐसा लगता है कि गेमप्ले 3 डी में y अक्ष पर ऊंचाई निर्धारित नहीं है, तो कुछ समस्याएं हैं, इसलिए) प्रयोग की शुद्धता के लिए हम y का उपयोग करेंगे)। हमें किसी तरह सभी वस्तुओं को नाम देने की आवश्यकता है ताकि हम उन्हें गेम कोड से एक्सेस कर सकें और उन्हें एक दूसरे से अलग कर सकें। हम सरल करेंगे - सभी क्यूब्स को बॉक्सएक्स , बॉल्स बॉलएक्स कहा जाएगा, जहां एक्स कोई भी संख्या है। जिस सतह पर वे चढ़ते हैं उसे फर्श कहा जाता है। हम कैमरे के कैमरे को कॉल करते हैं और इसे घुमाते हैं ताकि हमें जो चाहिए वह लेंस में गिर जाए। दृश्य तैयार है और गेमप्ले-एनकोडर उपयोगिता द्वारा समझे गए प्रारूप में निर्यात किया जा सकता है। चुनने के लिए दो विकल्प हैं: FBX और COLLADA। हम COLLADA चुनते हैं, क्योंकि इस स्तर पर यह आसान है (लेख के अंत में विवरण)।

परिणाम कुछ इस तरह दिखता है:

आलसी और उन लोगों के लिए, जिनके हाथ में ब्लेंडर नहीं है

ब्लेंडर के लिए दृश्य: dl.dropbox.com/u/64710641/boxes.blend
COLLADA में दृश्य: dl.dropbox.com/u/64710641/boxes.dae
GamePlayBundle में परिवर्तित दृश्य: dl.dropbox.com/u/64710641/boxes.gpb

यह वह जगह है जहाँ गेमप्ले-एनकोडर आता है। यह उपयोगिता विभिन्न अपचनीय फ़ाइल स्वरूपों को फ्रेमवर्क के मूल द्विआधारी प्रारूप में परिवर्तित करती है। हम XML से किसी दृश्य के पार्सर पर अतिरिक्त समय और स्मृति खर्च नहीं करना चाहते हैं या 3 डी में एक वेक्टर फ़ॉन्ट प्रदान नहीं करना चाहते हैं? ऐसी वस्तुओं को अग्रिम में पार्स करना और उन्हें अनुकूलित बाइनरी रूप में सहेजना बेहतर है, ताकि बाद में वे बस स्मृति में लोड हो जाएं। इसलिए, कलाई की एक झिलमिलाहट के साथ, हम दृश्य .dae फ़ाइल को ब्लेंडर से दृश्य में परिवर्तित करते हैं। pgb और इस फ़ाइल को हमारे प्रोजेक्ट के Res / subdirectory में डालते हैं:

 path/to/GamePlay/bin/linux/gameplay-encoder scene.dae

घूर्णन क्यूब के साथ शुरुआती उदाहरण के विपरीत, हम मैन्युअल रूप से दृश्य में वस्तुओं की खोज नहीं करेंगे और उनके गुणों का निर्धारण करेंगे। हम केवल एक फाइल बनाते हैं जो दृश्य का वर्णन करता है, और फिर फ्रेमवर्क सब कुछ अपने आप करेगा। तो game.scene दृश्य विवरण फ़ाइल:

 scene boxes { //     path = res/boxes.gpb //    activeCamera = camera //     floor node floor { //  ,     material = res/game.material#floor //   ,   collisionObject res/game.physics#floor } //   node boxes { //  url,          boxX url = box* //  material = res/game.material#box //  collisionObject = res/game.physics#box } //    node ball { url = ball* material = res/game.material#ball collisionObject = res/game.physics#ball } //      physics { //     y gravity = 0.0, -9.8, 0.0 } }

संकेतित सामग्री और भौतिक गुणों को छत से नहीं लिया जाता है, बल्कि इसी गेममैट्री और game.physics फ़ाइलों से लिया जाता है।

game.material:

 //       material colored { technique { //      pass 0 { //     ,  //      u_worldViewProjectionMatrix = WORLD_VIEW_PROJECTION_MATRIX u_inverseTransposeWorldViewMatrix = INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX //         ... //      renderState { cullFace = true depthTest = true } //        vertexShader = res/shaders/colored.vert fragmentShader = res/shaders/colored.frag } } } //   .     colored material box : colored { //       u_diffuseColor = 0.8, 0.2, 0.2, 1.0 } //    material ball : colored { u_diffuseColor = 0.2, 0.2, 0.8, 1.0 } //   material floor : colored { u_diffuseColor = 0.2, 0.8, 0.2, 1.0 }

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

game.physics:

 //     collisionObject box { //   -   type = RIGID_BODY //  bounding box -  shape = BOX //   mass = 2.0 } //     collisionObject ball { type = RIGID_BODY //  bounding box -  shape = SPHERE mass = 1.0 } //    ,     collisionObject floor { type = RIGID_BODY shape = BOX mass = 0 }

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

साबुन आपको गेम कोड में दृश्य.जीपीबी डाउनलोड करने के लिए है।
हमारे पास बेस क्लास डेमो, इनहेरिटिंग क्लास गेम है। खेल का जीवन चक्र इस प्रकार है:

इनिशियलाइज़ेशन () विधि में गेम आरंभीकरण ;
अद्यतन पद्धति में प्रत्येक फ्रेम से पहले दुनिया की स्थिति को अपडेट करना (फ़्लैट एल्प्सडाइम);
रेंडर विधि में दृश्य प्रस्तुत करना (बीता हुआ समय बीता);
अंतिम रूप में आवेदन को समाप्त करना () विधि ;

हम सिर्फ इनिशियलाइज़ () मेथड को बदलते हैं और अपडेट (फ्लोट एलाप्सिडाइम) विधि को खाली करते हैं ।

आमतौर पर प्रारंभिक () विधि में हम दृश्य फ़ाइलों, लिपियों को लोड करते हैं, और गेम की प्रारंभिक स्थिति सेट करते हैं। तो हम करेंगे:

 void Demo::initialize() { //        game.scene, //         _scene = Scene::load("res/game.scene"); //  - .         Blender, //            _lightNode = Node::create("directionalLight1"); //      ,    Light* light = Light::createDirectional(_scene->getActiveCamera()->getNode()->getForwardVector()); //    light->setColor(1.0, 1.0, 1.0); //        _lightNode->setLight(light); //         _scene->getActiveCamera()->setAspectRatio((float)getWidth() / (float)getHeight()); //     ,     _scene->visit(this, &Demo::initializeScene); }

InitializeScene () विधि जोड़ें, जो हमारे द्वारा बनाए गए प्रकाश स्रोत का उपयोग करके प्रत्येक दृश्य ऑब्जेक्ट को प्रकाश पैरामीटर प्रदान करेगा। मुझे लगता है कि यहाँ की टिप्पणियाँ अतिश्योक्तिपूर्ण हैं:

 bool Demo::initializeScene(Node* node) { Model* model = node->getModel(); if (model) { Material* material = model->getMaterial(); if (material && material->getTechnique()->getPassByIndex(0)->getEffect()->getUniform("u_lightDirection")) { material->getParameter("u_ambientColor")->setValue(_scene->getAmbientColor()); material->getParameter("u_lightColor")->setValue(_lightNode->getLight()->getColor()); material->getParameter("u_lightDirection")->setValue(_lightNode->getForwardVectorView()); } } return true; }

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

Demo.h और Demo.cpp की पूरी सूची

 #ifndef TEMPLATEGAME_H_ #define TEMPLATEGAME_H_ #include "gameplay.h" using namespace gameplay; /** * Main game class. */ class Demo: public Game { public: /** * Constructor. */ Demo(); /** * @see Game::keyEvent */ void keyEvent(Keyboard::KeyEvent evt, int key); /** * @see Game::touchEvent */ void touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex); protected: /** * @see Game::initialize */ void initialize(); /** * @see Game::finalize */ void finalize(); /** * @see Game::update */ void update(float elapsedTime); /** * @see Game::render */ void render(float elapsedTime); private: /** * Draws the scene each frame. */ bool drawScene(Node* node); bool initializeScene(Node* node); Scene* _scene; Node* _lightNode; }; #endif

 #include "Demo.h" // Declare our game instance Demo game; Demo::Demo() : _scene(NULL), _lightNode(NULL) { } void Demo::initialize() { _scene = Scene::load("res/game.scene"); _lightNode = Node::create("directionalLight1"); Light* light = Light::createDirectional(_scene->getActiveCamera()->getNode()->getForwardVector()); light->setColor(1.0, 1.0, 1.0); _lightNode->setLight(light); // Set the aspect ratio for the scene's camera to match the current resolution _scene->getActiveCamera()->setAspectRatio((float)getWidth() / (float)getHeight()); _scene->visit(this, &Demo::initializeScene); } void Demo::finalize() { SAFE_RELEASE(_lightNode); SAFE_RELEASE(_scene); } void Demo::update(float elapsedTime) { } void Demo::render(float elapsedTime) { // Clear the color and depth buffers clear(CLEAR_COLOR_DEPTH, Vector4::zero(), 1.0f, 0); // Visit all the nodes in the scene for drawing _scene->visit(this, &Demo::drawScene); } bool Demo::initializeScene(Node* node) { Model* model = node->getModel(); if (model) { Material* material = model->getMaterial(); if (material && material->getTechnique()->getPassByIndex(0)->getEffect()->getUniform("u_lightDirection")) { material->getParameter("u_ambientColor")->setValue(_scene->getAmbientColor()); material->getParameter("u_lightColor")->setValue(_lightNode->getLight()->getColor()); material->getParameter("u_lightDirection")->setValue(_lightNode->getForwardVectorView()); } } return true; } bool Demo::drawScene(Node* node) { // If the node visited contains a model, draw it Model* model = node->getModel(); if (model) { model->draw(); } return true; } void Demo::keyEvent(Keyboard::KeyEvent evt, int key) { if (evt == Keyboard::KEY_PRESS) { switch (key) { case Keyboard::KEY_ESCAPE: exit(); break; } } } void Demo::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex) { switch (evt) { case Touch::TOUCH_PRESS: break; case Touch::TOUCH_RELEASE: break; case Touch::TOUCH_MOVE: break; }; }

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

क्रॉस-प्लेटफॉर्म

अन्य प्लेटफार्मों के लिए खेल की विधानसभा में एक छोटा विषयांतर।

एंड्रॉइड: आपको एंड्रॉइड एसडीके और एनडीके डाउनलोड करना होगा, और अपाचे चींटी को स्थापित करना होगा। SDK और NDK के रास्ते पथ में होने चाहिए। हमारी परियोजना की Android निर्देशिका पर जाएं, अपडेट प्रोजेक्ट -t 1 -p चलाएं । -s && ndk- बिल्ड करें और समाप्त APK प्राप्त करें।
Mac OS X / iOS: Xcode में प्रोजेक्ट फ़ाइल खोलें, बिल्ड, रन करें।
Windows: Visual Studio प्रोजेक्ट फ़ाइल खोलें, बनाएँ, चलाएँ।
ब्लैकबेरी प्लेबुक: साइट पर विवरण देखें। दुर्भाग्य से, मैं प्लेबुक का मालिक नहीं हूं और स्थिति पर टिप्पणी नहीं कर सकता। लेकिन कब से मूल रूप से फ्रेमवर्क के लेखकों ने इसे प्लेबुक के तहत लिखा था, मुझे लगता है कि इसके साथ कोई समस्या नहीं होनी चाहिए।

कमियों

उनके बिना कहाँ?

अब तक मैंने जो सबसे बड़ी समस्या का सामना किया है वह ब्लेंडर और गेमप्ले-एनकोडर है। पहले व्यक्ति को COLLADA को सामान्य नक्शे निर्यात करने का तरीका नहीं पता है, इसलिए आप बंप-मैपिंग के बारे में भूल सकते हैं। एक पैच फ्रेमवर्क के उपयोगकर्ताओं में से एक द्वारा लिखा गया है, लेकिन यह पैच अभी तक ब्लेंडर कोड में शामिल नहीं है और इसका समावेश अभी तक नियोजित नहीं है। इस पैच के साथ ब्लेंडर का पुनर्निर्माण एक आसान काम नहीं है, मैं अब तक सफल नहीं हुआ हूं। बेशक, आप कोलाडा के बजाय एफबीएक्स का उपयोग कर सकते हैं। लेकिन यहां एक और समस्या है - गेमप्ले-एनकोडर का पुनर्निर्माण करना इतना आसान नहीं है। यह एक तैयार बाइनरी के रूप में आता है और एफबीएक्स समर्थन के बिना ठीक काम करता है, जैसा कि FBX मालिकाना है। एफबीएक्स एसडीके को ऑटोडेस्क वेबसाइट से मुफ्त में डाउनलोड किया जा सकता है, लेकिन एफबीएक्स समर्थन के साथ गेमप्ले-एनकोडर का निर्माण भी एक बड़ा सिरदर्द है। कहीं opencollada के पुराने संस्करण का उपयोग किया गया है, तो libpcrecpp के नए संस्करणों से लिंक करने से इनकार करते हुए, कहीं FBX SDK शरारती है, आदि। और अगर Ubuntu 12.04 पर यह अभी भी संभव है, तो अधिक हाल के लिनक्स पर - उदासी। इसका उपाय माया या 3DsMax का उपयोग करना है जहाँ बम्प-मैपिंग की आवश्यकता है, या अन्य विधियों का उपयोग करें। या ब्लेंडर या गेमप्ले-एनकोडर बनाने में समय बिताएं।

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

मामूली कीड़े। परियोजना स्पष्ट रूप से काफी युवा है। कभी-कभी छोटे कीड़े होते हैं, जो हालांकि, जल्दी से तय हो जाते हैं। लेखक पूल अनुरोध और पैच को सक्रिय रूप से स्वीकार करते हैं और आम तौर पर समुदाय के अनुकूल होते हैं।

परिणाम

इस उदाहरण में, हमने गेमप्ले 3 डी का केवल एक छोटा सा हिस्सा हमें प्रदान किया है। भौतिकी इंजन के साथ वाहनों और पात्रों के समान सरल सिमुलेशन, एनीमेशन और ध्वनि की सरल प्रोग्रामिंग, विभिन्न उपकरणों से इनपुट के प्राथमिक नियंत्रण और विभिन्न प्लेटफार्मों के लिए कॉन्फ़िगरेशन के सुविधाजनक जुदाई के साथ समाप्त होने से कई अन्य अच्छाई और खुशियाँ हैं। हाल ही में, Habré पर एक लेख फिसल गया कि एंड्रॉइड के लिए गेम लिखना कितना मुश्किल है, क्योंकि, अन्य बातों के अलावा, विभिन्न फोन हार्डवेयर बनावट संपीड़न के लिए अलग-अलग चिप्स का उपयोग करते हैं। इस समस्या को हल करने के लिए, उदाहरण के लिए, आप अलग-अलग चिप्स के लिए संबंधित बनावट के लिए पथों के साथ अलग कॉन्फ़िगरेशन फ़ाइल बना सकते हैं: खेल के लिए atc चिप्स, dxt के लिए game.dxt.config, pvr, game.pvr.config के साथ उपकरणों के लिए गेम। पीसी के लिए png.conf, और इंजन बिना किसी विशेष प्रश्न के एक विशिष्ट डिवाइस के लिए आवश्यक कॉन्फिगर उठाएगा।

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

प्रोजेक्ट साइट: gameplay3d.org

ब्लेंडर के लिए प्रोजेक्ट और दृश्य स्रोत के साथ पुरालेख: dl.dropbox.com/u/64710641/Demo_complete.zip
ब्लेंडर के लिए दृश्य: dl.dropbox.com/u/64710641/boxes.blend
COLLADA में दृश्य: dl.dropbox.com/u/64710641/boxes.dae
GamePlayBundle में परिवर्तित दृश्य: dl.dropbox.com/u/64710641/boxes.gpb

अंत में, उपयोगकर्ताओं के उदाहरण के एक जोड़े ने परियोजना मंच पर अपने विकास को प्रकाशित किया।

तरल गतिकी प्रयोग

आचरण के पंख डस्टर BB10 एप्लिकेशन

गेमप्ले 3 डी + किनेक्ट

BBGamePlay + OpenNI का उपयोग करके AR बॉडी सूट

बेनाम: Kinect खेल

गेमप्ले 3 डी फ्रेमवर्क - 3 डी गेम के क्रॉस-प्लेटफॉर्म विकास के लिए एक आसान शुरुआत

परियोजना

क्रॉस-प्लेटफॉर्म

कमियों

परिणाम

More articles: