Manualul de bază 6, ogre3d

SCRIE INTRODUCERE

În acest tutorial, veți învăța cum să scrieți o aplicație simplă Ogre de la zero.

Cunoștințe necesare

Acest ghid presupune că aveți cunoștințe despre programarea C ++ și puteți instala și compila aplicația utilizând Ogre.






Acest ghid presupune, de asemenea, că ați creat proiectul utilizând Ogre Wiki Tutorial Framework sau manual folosind CMake sau Ogre AppWizard.
Acest ghid se bazează pe cele anterioare și implică faptul că ați lucrat cu aceștia.

Codul original

În acest tutorial, un cadru gol va fi punctul de plecare pentru noi.

ATENȚIE

Înainte de a continua, asigurați-vă că proiectul este configurat și că are două fișiere: antet și cpp.
Dacă ați folosit Ogre Tutorial Wiki Framework, eliminați BaseApplication.h și BaseApplication.cpp din acesta.

1. clasa BasicTutorial6
3. publice:
4. BasicTutorial6 (void);
5. virtual

1. #include "BasicTutorial6.h"
2. #include
3. // -----------------------------
4. BasicTutorial6 :: BasicTutorial6 (void)
6. >
7. // -----------------------------
8. BasicTutorial6 ::

Asigurați-vă că puteți compila acest cod înainte de a continua. Codul nu va face nimic - programul va ieși imediat după începere.

Nu vă faceți griji, după ce vom trece prin acest ghid, vom merge la aplicația full-featured Ogre.

Procesul de pornire

După ce înțelegeți că procesele sunt ascunse de ochii dvs., lucrul cu Ogre va deveni mult mai ușor. Cadrul exemplu va arăta destul de complicat, deoarece încearcă să facă multe lucruri care pot sau nu să fie necesare pentru cererea dvs., dar acest lucru este doar la prima vedere. După terminarea acestei lecții, veți putea selecta ceea ce este cu adevărat necesar pentru aplicația dvs. Înainte de a face acest lucru, vom face o scurtă trecere în revistă a modului în care funcționează procesul de pornire.

Ciclul de viață de bază al lui Ogre arată astfel:

1. Creați un obiect rădăcină (root)
2. Identificați resursele pe care le va utiliza Ogre
3. Selectați și configurați sistemul de redare (DirectX, OpenGL și așa mai departe)
4. Creați o fereastră de redare (RenderWindow) (o fereastră pe care Ogre o folosește pentru afișare)
5. Inițializați toate resursele pe care le veți utiliza
6. Creați o scenă din aceste resurse
7. Configurați toate celelalte biblioteci și plug-in-uri
8. Creați orice număr de dispozitive de tratare a cadrelor
9. Porniți ciclul de afișare

În această lecție vom trece prin fiecare element în profunzime.

Rularea Ogre

Crearea unui obiect rădăcină

Obiectul rădăcină este nucleul motorului OGRE și trebuie creat înainte de a începe să faceți ceva cu motorul.

Trebuie să adăugăm următorii membri la clasa BasicTutorial6:

1. privat:
2. Ogre :: Root * mRoot;
3. Ogre :: String mPluginsCfg;

1. bool BasicTutorial6 :: go (void)
3. #ifdef _DEBUG
4. mPluginsCfg = "plugins_d.cfg";
5. #else
6. mPluginsCfg = "plugins.cfg";
7. # endif
8. // Ogre :: Root
9. mRoot = Ogre :: Root nou (mPluginsCfg);
10. return true;
11. >

Constructorul clasei Ogre :: Root acceptă trei parametri:

pluginFileName ("plugins.cfg") - calea completă la fișierul în care sunt înregistrate toate pluginurile.
configFileName ("ogre.cfg") - cale completă la fișierul de configurare
logFileName ("Ogre.log") - calea completă la fișierul jurnal al motorului în care OGRE scrie tot ce se întâmplă în interior.

Am putea lăsa valorile implicite, ci la cererea noastră de a lucra cu pre-asamblate Ogre SDK, în cazul în care numele de fișier de configurare plug-in-ul este diferit în funcție de faptul dacă în modul de depanare (Debug) asamblate motorului sau final (Release), trebuie să trecem nostru parametru mPluginsCfg constructorului, numele fișierului de configurare va fi „plugins_d.cfg“ atunci când rulează în modul de depanare.

Continuați - ne compilați și rulați cererea noastră.
Se pare că nu se întâmplă nimic, dar dacă deschideți Ogre.log, atunci veți vedea că Ogre a început, inițializat și terminat. De asemenea, ar trebui să vedeți că a analizat pluginurile găsite și instalate listate în "plugins.cfg".

Notă: pentru dvs., această secțiune va avea mult mai multă sens dacă deschideți "resources.cfg" și căutați-o înainte de a continua. Îl puteți găsi în directorul bin / release al SDK-ului. Următorul lucru pe care trebuie să-l facem este să determinăm resursele utilizate de aplicația noastră. Pot fi texturi, modele, scripturi și altele.

În acest ghid, nu vom intra în subiectul resurselor. Pentru moment, trebuie doar să rețineți că mai întâi trebuie să determinați toate resursele pe care le veți folosi în aplicație și apoi să inițializați cele pe care Ogre le va folosi. În acest stadiu, determinăm resursele care vor fi utilizate de aplicația noastră. Pentru a face acest lucru, adăugăm fiecare director resurse către ResourceGroupManager.

Adăugați următorul membru al clasei la clasa BasicTutorial6:

Acum trebuie să adăugați OIS la setările proiectului nostru:

Include directorul $ (OGRE_HOME) / include / OIS
Biblioteca de intrare OIS_d.lib / OIS.lib

Ar trebui să fie instalat directorul cu biblioteca.
Asigurați-vă că după ce adăugați OIS la proiect, îl puteți compila.

Adăugarea OIS

OIS utilizează modulul principal InputManager, care este puțin dificil de configurat, dar dacă este creat corect, este ușor de utilizat. OIS nu se integrează în Ogre; aceasta este o bibliotecă offline, ceea ce înseamnă că va trebui să îi oferiți câteva informații la început pentru a funcționa corect. În practică, acest lucru necesită doar un mâner de fereastră în care Ogre afișează obiecte. Din fericire, va fi mult mai ușor pentru noi, deoarece am creat fereastra implicită.

Mergeți la funcția BasicTutorial6 :: go și adăugați acest cod înainte de ciclul nostru de afișare:

1. Ogre :: LogManager :: getSingletonPtr () -> logMessage ("*** Inițializarea OIS ***");
2. OIS :: ParamList pl;
3. size_t windowHnd = 0;
4. std :: fereastra stinsa;
5. mWindow-> getCustomAttribute ("WINDOW". windowHnd);
6. windowHndStr <
7. pl.insert (std :: make_pair (std :: șir ("WINDOW"), windowHndStr.str ()));
8. mInputManager = OIS :: InputManager :: createInputSystem (pl);

Aceasta configurează InputManager să folosească, dar de fapt să utilizeze OIS. Pentru a obține date de la tastatură, mouse sau joystick, va trebui să creați aceste obiecte:

1. mKeyboard = static_cast (mInputManager-> createInputObject (OIS :: OISKeyboard, false));
2. mMouse = static_cast (mInputManager-> createInputObject (OIS :: OISMouse, false));

Trecem false pentru createInputObject, pentru că vrem să nu facem mouse-ul și tastatura să fie tamponate.

Notă: Dacă doriți să utilizați de intrare tamponat (care este, veți obține un apel invers mouseMoved evenimente, mousePressed, keyReleased, și așa mai departe), atunci ar trebui să setați al doilea parametru createInputObject, cât de adevărat.

Dezactivarea OIS

OIS este un pic cam complicat pentru ao dezactiva corect. Cel mai sigur mod de a face acest lucru este să utilizați WindowEventListener.

Mai întâi, puneți această linie în lista de conexiuni (include) BasicTutorial6.h:

1. clasa BasicTutorial6. publice Ogre :: WindowEventListener

1. // Ogre :: WindowEventListener
2. fereastra virtuală voidResized (Ogre :: RenderWindow * rw);
3. fereastra virtuală vidă închisă (Ogre :: RenderWindow * rw);

Acum deschideți BasicTutorial6.cpp și adăugați următoarele:

1. // Reglați zona de tăiere a mouse-ului
2. void BasicTutorial6 :: fereastră (Ogre :: RenderWindow * rw)
4. nesemnate int latime, înălțime, adâncime;
5. int stânga, partea de sus;
6. rw-> getMetrics (lățime, înălțime, adâncime, stânga, partea de sus);
7. const OIS :: MouseState ms = mMouse-> getMouseState ();
8. ms.width = width;
9. ms.height = înălțime;
10. >
11. // Unattach OIS înainte de închiderea ferestrei (foarte important sub Linux)
12. void BasicTutorial6 :: fereastrăClosed (Ogre :: RenderWindow * rw)
14. // închideți numai pentru fereastra care a creat OIS (fereastra principală a acestor demonstrații)
15. dacă (rw == mWindow)
17. dacă (mInputManager)
19. mInputManager-> destroyInputObject (mMouse);
20. mInputManager-> destroyInputObject (mKeyboard);
21. OIS :: InputManager :: destroyInputSystem (mInputManager);
22. mInputManager = 0;
23. >
24. >
25. >

windowResized este numit ori de câte ori fereastra este redimensionată și asigură că poziția OIS a mouse-ului este sincronizată cu dimensiunea curentă a ferestrei.
windowClosed elimină OIS atunci când fereastra este închisă.

Pentru a face ca aplicația noastră să acționeze ca WindowEventListener, trebuie să le înregistrăm împreună.
Așa că adăugați următoarele linii la funcția BasicTutorial6 :: go:

1. // Setați fereastra inițială de tăiere a mouse-uluiResizată (mWindow);
2. // Înregistrați-vă ca ascultător de ferestre Ogre :: WindowEventUtilities :: addWindowEventListener (mWindow, this);

Mai este un lucru pe care trebuie să-l facem.
Găsiți modelul Destructor BasicTutorial6 și faceți următoarele:

1. // Eliminați-vă ca ascultător de ferestre
2. Ogre :: WindowEventUtilities :: removeWindowEventListener (mWindow, aceasta);
3. fereastră închisă (mWindow);
4. șterge mRoot;

Configurarea procesoarelor de cadre

Indiferent dacă utilizați o intrare tamponată sau fără buffer, fiecare cadru, trebuie să apelați metoda de captură pentru toate obiectele pe care le folosiți: tastatură, mouse sau joystick ...

Pentru o intrare fără buffer, acesta este tot ce trebuie să faceți.
Fiecare cadru, puteți apela diverse funcții ale tastaturii și mouse-ului pentru a solicita poziția acestor obiecte.

Deci, trebuie să facem ca clasa BasicTutorial6 să devină un handler de cadre.

1. clasa BasicTutorial6. publice Ogre :: WindowEventListener, public Ogre :: FrameListener

1. // Ogre :: FrameListener
2. ramă virtuală boolRenderingQueued (const Ogre :: FrameEvent evt);

Apoi, în BasicTutorial6.cpp, adăugați definiția acestei funcții:

1. bool BasicTutorial6 :: frameRenderingQueued (const Ogre :: FrameEvent EVT)
3. dacă (mWindow-> isClosed ())
4. return false;
5. // Trebuie să capturați / actualizați fiecare dispozitiv
6. mKeyboard-> captură ();
7. mMouse-> captură ();
8. dacă (mKeyboard-> isKeyDown (OIS :: KC_ESCAPE))
9. return false;
10. return true;
11. >

Sarcini finale

Înainte de a fi pregătiți să compilați și să executați aplicația, trebuie să o înregistrăm ca un handler. De asemenea, nu avem nevoie de un ciclu de redare.

Găsiți BasicTutorial6 :: mergeți și ștergeți bucla în timp.
Apoi adăugați aici:

1. mRoot-> addFrameListener (acest lucru);
2. mRoot-> startRendering ();

Prima linie de cod adaugă BasicTutorial6 la root ca manipulator de cadre, ceea ce înseamnă că clasa va primi evenimente cadru. Dacă nu înregistrăm clasa cu Ogre :: Root ca manipulator de cadre, funcția frameRenderingQueued nu va fi apelată.

A doua linie a codului pornește ciclul de redare. Nu avem nevoie de nicio prelucrare specială a buclelor, deoarece putem executa sarcinile noastre în cadrul frameRenderingQueued "frame-by-frame".

Compilați și rulați!

Ar trebui să vedeți capul proprietarului căpriorului și aplicația trebuie să se închidă când apăsați tasta "Esc".

Versiunea cacao

Un nou mod de a instala manualul actual de xcode în Mac OS X este mult mai scurt și mai ușor de înțeles.
Asigurați-vă că proiectul este construit ca și aplicația de cacao și modificați extensia de la .cpp la .mm, apoi copiați fișierele de resurse .cfg și plug-in-urile în folderul xcode.

Acum modificați următoarele:

1. #ifdef _DEBUG
2. mResourcesCfg = "resurse_d.cfg";
3. mPluginsCfg = "plugins_d.cfg";
4. #else
5. mResourcesCfg = "resurse.cfg";
6. mPluginsCfg = "plugins.cfg";
7. # endif

1. #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
2. std :: șir mResourcePath = [[[NSBundle mainBundle] resursăPath] cStringUsingEncoding: NSUTF8StringEncoding];
3. # endif
4. #ifdef _DEBUG
5. #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
6. mResourcesCfg = mResourcePath + "/resources_d.cfg";
7. mPluginsCfg = mResourcePath + "/plugins_d.cfg";
8. #else
9. mResourcesCfg = "resurse_d.cfg";
10. mPluginsCfg = "plugins_d.cfg";
11. # endif
12. #else
13. #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
14. mResourcesCfg = mResourcePath + "/resources.cfg";
15. mPluginsCfg = mResourcePath + "/plugins.cfg";
16. #else
17. mResourcesCfg = "resurse.cfg";
18. mPluginsCfg = "plugins.cfg";
19. # endif

Carbon version

Deoarece Mac OS X folosește pachete de aplicații, conceptul este radical diferit de cel pe care îl folosim pentru Windows și Linux. Codul descris mai sus (mai mare decât secțiunea anterioară) nu se va difuza pe Mac OS X.

Adăugați următoarea funcție:

În createRoot (), schimbați:

Trimiteți-le prietenilor: