OpenGL come macchina a stati

OpenGL è una macchina a stati. Essa viene impostata in vari stati o modi di funzionamento e resta in quello stato sino a quando non viene modificato. Come si è già visto, il colore corrente è una variabile di stato. Si può impostare il colore corrente in bianco, rosso, e qualsiasi altro colore, quindi ogni oggetto sarà disegnato in quel colore, sino a quando il colore impostato non verrà cambiato. Altri controllano cose quali l'impostazione della vista attuale, e le trasformazioni della proiezione ortogonale, le trame di linee e poligoni, il modo di disegnare i poligoni, i metodi per impacchettare i pixel, e le posizioni e caratteristiche delle luci, le proprietà dei materiali degli oggetti disegnati. Molti di queste variabili di stato hanno modalità che possono attivate o disattivate mediante i comandi glEnable() o glDisable(). Ogni variabile di stato ha una modalità di default, e in ogni punto del programma si può chiedere al sistema il valore corrente. Tipicamente, vengono usati uno dei seguenti 6 comandi per conoscerlo: glGetBooleanv(), glGetDoublev(), glGetInteger(),glGetPointer(), glIsEnabled(). La selezione di alcuni di questi comandi dipende dal tipo di dato da recuperare. Alcune variabili di stato possiedono comandi specifici (quali glGetLight*(), glGetError() o glGetPolygonStipple(). Inoltre si possono salvare un insieme di variabili di stato su uno stack di attributi, mediante glPushAttrib() o glPushClientAttrib() temporaneamente. Dopo averle modificate, sono recuperate mediante le istruzioni glPopAttrib(), glPopClientAttrib(). Per cambiamenti di stato temporanei è consigliato utilizzare queste ultime istruzioni, in quanto sono più efficienti.

La classe SalaGioco

La classe SalaGioco rappresenta la sala o la fila nella quale i giocatori attendono.

Class SalaGioco

{ friend ostream& operator<<(ostram& os, const SalaGioco& aSalaGioco);

public:

          SalaGioco(): m_pTesta(0){}

          ~SalaGioco( ){ Azzera(); }

          void AggiungiGiocatore();

          void RimuoviGiocatore();

          void Azzera();

private:

         Giocatore* m_pTesta;

};

Il membro dati m_pTesta è un puntatore che indica l'oggetto Giocatore, il quale rappresenta la prima persona nella coda. m_pTesta è l'inizio della coda. Poiché ogni oggetto Giocatore ha un membro dati m_pPros, è possibile collegare un gruppo di oggetti Giocatore in una lista collegata. Elementi individuali della lista collegata sono chiamati nodi. Un modo di pensare ai nodi del giocatore è come un gruppo di vagoni connessi tra loro. Ogni vagone porta un nome e sono collegati attraverso un puntatore chiamato m_pPros. La classe SalaGioco alloca la memoria su heap per ciascuno dei giocatori sulla lista. La classe SalaGioco fornisce accesso al primo oggetto Giocatore in testa alla lista. Il costruttore è molto semplice e inizializza i dati membro di m_pTesta a 0, con un puntatore nullo. Il distruttore chiama semplicemente Azzera(), il quale rimuove tutti i giocatori dalla lista e libera la memoria allocata. AggiungiGiocatore() istanzia un nuovo oggetto Giocatore su heap, e lo aggiunge alla fine della lista. RimuoviGiocatore() toglie il primo oggetto Giocatore dalla lista e libera la memoria allocata. Viene dichiarata la funzione operator<<() amica di SalaGioco, in quanto l'oggetto SalaGioco possa essere visualizzato con cout usando l'operatore <<.

Il programma Sala da Gioco

Il programma sala da gioco, simula un'area di gioco in attesa di giocatori, solitamente per un gioco in rete. Il programma non coinvolge alcuna funzione in linea del computer. Ma crea una singola linea di testo per la quale il giocatore deve aspettare. L'utente del programma esegue una simulazione ed ha quattro scelte. Può aggiungere un giocatore alla sala da gioco, rimuovere una persona dalla sala (la prima ad entrare è al prima ad uscire), azzerare la sala, o uscire dalla sala da gioco.

La classe Giocatore

La prima cosa da fare quando si crea la classe Giocatore e rappresentare i giocatori che aspettano nella sala da gioco. Poiché non sappiamo quanti giocatori deve avere la sala ogni volta, ha senso usare una struttura dinamica. Solitamente, i contenitori utilizzati sono quelli delle librerie standard, ma in questo caso viene definito un contenitore dinamico che possa allocare la memoria ed essere gestito dal programma. Un' ottima via per vedere la memoria dinamica in azione.

 //Sala da Gioco

  //Simula una sala nella quale il giocatore può attendere

  #include<iostream>

  #include<string>

  using namespace std;

class Giocatore

{

public:

          Giocatore(const string& nome=” ”): m_Nome(nome), m_pPros(0){}

          string DaiNome() const { return m_Nome;}

          Giocatore* DaiPros() const { return m_pPros;}

          void MettiPros(Giocatore* prossimo){m_pPros = prossimo;}

private:

           string m_Nome;

           Giocatore* m_pPros; //puntatore al giocatore successivo

};

Il membro dati m_Nome tiene il nome del giocatore. Questo è molto comprensibile, ma ci si può chiedere quale tipo di dato contenga m_pPros. E' un puntatore all'oggetto Giocatore, il quale indica che ogni oggetto Giocatore può contenere il nome e puntare ad un altro oggetto Giocatore. Questo è molto comprensibile durante lo sviluppo dell'oggetto SalaDaGioco. La classe ha due metodi accessori per m_Nome come due funzioni accessorie dai e metti per m_pPros. Il costruttore della classe è molto semplice, inizializza una stringa m_Nome basandosi sull'argomento passato ed imposta m_pPros con un puntatore nullo.