[Pillola] Come creare un gioco 3D
COME CREARE UN PLATFORM 3D IN C++
parte 1
Introduzione
Seguendo queste lezioni imparerete a programmare un livello di un possibile gioco di piattaforme 3D usando solo strumenti freeware, perciò gratuiti e facilmente reperibili dalla rete.
Oltre il compilatore Dev-C++ e al motore grafico Irrlitch useremo una libreria fatta da me con una serie di comandi e funzioni molto utili che semplificano il lavoro con Irrlitch.
Ho creato questi files per rendere la guida adatta anche a chi si vuole cimentare nello sviluppo di una applicazione 3D per la prima volta, gli utenti più smaliziati potranno comunque guardare e modificare il codice della libreria a loro piacimento visto che è un prodotto che fornisco in modo Open Source.
La guida, anche se di una difficoltà di apprendimento di certo non bassissima è inoltre scritta anche per chi non ha mai programmato in vita sua, troverete perciò anche le basi del linguaggio C e nozioni sull'utilizzo del compilatore. Questo perchè non voglio rivolgermi solo ai più esperti ma miro a coinvolgere tutti coloro che volessero imparare senza dover prima studiare un voluminoso manuale.
Bene, cosa serve per iniziare?
Compilatore: Dev-C++
Motore Grafico: Irrlitch 0.5
Files Aggiuntivi: Libreria Eclipse e platform3d_pack
Inoltre consiglio caldamente di seguire la mia guida su come importare e modificare un modello 3d con Milkshape quando vorrete inserire dei vostri modelli nel gioco. ( eccola qui )
Primo passo, un progetto con Irrlicht
Dopo aver scaricato la libreria e aver installato Dev-C++ e Irrlitch creiamo una cartella con nome “platform3d” sul disco e copiamoci dentro il contenuto del file eclipse_lib.zip, cioè i files eclipse.h e eclipse.cpp, il contenuto del file “platform3d_pack.zip” che non è che altri due files zippati (copiateli e lasciateli zippati) e il file Irrlicht.dll che trovate dentro “C:\irrlitch0.5\bin\DevCpp”, sempre se avete decompattato irrlitch su “C:”.
Fatto ciò avviamo Dev-C++, clicchiamo su “File>Nuovo>Progetto”. Selezioniamo “Console Application” e come Nome Progetto mettiamo “Platform3D”, nella schermata successiva andiamo alla cartella che abbiamo precedentemente creato e salviamo il file Platform3D.dev.
Passiamo ora alla configurazione del progetto, clicchiamo su “Progetto> Opzioni del Progetto” e rechiamoci alla sezione “Files/Cartelle”: su “Cartelle librerie” facciamo clic sul pulsante [...] andiamo fino alla cartella “Lib” di Irrlitch e poi alla sottocartella “Dev-Cpp” come da figura.
http://www.playerworld.it/projects/immagini/irr1.jpg
Confermiamo con OK e poi con Aggiungi, poi andiamo su “Cartelle Include” e rifacciamo lo stesso scegliendo però la sottocartella “include” da quella di Irrlitch.
Fatto ciò non dimentichiamoci di cliccare su “Aggiungi”!
Restando sempre dentro le Opzioni del Progetto spostiamoci adesso su “Parametri”, qui nel campo chiamato “Linker” inseriamo queste tre righe:
C:\irrlicht0.5\lib\DevCpp\libIrrlicht.a
C:\irrlicht0.5\lib\DevCpp\libjpeg.a
C:\irrlicht0.5\lib\DevCpp\libz.a
Se avete installato Irrlitch in una cartella diversa da “C:\irrlicht0.5\” modificate il persorso inserendo la vostra cartella.
Completate premendo OK e tornando al programma.
Ora nello spazio chiamato “Progetto” cliccate con il pulsante destro su “Platform3D” e andate dal menù alla voce “Aggiungi al Progetto”, selezionate i files eclipse.cpp e eclipse.h e cliccate su “Apri” per includerli nel progetto eeeeee finalmente abbiamo concluso questa prima pallossissima parte della guida! (O almeno lo spero per voi perchè se avete sbagliato qualcosa vi tocca rifare tutto da principio).
http://www.playerworld.it/projects/immagini/irr2.jpg
E ora, si programma!!
Passiamo ora alla pagina che conterrà il codice, cioè main.cpp, cancelliamo quello che troviamo (sono righe che crea in automatico il Dev-C++) e scriviamo questo:
Citazione:
#include <irrlicht.h>
#include <wchar.h>
#include <windows.h>
using namespace irr;
#pragma comment(lib, <Irrlicht.lib>)
#include "eclipse.h"
//==================================//
//Globali
IrrlichtDevice *device;
scene::ISceneManager* smgr;
video::IVideoDriver* driver;
scene::ICameraSceneNode* camera=0;
//==================================//
//==================================//
int main(){
//funzioni "figlio" di Main
void carica_mappa();
//carica engine
device = createDevice(video::EDT_OPENGL , core::dimension2d<s32>(750, 550),16, false, false, NULL);
driver = device->getVideoDriver();
PW_debug_driver(driver);
smgr = device->getSceneManager();
//decomprimi files
device->getFileSystem()->addZipFileArchive("world.zip");
device->getFileSystem()->addZipFileArchive("models.zip");
//chiamata alla funzione carica_mappa
carica_mappa();
//LOOP PRINCIPALE
while(device->run()){
driver->beginScene(true, true, video::SColor(255,90,90,156));
/*qui andranno i comandi del gioco*/
smgr->drawAll();
driver->endScene();
}//fine loop
device->drop();
return 0;
} //fine programma
//==================================//
//==================================//
void carica_mappa(){
//crea telecamera
camera= smgr->addCameraSceneNode();
//carica ambiente 3d
scene::ISceneNode* mappa=PW_carica_mappa(smgr, "stadium.3ds");
mappa->setMaterialFlag(video::EMF_LIGHTING, false);
}
//==================================//
Come vedete useremo dei commenti come questi “//====//” per dividere in parti il codice e rendere tutto più ordinato.
Il compilatore salta tutte le righe che iniziano con “//” e tutte le parti che iniziamo con “/*” e finiscono per “*/”, perciò potete anche lasciare i commenti che metto sul codice e metterne di nuovi se volete.
Cominciamo ad analizzare quello che abbiamo scritto. Le righe sopra le Globali caricano librerie e files vari inoltre “using namespace irr;” ci permetterà di usare i comandi di Irrlicht.
Su Globali abbiamo definito tre variabili che userà l'engine 3d rispettivamente per avviare il motore, selezionare i driver video e gestire la scena e una variabile “camera” che useremo per comandare la telecamera virtuale nell'ambiente.
Sulla nostra funzione principale, main( ), abbiamo definito una sottofunzione chiamata “carica_mappa” che vedremo più sotto, seguendo il codice abbiamo caricato l'engine in modalità Open GL (La versione di Irrlitch.dll per Dev-C++ non funziona in Direct3D, che potremo usare solo con Visual C++) con una risoluzione di 800x600 pixels e 32 bit di colore, poi abbiamo caricato i drivers video, la gestione della scena e tramite il comando addZipFileArchive abbiamo inserito nel gioco il contenuto dei due files zip.
Successivamente troviamo la chiamata alla funzione “carica_mappa”, arrivato qui il programma smette di leggere da main e si sposta appunto dentro carica_mappa (legge cioè i comandi che si trovano tra le parentesi graffe dopo la riga “void carica_mappa(){“).
Tramite questa funzione creiamo la telecamera che inquadrerà la scena e carichiamo la mappa stadium.3ds (che si trova dentro world.zip!!!).
L'istruzione PW_carica_mappa è un comando della mia libreria, tutti i comandi che avranno la scritta “PW” d'avanti sono comandi della libreria, i comandi di irrlicht sono invece più complessi e usano un sistema gerarchico del tipo “sezione->comando” dove come “sezione” del motore potrete usare variabili come smgr, device o anche un oggetto 3d come accade con “mappa->setMaterialFlag(video::EMF_LIGHTING, false);” e come comando uno dei tanti che il motore offre.
Nella guida non tratteremo tutti i comandi di Irrlitch, anche se useremo sicuramente tutti quelli di base, con l'engine avete comunque scaricato anche un file di Help, che si trova nella cartella “Doc”, dove potrete studiarli.
Finite le istruzioni dentro carica_mappa il programma torna a leggere dentro main e precisamente tutto ciò che aveva lasciato sotto la riga “carica_mappa();”, a chi programma per la prima volta potrà sembrare inutile l'uso di questa funzione, per ottenere lo stesso risultato basta infatti scrivere le righe che ci sono dentro carica_mappa al posto della chiamata alla funzione dentro main, quando però il codice diventerà più lungo benediremo il fatto di aver usato tante funzioni.
Tornando al nostro codice dopo aver caricato la mappa si entra nel LOOP PRINCIPALE, il cuore del nostro futuro gioco.
Il loop principale non è altro che un ciclo “while” che ripete i comandi al suo interno finchè il motore 3d è in azione cioè finchè “device->run()” è vero.
Per adesso dentro al loop abbiamo soltanto le istruzioni che servono a creare la scena che vede la telecamera virtuale in memoria e a disegnarla sullo schermo, una volta disegnata si torna indietro all'inizio del while e si ridisegna tutto, così fino alla fine del nostro gioco.
L'unico modo di uscire dal Loop è infatti premere ALT+F4 o cliccare sulla X nella finestra del gioco, quando l'utente farà questo il comando device->drop(); pulirà la memoria dalle tracce del gioco e la riga seguente ritornerà 0 e chiuderà la funzione main e con essa il programma.
Se compiliamo e avviamo il nostro lavoro premendo F9 vedremo una strana stanza (è fatta malissimo ma serve solo da esempio!) molto illuminata e basta.
Non potrete muovere la visuale o fare altro, avete comunque buttato le basi per un programma con Irrlitch. Vi consiglio magari di conservare tutta la cartella platform3d, magari zippandola, in modo da disporre in futuro di un progetto già configurato e un codice di base da usare per tutti i giochi che farete.
Inseriamo un personaggio 3d
Vedremo adesso come caricare un modello animato e come comandarlo tramite la tastiera.
Per prima inseriamo la dichiarazione della variabile che useremo per il personaggio su Globali.
[quote]scene::IAnimatedMeshSceneNode* rigell=0;[\quote]
Adesso cosa creiamo un'altra funzione che chiameremo carica_modelli, inseriamo perciò la riga “void carica_modelli();” sotto “void carica_mappa();” e mettiamo poi la chiamata “carica_modelli();” sotto “carica_mappa();”.
Fatto ciò posizioniamoci alla fine del file, premiamo Invio per fare un po' di spazio e scriviamo questo:
Citazione:
//==================================//
void carica_modelli(){
//Rigell: personaggio principale
rigell= smgr->addAnimatedMeshSceneNode(smgr->getMesh("rigell.ms3d"));
rigell->setMaterialTexture(0, driver->getTexture("rigell.bmp"));
PW_setta_animazione_ms3d(rigell,0,32,94);
rigell->setAnimationSpeed(1000);
rigell->setMaterialFlag(video::EMF_LIGHTING, false);
rigell->setPosition(core::vector3df(0,0,100));
rigell->setRotation(core::vector3df(0,90,0));
}
//==================================//
Avviando il gioco vedremo Rigell nella stanza, a mezz'aria di fronte a noi.
http://www.playerworld.it/projects/immagini/irr3.jpg
Il comando addAnimatedMeshSceneNode serve a caricare un modello 3d animato, i formati compatibili sono md2 (modelli di Quake2), 3ds (3d Studio Max) e ms3d (Milkshape 3d), rigell è salvato in quest'ultimo formato.
Tramite la riga rigell->setMaterialTexture(0, driver->getTexture("rigell.bmp")); impostiamo al personaggio la texture rigell.bmp, il numero 0 è il numero del materiale che mettiamo, i modelli possono infatti avere più di una texture.
PW_setta_animazione_ms3d(rigell,0,32,94); è un comando che ho creato io al posto di “setFrameLoop” di Irrlich, avevo infatti notato un difetto sul comando fornito dal motore che non mi permetteva di mettere i frames reali del file ma agiva inserendo i millisecondi dell'animazione, inoltre per i primi frames il modello si bloccava e assumeva una strana forma.
Tramite il mio comando potete invece inserire direttamente il numero di inizio e quello di fine dell'animazione che avete creato tramite Milkshape 3D 1.6.6.
“0” è qui il numero iniziale dell'animazione che fa respirare Rigell, 32 è quello finale e 94 sono i frames totali che ha il modello (per vedere quanti frames ha un modello ms3d basta aprirlo con Milkshape).
Le righe
rigell->setPosition(core::vector3df(0,0,100));
rigell->setRotation(core::vector3df(0,90,0));
impostano la posizione e la rotazione del personaggio. Normalmente appena caricato un modello 3d esso appare alle coordinate “0,0,0” cioè l'origine degli assi 3d X,Y,Z dell'ambiente, per vedere Rigell di fronte la telecamera l'abbiamo perciò mosso in avanti di 100 punti lungo l'asse Z e ruotato poi di 90 gradi lungo l'asse Y in modo da vederlo in faccia.
Provate pure a modificare i valori presenti in queste righe per far pratica con le coordinate degli oggetti.
core::vector3df è un tipo di variabile, più precisamente un vettore 3d che contiene i valori di posizione o rotazione, possiamo creare un vettore scrivendo
core::vector3df nomevettore(x,y,z);
dove nomevettore sarà il nome e x,y e z i tre valori di posizione o rotazione. Questo servirà per memorizzare la posizione di un oggetto quando ci servirà o per impostarne una nuova scrivendo rigell->setRotation(nomevettore); invece delle coordinate.
Ho inserito queste due righe solo per farvi conoscere questi comandi, potete lasciarle o cancellarle, se le eliminate il personaggio verrà creato nella stessa pozione dove abbiamo la telecamera, cioè l'origine della mappa.
Andiamo adesso dentro il Loop principale, dove si trova il commento /*qui andranno i comandi del gioco*/ e inseriamo queste righe che ci permetteranno di muovere il personaggio.
Citazione:
//comandi tastiera
int anim=0;
if (GetAsyncKeyState(VK_UP)) {PW_Muovi_Oggetto(rigell,6); anim=1;}
if (GetAsyncKeyState(VK_DOWN)) {PW_Muovi_Oggetto(rigell,-6); anim=1;}
if (GetAsyncKeyState(VK_LEFT)) {PW_Ruota_Oggetto_Y(rigell,-3);anim=1;}
if (GetAsyncKeyState(VK_RIGHT)){PW_Ruota_Oggetto_Y(rigell,3); anim=1;}
GetAsyncKeyState è un comando della libreria windows.h, VK_UP, VK_DOWN ecc sono i tasti cursore (quelli con stampata una freccia per intenderci), quando vorrete usarne altri tasti dovrete o scrivere i nomi assegnati ai singoli tasti o il loro codice ascii, le lettere non hanno nomi e dovrete perciò usare il codice ascii invece di “VK_”.
(per Invio potete ad esempio scrivere sia VK_RETURN sia 0x0D che è il codice ASCII).
Ho copiato il codice delle definizioni dei tasti dalla libreria in un file di testo per renderne più semplice l'utilizzo. Potete scaricare l'elenco da QUI.
PW_muovi_oggetto serve a far muovere l'oggetto avanti o indietro, come velocità di movimento ho messo 6 mentre quella di rotazione l'ho settata a 3 usando il comando PW_Ruota_Oggetto_Y che ruoterà Rigell in base all'asse Y verso destra o sinistra.
La variabile “anim” non serve ancora a nulla ma sarà fondamentale per dire a una funzione che creeremo di cambiare l'animazione di Rigell quando premiamo un tasto.
Di norma anim è infatti uguale a 0, se si preme un tasto durante il gioco però diventa 1.
sarà perciò uguale a 0 quando il personaggio starà fermo e 1 quando camminerà.
Insieme alle funzioni void carica_mappa(); e void carica_modelli(); aggiungiamo
void animazione_rigell(int n);
Invece di mettere la chiamata insieme alle altre però questa la scriviamo subito sotto le righe dei controlli via tastiera scrivendo
animazione_rigell(anim);
in questo modo la funzione prenderà il nostro valore “anim” e lo userà come se fosse il suo “n”.
Alla fine del file aggiungiamo la funzione animazione_rigell:
Citazione:
//==================================//
void animazione_rigell(int n){
int static last=0;
if (last!=n){ last=n;
//fermo
if (n==0)
PW_setta_animazione_ms3d(rigell,0,32,94);
rigell->setAnimationSpeed(600);
//cammina
if (n==1)
PW_setta_animazione_ms3d(rigell,34,55,94);
rigell->setAnimationSpeed(1000);
}
}//fine animazione
//==================================//
Dentro la variabile “last” sarà memorizzato l'ultimo valore di anim ricevuto, se il valore cambia anche l'animazione cambierà in base al valore fornito da “n” che non è altro che “anim”.
Avviamo il gioco, adesso il personaggio si muove ma continua a svolazzare in aria, inoltre la telecamera non segue i suoi movimenti e non ci sono le collisioni con i muri della stanza.
Per prima cosa aggiungiamo il comando
Citazione:
PW_collisione(rigell);
dentro la funzione “carica_modello()”, dopo ovviamente le righe che caricano il file ms3d!
Poi per far seguire Rigell dalla telecamera mettiamo, sempre dentro al Loop Principale, queste righe:
Citazione:
//posiziona camera
PW_Lega_Camera_a_Oggetto(camera,rigell,100);
core::vector3df camcord=camera->getPosition();
camcord.Y+=60;
camera->setPosition(camcord);
PW_gestione_gravita(rigell, 4);
il primo comando ci permette di far seguire i movimenti di rigell dalla telecamera, 100 è la distanza che la camera terrà nei confronti del personaggio. Le righe successive alzano un po' la visuale in modo da far apparire Rigell nella parte bassa dello schermo e non al centro come accadeva prima.
Il comando “PW_gestione_gravita” farà finalmente toccare il suolo a Rigell.
Il valore “4” è la forza con cui cadrà al suolo. Non ho ancora implementato l'accellerazione perciò per ora cadrà con velocità costante.
http://www.playerworld.it/projects/immagini/irr4.jpg
E ti pareva che non funzionava al primo colpo!
dopo aver configurato tutto e scritto tutto il codice, provo a compilare il tutto e il dev
mi da l'errore alla riga
rigell=smgr->addAnimatedMeshSceneNode(smgr->getMesh("rigell.ms3d"));
nel debug mi dice:
`rigell' undeclared (first use this function)
cos'è andato storto???
risolta un problema se ne crea un altro!
Ho risolto il problema del caricamento del pg ma ora dopo la compilazione corretta ed il linking ok, mi crea l'applicaziona ma mi mostra quest'errore:
"impossibile trovare il punto di ingresso
_ZN3irr12createDeviceENS_5video11EDriverTypeERKNS_4core11d imension 2dIiEEjbbPNS_14IEventReceiverEPKw
della procedura nella libreria di collegamento dinamico Irrlicht.dll"
Re: risolta un problema se ne crea un altro!
Citazione:
Squall L.
Ho risolto il problema del caricamento del pg ma ora dopo la compilazione corretta ed il linking ok, mi crea l'applicaziona ma mi mostra quest'errore:
"impossibile trovare il punto di ingresso
_ZN3irr12createDeviceENS_5video11EDriverTypeERKNS_4core11d imension 2dIiEEjbbPNS_14IEventReceiverEPKw
della procedura nella libreria di collegamento dinamico Irrlicht.dll"
non hai inserito il file Irrlicht.dll nella cartella di gioco o hai messo un file sbagliato, devi mettere il file inerente al compilatore che usi, se usi Dev-C++ copia il file dll dalla cartella "bin\dev-cpp" se usi Visual C++ da "bin\visualcpp".
Fammi sapere!!!
ah! non trovate irrlicht 0.5 perchè hanno aggiornato l'engine alla versione 0.6, scaricate quella, è praticamente lo stesso.
