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

आगे देखते हुए, अंतिम परिणाम इस तरह दिखता है:

आवश्यक पुस्तकालयों में शामिल हैं:

वायुमंडलीय प्रभावों, अर्थात् आकाश और बादलों के लिए Caelum ;
पानी की सतह के लिए हाइड्रैक्स ;
वनस्पति के लिए पृष्ठांकित ज्यामिति , जिसमें शामिल हैं, लेकिन पेड़ों, झाड़ियों और घास तक सीमित नहीं हैं।

एक कदम: आवेदन कंकाल

एप्लिकेशन के कंकाल के रूप में, हम थोड़ा संशोधित ओग्रे विकी ट्यूटोरियल फ्रेमवर्क का उपयोग करेंगे - ओग्रे-विकी से गाइड के लिए एक सामान्य ढांचा, क्योंकि यह छोटी जटिलता के अनुप्रयोगों को बनाने के लिए पर्याप्त लचीला है; इसके अलावा, इसमें बहुत अधिक कार्यक्षमता शामिल है, विशेष रूप से, WASD चाबियाँ, माउस की समीक्षा, एफपीएस काउंटर और अन्य उपयोगी चीजों के साथ कैमरे की गति। संकलन के लिए, मैंने Microsoft Visual C ++ 2008 और CMake बिल्ड सिस्टम का उपयोग किया (बाद वाला आपको Ogre द्वारा समर्थित किसी भी आर्किटेक्चर के तहत प्रोजेक्ट को संकलित करने की अनुमति देगा)।
मैंने गितुब पर सभी स्रोतों को पोस्ट किया (हालांकि, गिट के साथ गड़बड़ न करने के लिए, आप उन्हें इस पते पर डाउनलोड कर सकते हैं)। संकलन के लिए, आपको शाखाओं की आवश्यकता होगी 1.7 और सीएमके को 2008 के स्टूडियो ओग्रे द्वारा पूर्व-इकट्ठे; Ogre को सही ढंग से खोजने के लिए बाद के लिए, आपको उस निर्देशिका के बराबर OGRE_HOME परिवेश चर जोड़ना होगा जिसमें यह स्थापित है।
इसके अलावा, परीक्षण आवेदन को चलाने के लिए, आपको दो अभिलेखागार की आवश्यकता होगी: मीडिया.ज़िप के साथ बनावट, मॉडल और अन्य आवश्यक चीजें, इसे सीधे परियोजना निर्देशिका में अनपैक करना होगा; और configs.zip , जिसमें Ogre कॉन्फ़िगरेशन फ़ाइलें हैं - आपको इसे विधानसभा निर्देशिका में अनज़िप करने की आवश्यकता है।
परियोजना को संकलित करने के लिए, पहले सीएमके जीयूआई चलाएं और "जहां स्रोत कोड है" फ़ील्ड में प्रोजेक्ट निर्देशिका का चयन करें, और "जहां बायनेरीज़ बनाने के लिए" फ़ील्ड - मनमाना, उदाहरण के लिए, आप प्रोजेक्ट डायरेक्टरी के बिल्ड उपनिर्देशिका का चयन कर सकते हैं। फिर हम कॉन्फ़िगर बटन पर क्लिक करें, संकलक की सूची में विजुअल स्टूडियो 2008 का चयन करें, और अगर सब कुछ ठीक हो गया और सीएमके ने कुछ भी नहीं होने की शपथ नहीं ली, तो जनरेट पर क्लिक करें :

परिणामस्वरूप, Visual Studio लैंडस्केपApp.sln समाधान फ़ाइल बिल्ड निर्देशिका में दिखाई देती है, जिसके साथ आप सीधे काम कर सकते हैं - कोड में परिवर्तन कर सकते हैं, परीक्षण प्रोजेक्ट को संकलित और चला सकते हैं।
दरअसल, संकलन और लॉन्च के बाद, हमें मानक ओग्रे रेंडर सबसिस्टम चयन विंडो द्वारा बधाई दी गई है:

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

खैर, जैसा कि एक प्रसिद्ध राजनीतिज्ञ ने कहा, "मुख्य बात यह है कि शुरू करना है!"

चरण दो: स्वर्ग

Caelum एक Ogre प्लगइन है, जो आकाशीय रंग, सूर्य, चंद्रमा और सितारों जैसे वर्तमान समय और पर्यवेक्षक निर्देशांक, बादलों, मौसम की घटनाओं (बारिश, बर्फ, कोहरे), आदि को ध्यान में रखते हुए GNU लेसर GPL लाइसेंस के तहत वितरित किया जाता है। घ।
हम Google कोड पर रिपॉजिटरी से Caelum का नवीनतम संस्करण डाउनलोड करेंगे, क्योंकि, मंच पर संदेशों को देखते हुए, इस परियोजना में एक नया अनुचर है और एक निश्चित गति है - परियोजना में नई सुविधाएँ जोड़ी गई हैं और वे पुरानी त्रुटियों को ठीक करती हैं

hg clone https://code.google.com/p/caelum

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

add_subdirectory ( Caelum )

CMakeLists.txt फ़ाइल में, Caelum/main/include और ${CMAKE_BINARY_DIR}/Caelum/main/include उप निर्देशिकाओं की सूची में include_directories कमांड का उपयोग करके और Caelum को include_directories कमांड का उपयोग करके लिंक किए गए पुस्तकालयों की सूची में जोड़कर:

कोड

include_directories ( ${ OIS_INCLUDE_DIRS } ${ OGRE_INCLUDE_DIRS } ${ OGRE_SAMPLES_INCLUDEPATH } "Caelum/main/include" "${CMAKE_BINARY_DIR}/Caelum/main/include" # ... target_link_libraries ( LandscapeApp ${ OGRE_LIBRARIES } ${ OIS_LIBRARIES } Caelum )

कोड को थोड़ा और बदलाव की आवश्यकता होगी। आरंभ करने के लिए, हमारे मुख्य लैंडस्केपApplication.hpp शीर्षक फ़ाइल में Caelum हेडर फ़ाइल शामिल करें:

#include <Caelum.h>

और लैंडस्केपApplication.cpp स्रोत कोड फ़ाइल में उपयुक्त नाम स्थान शामिल करें:

using namespace Caelum;

इसके अलावा, Caelum आकाश और वायुमंडल के प्रतिपादन के लिए अलग-अलग घटकों का एक समूह है, जो कि CaelumSystem रूट क्लास द्वारा नियंत्रित किया जाता है। यह वर्ग सभी घटकों की निगरानी करता है और यदि आवश्यक हो, तो उनकी आंतरिक स्थिति को अपडेट करता है। चलिए इस वर्ग का एक उदाहरण बनाते हैं, इसके लिए हम अपने मूल LandscapeApplication वर्ग में इसे एक पॉइंटर जोड़ते हैं:

कोड

class LandscapeApplication : public BaseApplication { // ... protected : virtual void createScene( void ); Caelum :: CaelumSystem * mCaelumSystem; };

और निर्माता को createScene पद्धति में कॉल करें:

void LandscapeApplication :: createScene( void ) { mCaelumSystem = new CaelumSystem(mRoot, mSceneMgr, CaelumSystem :: CAELUM_COMPONENTS_DEFAULT);

सबसे महत्वपूर्ण अंतिम पैरामीटर है, जो एक बिटमास्क है जो यह दर्शाता है कि हम कौन सी Caelum घटकों का उपयोग करेंगे। CAELUM_COMPONENTS_DEFAULT - डिफ़ॉल्ट सेट, इसमें सभी स्थिर घटक शामिल हैं।
CaelumSystem और इसके घटकों में बड़ी संख्या में सेटिंग्स हैं, जिनमें से अधिकांश कोड से get/set विधियों के रूप में उपलब्ध हैं और प्रलेखन में वर्णित हैं; ट्यूनिंग का एक और स्पष्ट तरीका 3 डी-संपादक ओगिटर है , जो विशेष रूप से ओग्रे के लिए बनाया गया है और इस लेख में वर्णित सभी पुस्तकालयों का समर्थन करता है (और कुछ का वर्णन नहीं किया गया है):

अंतिम स्पर्श - समय के साथ वायुमंडलीय प्रभावों को बदलने के लिए, आपको हर फ्रेम में सीलम को अपडेट करने की आवश्यकता है; बस हमारे CaelumSystem उदाहरण को फ्रेम श्रोता और रेंडर लक्ष्य श्रोता Ogre सूचियों में जोड़ें:

mCaelumSystem = new CaelumSystem(mRoot, mSceneMgr, CaelumSystem :: CAELUM_COMPONENTS_DEFAULT); mRoot -> addFrameListener(mCaelumSystem); mWindow -> addListener(mCaelumSystem);

वोइला - हमें सूर्य के साथ एक नीले आकाश द्वारा अभिवादन किया जाता है, जो धीरे-धीरे सूर्यास्त, दुर्लभ बादलों और धूसर कोहरे के साथ आता है:

हम अधिक मनोरंजन के लिए कुछ Caelum विकल्पों को ट्विस्ट करेंगे:

कोड

// ... mWindow -> addListener(mCaelumSystem); mCaelumSystem -> getUniversalClock() -> setTimeScale( 100 ); // FlatCloudLayer * cloudLayer = // , mCaelumSystem -> getCloudSystem() -> createLayer(); // : cloudLayer -> setCloudCover( 0.8f ); // cloudLayer -> setCloudSpeed(Vector2( 0.0001f , 0.0001f )); // cloudLayer -> setHeight( 5000 ); //

नतीजतन, आकाश इस तरह दिखता है:

हमारे आवेदन में पृथ्वी की सतह को जोड़ने का समय आ गया है ताकि सूर्य और चंद्रमा को जाने के लिए जगह मिल सके।

चरण तीन: पृथ्वी

हम अपने आवेदन में पृथ्वी की सतह को जोड़ने के लिए मूल Ogre इलाके प्रतिपादन उपतंत्र ( Ogre Terrain System ) का उपयोग करेंगे। यह सिस्टम 2009 में ओगरे स्टीव स्ट्रीट के निर्माता द्वारा अप्रचलित भू-भाग रेंडरिंग ऐड-ऑन को बदलने के लिए बनाया गया था और यह पूरी तरह से अलग वैकल्पिक घटक है (फिर भी, Ogre पैकेज में शामिल संस्करण 1.7 से)। ऑगरे टेरेन सिस्टम में वह सब कुछ शामिल है जो आपको हमारे जैसे छोटे परीक्षण अनुप्रयोगों को बनाने की आवश्यकता है, और पृष्ठों के अलग-अलग छोटे टुकड़ों के साथ रैम में भरी हुई विशाल दुनिया के लिए - इस बारे में अधिक ओग्रे मंच पर पाया जा सकता है, उदाहरण के लिए, यहां ; इसके अलावा, GSoC'11 परियोजनाओं में से एक इलाके के पृष्ठ लोडिंग तंत्र में सुधार करना है ।
सबसे पहले, CMake को हमारे इरादों के बारे में बताएं: CMakeLists.txt फ़ाइल में, ${OGRE_Terrain_LIBRARIES} कमांड का उपयोग करके लिंक किए गए पुस्तकालयों की सूची में ${OGRE_Terrain_LIBRARIES} जोड़ें:

target_link_libraries ( LandscapeApp ${ OGRE_LIBRARIES } ${ OGRE_Terrain_LIBRARIES } ${ OIS_LIBRARIES } Caelum )

अब हम भू-भाग में एक पेज लोड करने के लिए LandscapeApplication::createScene पद्धति को LandscapeApplication::createScene (मैं ओग्रे में "टेरेन उदाहरण" से लिया गया हूं), जो ओग्रे बेसिक ट्यूटोरियल 3 के कोड से लगभग मेल खाता है।

कोड

mCamera -> setPosition(Vector3( 1683 , 50 , 2116 )); // mCamera -> lookAt(Vector3( 1963 , 50 , 1660 )); Vector3 lightdir( 0.55f , -0.3f , 0.75f ); // lightdir.normalise(); Light * light = mSceneMgr -> createLight( "tstLight" ); light -> setType(Light :: LT_DIRECTIONAL); light -> setDirection(lightdir); light -> setDiffuseColour(ColourValue :: White); light -> setSpecularColour(ColourValue( 0.4f , 0.4f , 0.4f )); mTerrainGlobals = OGRE_NEW TerrainGlobalOptions; // mTerrainGroup = OGRE_NEW TerrainGroup(mSceneMgr, // Terrain :: ALIGN_X_Z, 513 , 12000 ); mTerrainGroup -> setOrigin(Vector3 :: ZERO); mTerrainGlobals -> setLightMapDirection(light -> getDerivedDirection()); mTerrainGlobals -> setCompositeMapAmbient(mSceneMgr -> getAmbientLight()); mTerrainGlobals -> setCompositeMapDiffuse(light -> getDiffuseColour()); mSceneMgr -> destroyLight( "tstLight" ); mTerrainGroup -> defineTerrain( 0 , 0 ); // (0, 0) mTerrainGroup -> loadAllTerrains( true ); // , mTerrainGroup -> freeTemporaryResources(); //

और, ज़ाहिर है, mTerrainGlobals और mTerrainGroup पॉइंटर्स को हमारे मुख्य वर्ग में जोड़ें:

कोड

#include <Terrain/OgreTerrain.h> #include <Terrain/OgreTerrainGroup.h> class LandscapeApplication : public BaseApplication { // ... protected : // ... Ogre :: TerrainGlobalOptions * mTerrainGlobals; Ogre :: TerrainGroup * mTerrainGroup; };

यदि कोई विशेष पैरामीटर निर्दिष्ट नहीं किया गया है, तो समन्वय (0, 0) वाले पृष्ठ को terrain_00000000.dat फ़ाइल से लोड किया जाएगा, जिसे मैंने उपरोक्त media.zip संग्रह में जोड़ा है।
परिणाम आने में लंबा नहीं है:

चरण चार: पानी

ओगरे - हाइड्रैक्स में एक प्रक्षेपण ग्रिड का उपयोग करके पानी की सतह के प्रतिपादन के लिए सबसे व्यापक रूप से उपयोग की जाने वाली लाइब्रेरी, जीएनयू लेसर जीपीएल के तहत लाइसेंस प्राप्त है।
यहाँ से डाउनलोड करें (पहली पोस्ट के नीचे लिंक) संग्रह, आगे के काम के लिए आपको इसमें से Hydrax-v0.5.1 / Hydrax / src / Hydrax कैटलॉग की आवश्यकता होगी, जिसे मैंने परीक्षण परियोजना के पेड़ में कॉपी किया था।
दुर्भाग्य से, हाइड्रैक्स CMake बिल्ड सिस्टम का समर्थन नहीं करता है, इसलिए मुझे इसके लिए एक Hydrax / CMakeLists.txt फाइल लिखना था, जो कि, हालांकि, केवल स्रोत और हेडर फ़ाइलों को सूचीबद्ध करने की तुलना में थोड़ा अधिक जटिल है। निर्माण प्रणाली में मुख्य रूप से CMakeLists.txt में हाइड्रैक्स को एकीकृत करने के लिए, आपको निम्नलिखित जोड़ने की आवश्यकता है:

कोड

include_directories ( # ... "Hydrax" ) add_subdirectory ( Hydrax ) # ... target_link_libraries ( LandscapeApp ${ OGRE_LIBRARIES } ${ OGRE_Terrain_LIBRARIES } ${ OIS_LIBRARIES } Caelum Hydrax )

इसके अलावा, हमारे आवेदन में पानी के प्रभाव को जोड़ने के लिए, हमें Hydrax::Hydrax वर्ग का एक ठीक से प्रारंभिक उदाहरण चाहिए।

कोड

// LandscapeApplication.hpp class LandscapeApplication : public BaseApplication { // ... protected : // ... Hydrax :: Hydrax * mHydrax; }; // LandscapeApplication.cpp void LandscapeApplication :: createScene( void ) { // ... mHydrax = new Hydrax :: Hydrax(mSceneMgr, mCamera, mWindow -> getViewport( 0 )); Hydrax :: Module :: ProjectedGrid * mModule = new Hydrax :: Module :: ProjectedGrid( // mHydrax, // Hydrax new Hydrax :: Noise :: Perlin( /* */ ), // Ogre :: Plane(Ogre :: Vector3( 0 , 1 , 0 ), Ogre :: Vector3( 0 , 0 , 0 )), // Hydrax :: MaterialManager :: NM_VERTEX, // Hydrax :: Module :: ProjectedGrid :: Options( 64 )); // mHydrax -> setModule(mModule); mHydrax -> loadCfg( "HydraxDemo.hdx" ); mHydrax -> create(); }

हमारे आवेदन को लॉन्च करके, हम एक अप्रत्याशित तस्वीर का निरीक्षण करते हैं:

पानी की जगह स्याही। क्या हुआ था?
तथ्य यह है कि केलम ओगरे के लिए कोहरे के विकल्पों को समायोजित करता है, ताकि वे सबसे अधिक वायुमंडलीय मॉडल के साथ संगत हों जिसका उपयोग कैरम द्वारा किया जाता है। हालांकि, ये विकल्प हाइड्रैक्स पानी को ठीक से प्रदान करने से रोकते हैं। Caelum विकल्पों को थोड़ा mCaelumSystem->setGlobalFogDensityMultiplier(0.01) (अर्थात् mCaelumSystem->setGlobalFogDensityMultiplier(0.01) , यानी कोहरे के घनत्व को कम करके), आप यह सुनिश्चित कर सकते हैं कि हाइड्रैक्स से बना पानी वास्तव में है:

कोहरे के मापदंडों का सावधानीपूर्वक समायोजन इस लेख के दायरे से परे है, इसलिए हमारे परीक्षण आवेदन में, हम बस कोहरे को बंद कर देते हैं:

void LandscapeApplication :: createScene( void ) { // ... cloudLayer -> setHeight( 5000 ); mCaelumSystem -> setManageSceneFog(Ogre :: FOG_NONE);

यहाँ हम निम्नलिखित आश्चर्य की प्रतीक्षा कर रहे हैं:

इस तरह की एक अप्रिय तस्वीर इस तथ्य का परिणाम है कि हमने तीसरे चरण में जो परिदृश्य जोड़ा, वह एक साधारण ओग्रे इकाई नहीं है , इसलिए हाइड्राक्स पानी की सतह की गणना करते समय इसे ध्यान में नहीं रखता है। इस स्थिति को ठीक करने के लिए, इलाके की सामग्री में गहराई तकनीक को जोड़ना पर्याप्त है:

void LandscapeApplication :: createScene( void ) { // ... mHydrax -> create(); mHydrax -> getMaterialManager() -> addDepthTechnique( mTerrainGroup -> getTerrain( 0 , 0 ) -> getMaterial() -> createTechnique());

परिणामस्वरूप, हमें निम्नलिखित चित्र आंख को भाते हैं:

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

इसके अलावा, पानी पर सूरज की चमक का स्थान सूरज की वास्तविक स्थिति के अनुरूप नहीं है, इसके अलावा, चमक सूर्यास्त के बाद भी बनी रहती है:

इस समस्या को हल करने के लिए, हम उपर्युक्त Ogitor संपादक से Caelum और Hydrax के एकीकरण के लिए जिम्मेदार थोड़ा संशोधित कोड का उपयोग करेंगे:

बिल्ली

// LandscapeApplication.hpp class LandscapeApplication : public BaseApplication { // ... protected : virtual bool frameEnded( const Ogre :: FrameEvent & evt); Ogre :: Vector3 mOriginalWaterColor; // LandscapeApplication.cpp void LandscapeApplication :: createScene( void ) { // ... mHydrax -> loadCfg( "HydraxDemo.hdx" ); mOriginalWaterColor = mHydrax -> getWaterColor(); // ... bool LandscapeApplication :: frameEnded( const Ogre :: FrameEvent & evt) { Vector3 value = mCaelumSystem -> getSun() -> getSceneNode() -> _getDerivedPosition(); ColourValue cval = mCaelumSystem -> getSun() -> getBodyColour(); mHydrax -> setSunPosition(value); mHydrax -> setSunColor(Vector3(cval.r,cval.g,cval.b)); Caelum :: LongReal mJulian = mCaelumSystem -> getUniversalClock() -> getJulianDay(); cval = mCaelumSystem -> getSunLightColour(mJulian, mCaelumSystem -> getSunDirection(mJulian)); mHydrax -> setWaterColor(Vector3(cval.r - 0.3 , cval.g - 0.2 , cval.b)); Vector3 col = mHydrax -> getWaterColor(); float height = mHydrax -> getSunPosition().y / 10.0f ; Hydrax :: HydraxComponent c = mHydrax -> getComponents(); if (height < 0 ) { if (mHydrax -> isComponent(Hydrax :: HYDRAX_COMPONENT_CAUSTICS)) mHydrax -> setComponents(Hydrax :: HydraxComponent( c ^ Hydrax :: HYDRAX_COMPONENT_CAUSTICS)); } else { if ( ! mHydrax -> isComponent(Hydrax :: HYDRAX_COMPONENT_CAUSTICS)) mHydrax -> setComponents(Hydrax :: HydraxComponent( c | Hydrax :: HYDRAX_COMPONENT_CAUSTICS)); } if (height < -99.0f ) { col = mOriginalWaterColor * 0.1f ; height = 9999.0f ; } else if (height < 1.0f ) { col = mOriginalWaterColor * ( 0.1f + ( 0.009f * (height + 99.0f ))); height = 100.0f / (height + 99.001f ); } else if (height < 2.0f ) { col += mOriginalWaterColor; col /= 2.0f ; float percent = (height - 1.0f ); col = (col * percent) + (mOriginalWaterColor * ( 1.0f - percent)); } else { col += mOriginalWaterColor; col /= 2.0f ; } mHydrax -> setWaterColor(col); mHydrax -> setSunArea(height); mHydrax -> update(evt.timeSinceLastFrame); return true ; }

नतीजा एक रोमांटिक सूर्यास्त और ... नई कलाकृतियों का एक जोड़ा:

सबसे पहले, जब कैमरा क्षितिज पर चलता है, तो लंबी सफेद धारियां दिखाई देती हैं या गायब हो जाती हैं। ऐसा इसलिए होता है क्योंकि पानी की सतह काफी दूर की दूरी पर दूर कतरन वाले विमान ( दूर की कतरन वाले विमान ) के साथ मिलती है, जो दृश्य कलाकृतियों को उत्पन्न करता है। इस समस्या का हल कहीं सरल नहीं है, बस इस विमान की दूरी बढ़ाएँ:

mCamera -> setFarClipDistance( 1000000 );

दूसरे, सूरज का निचला हिस्सा, पानी के नीचे "चला गया", जो बिल्कुल भी दिखाई नहीं देना चाहिए, इसमें सफेद किनारे हैं जो हड़ताली हैं। इस समस्या की जड़ परिदृश्य समस्या के समान है: सूर्य (और चंद्रमा) साधारण ओग्रे वस्तु नहीं हैं; इसे ठीक करने के लिए, आपको इन वस्तुओं की सामग्री में गहराई तकनीक को जोड़ने की आवश्यकता है। इसके लिए सबसे अच्छी जगह है मीडिया / Caelum निर्देशिका में Sun.material और Moon.material फ़ाइलें; आपको इन फ़ाइलों में वर्णित प्रत्येक सामग्री में निम्न अनुच्छेद जोड़ना होगा:

technique HydraxDepth { scheme HydraxDepth pass { lighting off texture_unit { colour_op_ex modulate src_manual src_current 0 0 0 } } }

सभी आवश्यक सुधारों के साथ media_fixed.zip संग्रह यहाँ डाउनलोड किया जा सकता है । उनके साथ आवेदन शुरू करने के बाद, सब कुछ ठीक हो जाता है:

चरण पाँच: वनस्पति

अंतिम स्पर्श हमारे आरामदायक परिदृश्य में कुछ वनस्पतियों को जोड़ना है। Ogre Paged ज्योमेट्री इंजन लाइब्रेरी इसके लिए सबसे उपयुक्त है, क्योंकि यह आपको बड़ी दूरी पर बड़ी मात्रा में छोटी जालियों को प्रस्तुत करने की अनुमति देता है, जो विशेष रूप से इमारत के लिए मूल्यवान है, उदाहरण के लिए, पेड़ों, झाड़ियों, घास, पत्थरों, और इसी तरह के साथ एक वन दृश्य और आगे। यह पुस्तकालय मुफ्त लाइसेंस के बीच सबसे उदार में से एक के तहत वितरित किया जाता है - एमआईटी (और साथ ही ओग्रे)।
पृष्ठांकित ज्यामिति के नवीनतम संस्करण को इस पते पर डाउनलोड किया जा सकता है, फिर से मैंने परीक्षण परियोजना के स्रोत पेड़ में सभी आवश्यक फ़ाइलों की प्रतिलिपि बनाई। पुस्तकालय CMake का समर्थन करता है, इसलिए हमारे CMakeLists.txt में आपको केवल कुछ पंक्तियाँ जोड़ने की आवश्यकता है: शीर्ष लेख फ़ाइलों का स्थान, लाइब्रेरी फ़ाइल का स्थान और स्वयं पुस्तकालय स्रोत का स्थान:

include_directories ( # ... "PagedGeometry/include" "${CMAKE_BINARY_DIR}/PagedGeometry/include" # ... add_subdirectory ( PagedGeometry ) # ... target_link_libraries ( LandscapeApp ${ OGRE_LIBRARIES } ${ OGRE_Terrain_LIBRARIES } ${ OIS_LIBRARIES } Caelum Hydrax PagedGeometry )

इसके अलावा, हमारे आवेदन में, हम तीन प्रकार की वस्तुओं को जोड़ने के लिए खुद को प्रतिबंधित करते हैं:

घास;
पेड़;
अन्य वनस्पति (झाड़ियों, फूल और मशरूम)।

ऐसा करने के लिए, हमारे मुख्य वर्ग में कुंजी वर्ग Forests::PagedGeometry उदाहरणों में Forests::PagedGeometry (और सहायक Forests::GrassLoader ) को Forests::GrassLoader , इसके लिए आवश्यक फाइलें न Forests::GrassLoader :

#include <PagedGeometry.h> #include <GrassLoader.h> class LandscapeApplication : public BaseApplication { // ... protected : // ... Forests :: PagedGeometry * grass, * trees, * bushes; Forests :: GrassLoader * grassLoader; };

फिर LandscapeApplication कंस्ट्रक्टर को बदलकर शून्य के साथ इन पॉइंटर्स को इनिशियलाइज़ करें:

LandscapeApplication :: LandscapeApplication( void ) : grass( NULL ), trees( NULL ), bushes( NULL ) { }

इसके अलावा, हमें एक फ़ंक्शन की आवश्यकता है जो दिए गए निर्देशांक x और z के साथ एक बिंदु पर परिदृश्य की ऊंचाई लौटाता है; इस फ़ंक्शन को लागू करने से, Paged Geometry अपने सभी प्रॉप्स को जमीन पर सही ढंग से व्यवस्थित करेगा। यह वह फ़ंक्शन होगा जिसकी आवश्यकता है, न कि क्लास विधि, क्योंकि पॉइंटर this स्पष्ट रूप से क्लास के तरीकों से पारित किया जाता है, जो लाइब्रेरी से बस प्राप्त करने के लिए कहीं नहीं होगा। इसलिए, हमें एक वैश्विक चर की आवश्यकता है - एक वर्ग के लिए एक संकेतक जो परिदृश्य स्वयं और हमारे कार्य के बीच संबंध के लिए परिदृश्य पृष्ठों के एक समूह का प्रबंधन करता है। खैर, हमें अपनी योजना का एहसास है:

static TerrainGroup * terrainGroup = NULL ; static float getTerrainHeight( float x, float z, void * userData) { OgreAssert(terrainGroup, "Terrain isn't initialized" ); return terrainGroup -> getHeightAtWorldPosition(x, 0 , z); }

चूंकि यह चर शुरू में NULL , इसे TerrainGroup वर्ग के उदाहरण के लिए एक सूचक के साथ आरंभीकृत किया जाना चाहिए, जिसे हम createScene विधि में लैंडस्केप आरंभीकरण कोड के बाद अगली पंक्ति बना देंगे:

terrainGroup = mTerrainGroup;

अंत में, अब आप उन सभी वस्तुओं के लिए इनिशियलाइज़ेशन कोड जोड़ सकते हैं जिनकी हमें createScene पद्धति में आवश्यकता है:

कोड

// grass = new PagedGeometry(mCamera); grass -> addDetailLevel < GrassPage > ( 160 ); // : 60 grassLoader = new GrassLoader(grass); grass -> setPageLoader(grassLoader); grassLoader -> setHeightFunction(getTerrainHeight); // , GrassLayer * l = grassLoader -> addLayer( "3D-Diggers/plant1sprite" ); // l -> setMinimumSize( 0.9f , 0.9f ); // ... l -> setMaximumSize( 2 , 2 ); // ... l -> setAnimationEnabled( true ); // l -> setSwayDistribution( 7.0f ); // l -> setSwayLength( 0.1f ); // - 0.1 l -> setSwaySpeed( 0.4f ); // l -> setDensity( 3.0f ); // l -> setRenderTechnique(GRASSTECH_SPRITE); // l -> setFadeTechnique(FADETECH_GROW); // l -> setColorMap( "terrain_texture2.jpg" ); // l -> setDensityMap( "densitymap.png" ); // l -> setMapBounds(TBounds( 0 , 0 , 3000 , 3000 )); // // trees = new PagedGeometry(mCamera); trees -> addDetailLevel < WindBatchPage > ( 150 , 30 ); // 150 180 trees -> addDetailLevel < ImpostorPage > ( 900 , 50 ); // 900 950 TreeLoader2D * treeLoader = new TreeLoader2D(trees, TBounds( 0 , 0 , 5000 , 5000 )); trees -> setPageLoader(treeLoader); treeLoader -> setHeightFunction(getTerrainHeight); // , treeLoader -> setColorMap( "terrain_lightmap.jpg" ); // Entity * tree1 = mSceneMgr -> createEntity( "Tree1" , "fir05_30.mesh" ); // Entity * tree2 = mSceneMgr -> createEntity( "Tree2" , "fir14_25.mesh" ); trees -> setCustomParam(tree1 -> getName(), "windFactorX" , 15 ); // trees -> setCustomParam(tree1 -> getName(), "windFactorY" , 0.01f ); trees -> setCustomParam(tree2 -> getName(), "windFactorX" , 22 ); trees -> setCustomParam(tree2 -> getName(), "windFactorY" , 0.013f ); // 5000 Vector3 position = Vector3 :: ZERO; Radian yaw; Real scale; for ( int i = 0 ; i < 5000 ; i ++ ) { yaw = Degree(Math :: RangeRandom( 0 , 360 )); position.x = Math :: RangeRandom( 0 , 2000 ); // Y , .. position.z = Math :: RangeRandom( 2300 , 4000 ); // - getTerrainHeight, scale = Math :: RangeRandom( 0.07f , 0.12f ); if (Math :: UnitRandom() < 0.5f ) { if (Math :: UnitRandom() < 0.5f ) treeLoader -> addTree(tree1, position, yaw, scale); } else treeLoader -> addTree(tree2, position, yaw, scale); } // / bushes = new PagedGeometry(mCamera); bushes -> addDetailLevel < WindBatchPage > ( 80 , 50 ); TreeLoader2D * bushLoader = new TreeLoader2D(bushes, TBounds( 0 , 0 , 5000 , 5000 )); bushes -> setPageLoader(bushLoader); bushLoader -> setHeightFunction(getTerrainHeight); bushLoader -> setColorMap( "terrain_lightmap.jpg" ); Entity * fern = mSceneMgr -> createEntity( "Fern" , "farn1.mesh" ); // Entity * plant = mSceneMgr -> createEntity( "Plant" , "plant2.mesh" ); // Entity * mushroom = mSceneMgr -> createEntity( "Mushroom" , "shroom1_1.mesh" ); // bushes -> setCustomParam(fern -> getName(), "factorX" , 1 ); // bushes -> setCustomParam(fern -> getName(), "factorY" , 0.01f ); bushes -> setCustomParam(plant -> getName(), "factorX" , 0.6f ); bushes -> setCustomParam(plant -> getName(), "factorY" , 0.02f ); // 20000 for ( int i = 0 ; i < 20000 ; i ++ ) { yaw = Degree(Math :: RangeRandom( 0 , 360 )); position.x = Math :: RangeRandom( 0 , 2000 ); position.z = Math :: RangeRandom( 2300 , 4000 ); if (Math :: UnitRandom() < 0.8f ) { scale = Math :: RangeRandom( 0.3f , 0.4f ); bushLoader -> addTree(fern, position, yaw, scale); } else if (Math :: UnitRandom() < 0.9 ) { scale = Math :: RangeRandom( 0.2f , 0.6f ); bushLoader -> addTree(mushroom, position, yaw, scale); } else { scale = Math :: RangeRandom( 0.3f , 0.5f ); bushLoader -> addTree(plant, position, yaw, scale); } }

... और LandscapeApplication डिस्ट्रक्टर को अंतिम रूप देने का कोड:

अंतिम रूप देने का कोड

LandscapeApplication ::~ LandscapeApplication( void ) { if (grass) { delete grass -> getPageLoader(); delete grass; grass = NULL ; } if (trees) { delete trees -> getPageLoader(); delete trees; trees = NULL ; } if (bushes) { delete bushes -> getPageLoader(); delete bushes; bushes = NULL ; } mSceneMgr -> destroyEntity( "Tree1" ); mSceneMgr -> destroyEntity( "Tree2" ); mSceneMgr -> destroyEntity( "Fern" ); mSceneMgr -> destroyEntity( "Plant" ); mSceneMgr -> destroyEntity( "Mushroom" ); }

(इस कोड के बिना, एप्लिकेशन निकास पर एक त्रुटि के साथ दुर्घटनाग्रस्त हो जाएगा)।
खैर, और सबसे महत्वपूर्ण बात - Forests::PagedGeometry उदाहरणों के लिए Forests::PagedGeometry , प्रत्येक फ्रेम को update() विधि को कॉल करने की आवश्यकता होती है ताकि हमारा जंगल एक आभासी हवा के झोंके के तहत आसानी से Forests::PagedGeometry :

bool LandscapeApplication :: frameEnded( const Ogre :: FrameEvent & evt) { // ... grass -> update(); trees -> update(); bushes -> update(); return true ; }

एप्लिकेशन लॉन्च करके, हम देहाती वन परिदृश्य का निरीक्षण कर सकते हैं:

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

पूरी तरह से संकलित और परीक्षण परियोजना चलाने के लिए तैयार यहां डाउनलोड किया जा सकता है ।

इस जगह पर पढ़ने वाले सभी के लिए आभार - एक जोड़े को और अधिक अच्छे स्क्रीनशॉट:

और वीडियो (यह मेरे द्वारा नहीं बनाया गया था, लेकिन यह प्रश्न में पुस्तकालयों का उपयोग करके बनाया गया था - ओग्रे, हाइड्रैक्स और सीलम):

मैं ओग्रे इंजन के साथ काम करने में मदद के लिए आर्टी एंड्री इंजन 9 और उत्कृष्ट सिंटैक्स हाइलाइटिंग के लिए काम करने के लिए मदद के लिए हब्रायुज़र सर्गेई विरुएससीडी के लिए अपना आभार व्यक्त करना चाहता हूं।

UPD : स्क्रीनशॉट को एंटी-अलियासिंग सक्षम के साथ रिटेन किया, टिप्पणी के लिए धन्यवाद m1el ।

ओगरे 3 डी में यथार्थवादी परिदृश्य

एक कदम: आवेदन कंकाल

चरण दो: स्वर्ग

चरण तीन: पृथ्वी

चरण चार: पानी

चरण पाँच: वनस्पति

More articles: