Tutoriels NeHe, Leçon 2 Porté sur iPhone

La première leçon de fond OpenGL plus à la grande Productions NeHe site Web est Leçon 02

J'ai porté le code de cette leçon à l'iPhone. Voici le code source.

Vous devriez lire la leçon, mais il faut également noter que la technique de dessin utilisée dans les leçons NeHe début (en utilisant glBegin () et glEnd ();) n'est pas supporté sur OpenGL ES 1.1. En conséquence, le projet lié ci-dessus utilise quelque chose appelé vertex arrays, qui ne sont pas couverts que beaucoup plus tard dans les leçons NeHe. Voici la différence fondamentale dans le code de dessin:

Dans le tutoriel NeHe, ils le font:

glBegin(GL_TRIANGLES);     // Drawing Using Triangles
  glVertex3f( 0.0f, 1.0f, 0.0f);  // Top
  glVertex3f(-1.0f,-1.0f, 0.0f);  // Bottom Left
  glVertex3f( 1.0f,-1.0f, 0.0f);  // Bottom Right
glEnd();      // Finished Drawing The Triangle

L'appel à glBegin () indique à OpenGL que le code qui suit va définir les points (ou sommets) dans l'espace virtuel. Puis, les trois appels à glVertex3f définir les sommets en utilisant les coordonnées cartésiennes (x, y, z). Parce GL_TRIANGLES a été spécifié dans glBegin (). OpenGL va dessiner et remplir le triangle défini par les trois sommets spécifiés avant l'appel à glEnd ()

Sur l'iPhone, au lieu de cela, nous devons placer les trois mêmes sommets dans un tableau (pas un NSArray - un bon vieux tableau C). Ce tableau, assez curieusement, est appelé un "tableau de vertex". Voici ce qu'un Vertex Array contenant les trois sommets dans le code ci-dessus ressemble comme:

const GLfloat triVertices[] = { 
  0.0f, 1.0f, 0.0f, 
  -1.0f, -1.0f, 0.0f, 
  1.0f, -1.0f, 0.0f 
 }; 

Notez que nous avons neuf éléments dans le tableau - c'est trois sommets avec trois valeurs de chaque (x, y, z). Les sommets peuvent être définis par 2 ou 3 points selon que vous faites le dessin à trois dimensions ou en deux dimensions. Bien que nous soyons dessin à plat, à deux dimensions ici, nous sommes effectivement les dessiner en trois dimensions d'espace, donc la première valeur de notre gamme est un endroit x, la seconde est l'emplacement oui, et le troisième est l'emplacement az. Puis nous passons au sommet suivant, avec un autre X, alors Y, alors z, etc

Pour utiliser les vertex arrays, nous devons activer cette fonctionnalité en OpenGL, comme ceci:

glEnableClientState(GL_VERTEX_ARRAY);

L'appel à glEnableClientState peut être soit dans le code de configuration, ou dans le code de dessin, en fonction de vos besoins, et les États peuvent être activés et désactivés pendant la durée de vie de l'application, donc si vous utilisez uniquement des vertex arrays dans une partie, vous pourriez lui permettre, votre dessin ne Vertex Array, puis désactivez-le en appelant glDisableClientState (GL_VERTEX_ARRAY);.

Après avoir défini le tableau de vertex et en tournant sur le vertex arrays, nous devons dire à OpenGL ES pour attirer le tableau de vertex. Nous faisons cela comme ceci:

glVertexPointer(3, GL_FLOAT, 0, triVertices);

Cette fonction lui indique que le tableau est un tableau triVertices vertex, et que chaque sommet a trois éléments de données (x, y, z). Si nous faisions en deux dimensions en utilisant le dessin et les sommets avec deux valeurs, on aurait passé 2 au lieu de 3 pour le premier argument. Le deuxième argument dit GL_FLOAT OpenGL ES que notre tableau est un tableau de la virgule flottante (GLfloat) valeurs. Le troisième paramètre n'est pas utilisé ici, nous passons donc 0. Ce paramètre peut être utilisé pour "sauter" des valeurs dans un tableau de vertex pendant le dessin - ne vous inquiétez pas cela, ce n'est pas quelque chose que vous êtes susceptible d'utiliser jusqu'à ce que vous en savez plus sur OpenGL que moi. Le dernier argument est un pointeur vers le tableau que nous disons à propos d'OpenGL.

Maintenant que l'OpenGL ES connaît le tableau de vertex, nous pouvons lui dire de tirer les sommets dans ce tableau. Nous faisons cela comme ceci:

glDrawArrays(GL_TRIANGLES, 0, 3);

Dans cet appel de fonction, le premier argument miroirs celui utilisé dans le glBegin (); appel dans le tutoriel original - il raconte OpenGL qui à utiliser à partir de plusieurs manières qu'il sait dessiner. Certaines des options comprennent des points de dessin, des lignes, des triangles, et plusieurs options plus avancées.

Et c'est tout - tout le reste du tutoriel devrait être le même - glIdentity (), glTranslate (), etc, tous exactement la même fonction, nous avons juste eu pour avancer rapidement un peu de vertex arrays à cause des limitations du OpenGL ES.