Spacesimulator.net - Space Simulator Project - OpenGL Tutorials

INTRODUZIONE

Original Author: Damiano Vitulli

Translation by: Click here

Dopo tanta attesa è giunta l'ora di dire addio al nostro amato cubo! In questa lezione svilupperemo una routine per il caricamento di modelli in formato 3ds, molto diffuso sulla rete e supportato da vari programmi di modellazione 3d. Questo tipo di programmi permette di creare qualunque tipo di oggetto in una modalità molto più intuitiva piuttosto che definire a mano le coordinete dei vertici, cosa impensabile per oggetti appena più complessi di un cubo.

A dire la verità un pò mi dispiace abbandonare il cubo, una figura così semplice e perfetta ma le astronavi, i pianeti, i missili e tutti gli oggetti facenti parte di una simulazione spaziale hanno forme completamente differenti da un cubo!

Prima di cominciare a scrivere codice è necessario analizzare la struttura di un file 3DS. Ok, prendetevi una bella camomilla e preparatevi...

LA STRUTTURA DI UN FILE 3DS

Un file 3ds contiene una serie di informazioni utili per descrivere ogni dettaglio una scena 3d composta da uno o più oggetti. Internamente un file 3ds è costituito da una serie di pacchetti di informazioni chiamati Chunks. Cosa è contenuto in questi pacchetti? Tutto ciò che serve per descrivere la scena, per ciascun oggetto infatti è memorizzato il nome, le coordinate dei vertici, le coordinate per il texture mapping, la lista dei poligoni, i colori delle facce, i movimenti per l'animazione e così via...

I chunks non hanno una struttura lineare, ciò significa che alcuni sono strettamente dipendenti da altri e quindi possono essere letti solo se viene letto anche i chunk che li contiene. Ovviamente non sarà assolutamente necessario leggere tutti i chunks, noi prenderemo in considerazione solo i più importanti.

Per descrivere il formato 3DS mi baserò sul file 3dsinfo.txt di Jochen Wilhelmy nel quale viene spiegata in dettaglio la struttura di un file 3ds con tutti i suoi i chunks.

Un chunk è formato da 4 campi principali:

Identificativo: un numero esadecimale di due byte di lunghezza. Tramite questa informazione possiamo capire subito se il chunk che stiamo leggendo ci interessa o meno. Nel primo caso andiamo ad estrapolare le informazioni contenute in esso e nei suoi figli, nel secondo caso lo saltiamo utilizzando l'informazione seguente:
Lunghezza del chunk: un numero di 4 byte, che rappresenta la lunghezza del chunk e di tutti i sub-chunks contenuti
Dati del chunk: questo campo ha lunghezza variabile. In esso sono contenuti i dati veri e propri del chunk.

Riassumiamo in questa tabella la struttura di un chunk:

Offset	Length	Description
0	2	Chunk identifier
2	4	Chunk length: chunk data + sub-chunks(6+n+m)
6	n	Data
6+n	m	Sub-chunks

Dall'ultima riga possiamo facilmente intuire come sia possibile rendere dipendenti alcuni chunks rispetto ad altri: ciascun chunk figlio è infatti contenuto all'interno del campo Sub-Chunks del padre.

Ecco a voi i chunks più importanti in un file 3ds, vi prego di notare la gerarchia tra i vari elementi:

MAIN CHUNK 0x4D4D
   3D EDITOR CHUNK 0x3D3D
      OBJECT BLOCK 0x4000
         TRIANGULAR MESH 0x4100
            VERTICES LIST 0x4110
            FACES DESCRIPTION 0x4120
               FACES MATERIAL 0x4130
            MAPPING COORDINATES LIST 0x4140
               SMOOTHING GROUP LIST 0x4150
            LOCAL COORDINATES SYSTEM 0x4160
         LIGHT 0x4600
            SPOTLIGHT 0x4610
         CAMERA 0x4700
      MATERIAL BLOCK 0xAFFF
         MATERIAL NAME 0xA000
         AMBIENT COLOR 0xA010
         DIFFUSE COLOR 0xA020
         SPECULAR COLOR 0xA030
         TEXTURE MAP 1 0xA200
         BUMP MAP 0xA230
         REFLECTION MAP 0xA220
         [SUB CHUNKS FOR EACH MAP]
            MAPPING FILENAME 0xA300
            MAPPING PARAMETERS 0xA351
      KEYFRAMER CHUNK 0xB000
         MESH INFORMATION BLOCK 0xB002
         SPOT LIGHT INFORMATION BLOCK 0xB007
         FRAMES (START AND END) 0xB008
            OBJECT NAME 0xB010
            OBJECT PIVOT POINT 0xB013
            POSITION TRACK 0xB020
            ROTATION TRACK 0xB021
            SCALE TRACK 0xB022
            HIERARCHY POSITION 0xB030

Come menzionato prima, se vogliamo leggere un particolare chunk dobbiamo necessariamente leggere il suo chunk padre. Facciamo un esempio pratico: immaginiamoci come una piccola formica che si trova sul terreno ed intende raggiungere una specifica foglia sul ramo di un albero. La foglia sarà il chunk da noi cercato mentre il tronco dell'albero il MAIN CHUNK, con tutti i rami come suoi Sub Chunks. Supponiamo che tale foglia da raggiungere sia il chunk VERTICES LIST. Per raggiungere questo chunk dobbiamo arrampicarci sull'albero e passare necessariamente per i rami: 3D EDITOR CHUNK, OBJECT BLOCK ed infine TRIANGULAR MESH. I restanti chunks possono essere tranquillamente saltati.

Ora potiamo di nuovo il nostro albero e lasciamo solamente i rami che contengono le informazioni: Vertici, Facce, Coordinate di mappatura ed i loro relativi padri, che sono quelle che andremo ad usare in questo tutorial.

MAIN CHUNK 0x4D4D
   3D EDITOR CHUNK 0x3D3D
      OBJECT BLOCK 0x4000
         TRIANGULAR MESH 0x4100
            VERTICES LIST 0x4110
            FACES DESCRIPTION 0x4120
            MAPPING COORDINATES LIST 0x4140

Descriviamo questi chunks più in dettaglio:

MAIN CHUNK
Identifier	0x4d4d
Length	0 + sub-chunks length
Chunk father	None
Sub chunks	3D EDITOR CHUNK
Data	None
3D EDITOR CHUNK
Identifier	0x3D3D
Length	0 + sub-chunks length
Chunk father	MAIN CHUNK
Sub chunks	OBJECT BLOCK, MATERIAL BLOCK, KEYFRAMER CHUNK
Data	None
OBJECT BLOCK
Identifier	0x4000
Length	Object name length + sub-chunks length
Chunk father	3D EDITOR CHUNK
Sub chunks	TRIANGULAR MESH, LIGHT, CAMERA
Data	Object name
TRIANGULAR MESH
Identifier	0x4100
Length	0 + sub-chunks length
Chunk father	OBJECT BLOCK
Sub chunks	VERTICES LIST, FACES DESCRIPTION, MAPPING COORDINATES LIST
Data	None
VERTICES LIST
Identifier	0x4110
Length	varying + sub-chunks length
Chunk father	TRIANGULAR MESH
Sub chunks	None
Data	Vertices number (unsigned short) Vertices list: x1,y1,z1,x2,y2,z2 etc. (for each vertex: 3*float)
FACES DESCRIPTION
Identifier	0x4120
Length	varying + sub-chunks length
Chunk father	TRIANGULAR MESH
Sub chunks	FACES MATERIAL
Data	Polygons number (unsigned short) Polygons list: a1,b1,c1,a2,b2,c2 etc. (for each point: 3*unsigned short) Face flag: face options, sides visibility etc. (unsigned short)
MAPPING COORDINATES LIST
Identifier	0x4140
Length	varying + sub-chunks length
Chunk father	TRIANGULAR MESH
Sub chunks	SMOOTHING GROUP LIST
Data	Vertices number (unsigned short) Mapping coordinates list: u1,v1,u2,v2 etc. (for each vertex: 2*float)

Ora che è abbastanza chiaro il formato 3ds andiamo ad analizzare il codice di questo tutorial... cosa? Non avete capito un tubo? Proseguite lo stesso! La struttura dei chunks vi sarà sicuramente più chiara proseguendo con la lezione, dopotutto noi programmatori comprendiamo meglio il linguaggio C piuttosto che le solite chiacchiere! ;)

Un breve Briefing

Gli steps necessari per caricare un oggetto 3ds e salvarlo nella nostra struttura dati sono:

Implementare un while loop che continua la sua esecuzione fino a che è raggiunta la fine del file.
Leggere chunk_id e chunk_length ad ogni iterazioe del ciclo.
Utilizzare uno switch (select case) per analizzare il contenuto dell'identificativo.
Se il chunk appartiene ad una parte dell'albero su cui NON dobbiamo passare allora saltiamo l'intera lunghezza del chunk spostando il puntatore del file alla posizione calcolata in base alla lunghezza del chunk sommata alla posizione attuale. In questo modo saltiamo il chunk e tutti i chunks contenuti. In altre parole: saltiamo al successivo ramo! Siamo antenati delle scimmie o no? =)
Se invece il chunk ci permette di arrivare ad un dato che ci serve, oppure se egli stesso contiene il dato che ci serve, allora leggiamo i suoi dati, dopodiché leggiamo il chunk successivo.

FINALMENTE... CODICE!

Come già abbiamo fatto per il precedente tutorial la prima cosa da fare è di creare i files che conterranno le nuove routines.

Fino ad ora abbiamo utilizzato il file tutorialN.cpp per contenere i tipi di dato necessari al nostro motore. Ora ci stiamo evolvendo e le nostre strutture dati stanno diventando sempre più grandi, quindi meglio inserire le dichiarazioni dei nostri tipi di dato presenti in tutorial3.cpp (che per questa lezione rinomineremo tutorial4.cpp) in un file header che chiameremo tutorial4.h.

Per prima cosa aumentiamo il numero di vertici e di poligono che il nostro motore sarà in grado di gestire:

#define MAX_VERTICES 8000
#define MAX_POLYGONS 8000

La successiva modifica da fare riguarda la struttura obj_type in cui inseriremo il campo char name[20]; che conterrà il nome dell'oggetto caricato.

Modificheremo anche il nome cube della nostra variabile oggetto in: obj_type object; giusto per sottolineare la natura generica del nostro oggetto.

L'altro file da creare è il 3dsloader.cpp. In questo file inseriremo questa routine:

char Load3DS (obj_type_ptr p_object, char *p_filename)
{
   int i;
   FILE *l_file;
   unsigned short l_chunk_id;
   unsigned int l_chunk_lenght;
   unsigned char l_char;
   unsigned short l_qty;
   unsigned short l_face_flags;

La routine Load3DS accetta come parametri in ingresso il puntatore alla struttura dati del nostro oggetto ed il nome del file da aprire. Come ritorno avremo "0" se il file non è stato trovato oppure "1" se il file è stato trovato e letto.

Come potete notare le variabili da inizializzare non sono molte: oltre alle solita variabile contatore i, al puntatore al file *l_file ed alla variabile di appoggio per estrapolare dati byte l_char abbiamo:

unsigned short l_chunk_id; l'identificatore del chunk, un numero esadecimale di 2 byte di lunghezza
unsigned int l_chunk_lenght; 4 byte di lunghezza invece per specificare la dimensione del chunk
unsigned short l_qty; Questa è solamente una variabile di appoggio che ci sarà utile per conoscere la quantità di informazioni da leggere.
unsigned short l_face_flags; Questa variabile memorizza alcune informazioni riguardanti il poligono corrente (visibile, non visibile ecc.) necessarie unicamente per la visualizzazione della scena negli editors. Noi la leggeremo solamente per far avanzare il puntatore del file alla successiva posizione.

Ora non ci resta che aprire il file!

   if ((l_file=fopen (p_filename, "rb"))== NULL) return 0; //Open the file
   while (ftell (l_file) < filelength (fileno (l_file))) //Loop to scan the whole file 
   {

Il ciclo while viene eseguito per tutta la lunghezza del file. La funzione ftell ci permette di acquisire la posizione attuale del puntatore di lettura nel file aperto mentre filelenght ci restituisce la lunghezza del file.

Quella che segue signore e signori è la parte più importante della routine di lettura:

      fread (&l_chunk_id, 2, 1, l_file); //Read the chunk header
      fread (&l_chunk_lenght, 4, 1, l_file); //Read the lenght of the chunk

Abbiamo estrapolato l'identificatore e la lunghezza del chunk e li abbiamo salvati rispettivamente in l_chunk_id e l_chunk_lenght. Ora andiamo ad analizzare il contenuto di l_chunk_id:

      switch (l_chunk_id)
      {
         case 0x4d4d: 
         break;

Abbiamo trovato il MAIN CHUNK e cosa facciamo? Semplice... niente! Infatti il MAIN CHUNK non ha dati propri, quello che ci interessa sono i suoi sub-chunks, per questo abbiamo incluso questa istruzione "case", infatti non includendo questo "case" tutto il chunk sarebbe stato saltato, ma perchè? La spiegazione si trova nel "case default", che spiegherò più avanti. Comunque è bene che sappiate che saltare la lunghezza del MAIN CHUNK avrebbe significato spostare il puntatore del file alla fine!

Stesso identico discorso per il 3D EDITOR CHUNK:

         case 0x3d3d:
         break;

Questo è il ramo secondario che ci serve per arrivare alle informazioni che ci interessano e non ha dati propri. Quindi facciamo finta di leggerlo =) lui ci porterà da suo figlio... l'OBJECT BLOCK:

         case 0x4000: 
            i=0;
            do
            {
               fread (&l_char, 1, 1, l_file);
               p_object->name[i]=l_char;
               i++;
            }while(l_char != '\0' && i<20);
         break;

Ed ecco il chunk OBJECT BLOCK, finalmente questo chunk ha qualche informazione interessante: il nome dell'oggetto, che salviamo subito all'interno del campo name della struttura object. Il ciclo while di lettura ha il controllo in coda ed esce nel momento in cui trova il carattere terminatore oppure se l'indice i è più grande di 20. Quindi fate attenzione! Abbiamo dovuto leggere per forza tutto ciò che era contenuto all'interno di questo chunk perchè ciò ci ha permesso di spostare il puntatore del file al successivo chunk:

         case 0x4100:
         break;

Che è un altro ramo vuoto che però è il padre dei chunks sottostanti.

Ed ecco finalmente i nostri bellissimi vertici! Il chunk VERTICES LIST contiene tutti i vertici dell'oggetto:

         case 0x4110: 
            fread (&l_qty, sizeof (unsigned short), 1, l_file);
            p_object->vertices_qty = l_qty;
            printf("Number of vertices: %d\n",l_qty);
            for (i=0; i<l_qty; i++)
            {
               fread (&p_object->vertex[i].x, sizeof(float), 1, l_file);
               fread (&p_object->vertex[i].y, sizeof(float), 1, l_file);
               fread (&p_object->vertex[i].z, sizeof(float), 1, l_file);
            }
         break;

Andiamo a leggere prima la quantità dei vertici contenuti ed in base a quella impostiamo un ciclo for per leggere punto per punto tutti i vertici. Salviamo tutte le informazioni all'interno della struttura object.

Il chunk FACES DESCRIPTION contiene la lista dei poligoni dell'oggetto:

         case 0x4120:
            fread (&l_qty, sizeof (unsigned short), 1, l_file);
            p_object->polygons_qty = l_qty;
            printf("Number of polygons: %d\n",l_qty); 
            for (i=0; i<l_qty; i++)
            {
               fread (&p_object->polygon[i].a, sizeof (unsigned short), 1, l_file);
               fread (&p_object->polygon[i].b, sizeof (unsigned short), 1, l_file);
               fread (&p_object->polygon[i].c, sizeof (unsigned short), 1, l_file);
               fread (&l_face_flags, sizeof (unsigned short), 1, l_file);
            }
         break;

Come abbiamo spiegato nel tutorial 1 noi in questa struttura non memorizziamo coordinate ma solamente gli indici corrispondenti ai vertici della struttura VERTICES LIST. Per la lettura di questo chunk ci comportiamo esattamente come per la lettura dei vertici: prima leggiamo il numero di facce ed in base a questo numero impostiamo un ciclo for per leggere tutte le facce. Dimenticavo di dire che per ogni faccia c'è anche un altro campo di 2 byte: si tratta del Face flags, che contiene alcune informazioni del tutto inutili a noi: lati visibili della faccia e così via. Noi lo leggiamo ugualmente per spostare il puntatore del file:

Infine leggiamo il MAPPING COORDINATES LIST:

         case 0x4140:
            fread (&l_qty, sizeof (unsigned short), 1, l_file);
            for (i=0; i<l_qty; i++)
            {
               fread (&p_object->mapcoord[i].u, sizeof (float), 1, l_file);
               fread (&p_object->mapcoord[i].v, sizeof (float), 1, l_file);
            }
         break;

Al solito acquisiamo prima il valore indicante la quantità delle informazioni successive da leggere ed impostiamo un ciclo for. Leggiamo le due coordinate per il texture mapping u e v ve le ricordate? No?? Cosa state facendo qui allora? ;P

Ed ecco finalmente il case default:

         default:
            fseek(l_file, l_chunk_lenght-6, SEEK_CUR);
      } 
   }

Quando incontriamo chunks che non vogliamo leggere ci viene in aiuto l'istruzione fseek che, tramite l'informazione chunk lenght, sposta il puntatore del file all'inizio del chunk successivo.

Abbiamo finito! Non ci rimane altro che chiudere il file e ritornare 1!

   fclose (l_file); // Closes the file stream
   return (1); // Returns ok
}

CONCLUSIONE

Il 3ds reader che abbiamo sviluppato è la base da cui partire per realizzare readers più complessi. Ricordate però che il nostro reader può leggere una scena 3ds solo se in essa è presente un solo oggetto centrato a coordinate 0,0. In una delle prossime lezioni, in particolare quella sulle matrici, aggiungeremo la possibilità di caricare altri oggetti. Aggiungeremo altre astronavi, giusto? Cosa pensate ci sia da distruggere in caso contrario nello spazio profondo? =)

Questa lezione è stata veramente divertente, non trovate? Non è stata poì così faticosa! Del resto il grosso del lavoro è stato già fatto con le lezioni precedenti. Le energie risparmiate le useremo per il prossimo tutorial, nel quale impareremo come effettuare l'illuminazione della scena attraverso le OpenGL. Saluti per ora cari amici programmatori!

SOURCE CODE

The Source Code of this lesson can be downloaded from the Tutorials Main Page