Contenuto

• Passi
• Parte 1 di 3: installazione iniziale
• Parte 2 di 3: La funzione display ()
• Parte 3 di 3: Interattività del programma

OpenGL è uno strumento di programmazione 3D che consente di creare immagini 3D complesse da forme semplici. In questo articolo imparerai come disegnare con il suo aiuto un semplice cubo che può essere ruotato in tre dimensioni!

Passi

Parte 1 di 3: installazione iniziale

1. 1 Installa OpenGL. Inizia con un tutorial su come installare OpenGL sul tuo computer. Se hai già OpenGL e un compilatore C, puoi saltare questo passaggio e passare a quello successivo.
2. 2 Crea un documento. Crea un nuovo file nel tuo editor di codice preferito e salvalo come mycube.c
3. 3 Aggiungi #include. Ecco le direttive #include di base di cui avrai bisogno. È importante ricordare che le direttive per i diversi sistemi operativi sono diverse e quindi è necessario scegliere tutto in modo che il programma sia universale e possa essere eseguito su qualsiasi sistema.

   // Include #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 Aggiungi prototipi funzionali e globali. Il prossimo passo è dichiarare i prototipi funzionali.

   // Prototipi funzionali void display (); void specialKeys (); // Variabili globali double rotate_y = 0; doppia rotazione_x = 0;

5. 5 Definire la funzione principale ().

   int main (int argc, char * argv []) // Inizializza GLUT ed elabora i parametri personalizzati glutInit (& argc, argv); // Richiedi una finestra con supporto per Double Buffering, Z-Buffering e True Color glutInitDisplayMode (GLUT_DOUBLE

Parte 2 di 3: La funzione display ()

1. 1 Comprendere lo scopo della funzione display(). Tutto il lavoro sul rendering del cubo ricadrà sulle fragili linee di questa funzione. L'idea generale è questa: disegnerai sei facce separate del cubo e le collocherai nelle rispettive posizioni.
   • Per ogni faccia, definirai quattro angoli e OpenGL li collegherà con linee e li riempirà con il colore scelto. Come farlo verrà spiegato di seguito.
2. 2 Aggiungi la funzione glClear(). Prima di tutto, quando si lavora con questa funzione, è necessario colore chiaro e z-buffer... Senza questo, quello vecchio sarà visibile sotto la nuova immagine e gli oggetti disegnati dal programma saranno posizionati in modo errato.

   void display () // Cancella lo schermo e il buffer Z glClear (GL_COLOR_BUFFER_BIT

   • Attenzione alle ultime due righe. Queste sono le funzioni glFlush (); e glutSwapBuffers ();, dando l'effetto di doppio buffering, che è stato descritto sopra.

Parte 3 di 3: Interattività del programma

1. 1 Aggiungere la funzione specialKeys(). In linea di principio, tutto è quasi pronto, ma il cubo viene solo disegnato e non ruotato. Per fare questo, devi creare la funzione SpecialKeys(), che ti permetterà di ruotare il cubo premendo i tasti freccia!
   • È per questa funzione che sono state dichiarate le variabili globali rotante_x e rotante_y. Quando si premono i tasti freccia sinistra e destra, il valore rotate_y aumenterà o diminuirà di cinque gradi. Il valore di rotate_x cambierà allo stesso modo, ma questa volta premendo i tasti freccia su e giù.

   void specialKeys (int key, int x, int y) {// Freccia destra - aumenta la rotazione di 5 gradi if (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Freccia sinistra - Diminuisce la rotazione di 5 gradi else if (key == GLUT_KEY_LEFT) rotate_y - = 5; else if (chiave == GLUT_KEY_UP) rotate_x + = 5; else if (tasto == GLUT_KEY_DOWN) rotante_x - = 5; // Richiedi aggiornamento schermo glutPostRedisplay (); }

2. 2 Aggiungi glRotate(). L'ultima cosa che faremo è aggiungere una linea che ci permetterà di ruotare l'oggetto. Torna alla funzione Schermo () e prima della descrizione del lato ANTERIORE aggiungere:

   // Reset trasforma glLoadIdentity (); // Ruota quando l'utente cambia i valori rotate_x e rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (ruota_y, 0.0, 1.0, 0.0); // Lato multicolor - FRONTE ....

   • Si prega di notare che la sintassi glRotatef()che è simile alla sintassi di glColor3f() e glVertex3f(), ma richiede sempre quattro parametri. Il primo è l'angolo di rotazione in gradi. I successivi tre sono gli assi lungo i quali avviene la rotazione, nell'ordine x, y, z. Per ora, dobbiamo ruotare il cubo lungo due assi, x e y.
   • Tutte le trasformazioni che definiamo nel programma richiedono linee simili. Fondamentalmente, rappresentiamo la rotazione di un oggetto lungo l'asse x come un cambiamento nel valore di rotate_x, e la rotazione lungo l'asse y come un cambiamento nel valore di rotate_y. Tuttavia, OpenGL raggrupperà tutto in un'unica matrice di trasformazione. Ogni volta che chiami display, creerai una matrice di trasformazione e glLoadIdentity() ti permetterà di iniziare ogni volta con una nuova matrice.
   • Altre funzioni di trasformazione che potresti aver usato sono glTranslatef() e glScalef(). Sono simili a glRotatef(), tranne per il fatto che richiedono solo tre parametri: i valori x, y e z per ridimensionare e ridimensionare l'oggetto.
   • Affinché tutto venga visualizzato correttamente quando tutte e tre le trasformazioni vengono applicate a un oggetto, è necessario impostare le trasformazioni nell'ordine appropriato, ovvero glTranslate, glRotate, glScale - e mai altrimenti. OpenGL trasforma l'oggetto leggendo il programma dal basso verso l'alto. Per capire meglio questo, immagina come il cubo 1x1x1 si occuperebbe di tutte le trasformazioni se OpenGL le applicasse nell'ordine mostrato (dall'alto verso il basso), quindi pensa a come OpenGL elaborerebbe il cubo leggendo le istruzioni dal basso verso l'alto.
3. 3 Aggiungi i seguenti comandi per ridimensionare il cubo due volte nelle direzioni x e y, per ruotare il cubo di 180 gradi sull'asse y e per spostare il cubo di 0,1 sull'asse x. Assicurati che tutti i comandi rilevanti, inclusi i comandi glRotate() dati in precedenza, siano nell'ordine corretto. Se hai paura di sbagliare, vedi la versione finale del programma alla fine dell'articolo.

   // Altre trasformazioni glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 Compila ed esegui il codice. Supponiamo che tu stia usando gcc come compilatore, quindi inserisci i seguenti comandi nel tuo terminale:

   Su Linux: gcc cube.c -o cube -lglut -lGL ./ mycube Su Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube Su Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ mycube

5. 5 Controlla il codice finale. Ecco il codice finale creato dall'autore dell'articolo, che non traduce i commenti.

   // // File: mycube.c // Autore: Matt Daisley // Creato: 25/4/2012 // Progetto: Codice sorgente per Crea un cubo in OpenGL // Descrizione: Crea una finestra OpenGL e disegna un cubo 3D / / Che l'utente può ruotare utilizzando i tasti freccia // // Controlli: Freccia sinistra - Ruota a sinistra // Freccia a destra - Ruota a destra // Freccia su - Ruota su // Freccia giù - Ruota giù // ------ --------------------------------------------------- - // Include // ----------------------------- - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # include GL / glut.h> #endif // ------------------------- - ------------------- // Prototipi di funzioni // ------------------------- - -------------------------------- display vuoto (); void specialKeys (); // ------------------------------------------------ ---------- // Variabili globali // -------------------- ------------------------ doppia rotazione_y = 0; doppia rotazione_x = 0; // ------------------------------------------------ ---------- // display() Funzione di richiamata // ------------------------------- ------------- void display () // Cancella schermo e Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ --------------------------------------------------- - // Tasti speciali () Funzione di richiamata // ------------------------- - ------------------ void specialKeys (int key, int x, int y) {// Freccia destra - aumenta la rotazione di 5 gradi if (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Freccia sinistra - diminuisce la rotazione di 5 gradi else if (tasto == GLUT_KEY_LEFT) rota_y - = 5; else if (tasto == GLUT_KEY_UP) rota_x + = 5; else if (tasto == GLUT_KEY_DOWN) rota_x - = 5; // Richiedi aggiornamento display glutPostRedisplay ();} // ----------------------------------- - ---------------------- // funzione main() // ------------------- - -------------------------------------- int main (int argc, char * argv [ ] ) GLUT_RGB