Affichage des articles dont le libellé est NeHe. Afficher tous les articles
Affichage des articles dont le libellé est NeHe. Afficher tous les articles

jeudi 2 février 2012

Just for Fun: OpenGL Icosaèdre

Juste pour montrer que la complexité du modèle ne doit pas nécessairement augmenter la complexité du code, voici par exemple un projet iPhone qui montre comment afficher et faire pivoter une alias alias icosaèdre une platonique vingt-face solide une virtuels vingt-faces. Si vous regardez le projet, vous verrez que le code est pratiquement identique au code d'affichage et de tourner le cube de la leçon 5 NeHe porté, il ya un peu plus les sommets.

Tutoriels NeHe, Leçon 6 Porté sur iPhone (sorte de)

J'ai porté Leçon 06 NeHe. En quelque sorte.

Vous voyez, OpenGL ES 1.1 ne supporte pas les quads. NeHe choisi une pyramide et un cube, parce qu'ils sont faciles formes sous OpenGL approprié. Toutefois, le polygone seul OpenGL ES 1.1 connaît est le triangle. Il ya plusieurs variations sur elle - bandes triangle, triangle de ventilateurs, et des triangles. Comme vous l'avez vu lorsque nous avons porté Leçon 5, Nous avons dû diviser chaque quad en deux triangles. Ce n'était pas si mauvais quand nous étions juste le dessin des couleurs à plat, mais maintenant que nous sommes à la recherche de textures carte, il devient un diable ensemble de beaucoup plus difficile, parce que la cartographie d'une texture carré à un triangle est, très franchement, une douleur dans le cul.

Voici le lien pour la Leçon 6 projet porté.

Je ne cartographié deux de ses côtés - devant et le dos, l'autre ne sont pas fait et ne s'afficheront pas droit. Il m'a fallu une bonne partie de une heure avant de finalement renoncé à la cartographie des six côtés. Je déteste la publication de ce inachevé, mais je ne peux pas se permettre le bon moment maintenant pour mapper manuellement les textures à tous le triangle qui composent le cube. Heureusement, il ya rarement un besoin de mapper manuellement les coordonnées de texture plus. La plupart des programmes en 3D va exporter les coordonnées de texture pour vous, alors ensemble nous avons vraiment besoin de prendre de la leçon 06 est de savoir comment charger les textures dans la mémoire et comment les rendre actifs. Vous devriez lire le tutoriel NeHe afin de comprendre comment fonctionne mappage de texture, mais il n'a pas de sens de dépenser beaucoup de temps sur le processus. Dans une future affectation, nous allons voir comment prendre un objet 3D créé dans Blender et importer les coordonnées de texture avec les données de vertex. En pratique, il serait rare pour vous permettre de mapper manuellement les textures et les polygones individuels comme cela.

Dans la leçon 06, nous avons notre variable de première instance de la classe contrôleur. Parce que j'avais besoin d'accéder à la gamme des textures à partir de plusieurs méthodes, je ne pouvais pas juste faire une autre variable statique. Donc, nous avons maintenant un tableau d'entiers, et ces entiers sera rapportent chacune à une texture chargée dans OpenGL.
GLuint  texture[1];      // Storage For One Texture ( NEW ) 
Dans notre méthode setupView, nous préparons notre texture tout comme est fait dans la leçon 06 NeHe
 glGenTextures(1, &texture[0]);
glBindTexture(GL_TEXTURE_2D, texture[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
Nous avons pour varier un peu le plan de réalité charger la texture du fichier. Au lieu d'un fichier. Bmp, nous allons charger ce fichier texture compressée je n'avais que vous créez dans ce blogue. Si vous n'avez pas fait cela, allez faire maintenant. Vous aurez envie de glisser le fichier. Pvr4 fichier dans le groupe / Ressources de votre projet.

Une fois que vous avez le projet dans votre texture, on peut le charger dans notre méthode setupView:
 NSString *path = [[NSBundle mainBundle] pathForResource:@"NeHe" ofType:@"pvr4"];
NSData *texData = [[NSData alloc] initWithContentsOfFile:path];
// Instead of glTexImage2D, we have to use glCompressedTexImage2D
glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, 256.0, 256.0, 0, (256.0 * 256.0) / 2, [texData bytes]);
[texData release];
Un couple de choses à remarquer - d'abord, parce que notre image de texture est comprimé, nous avons dû utiliser glCompressedTexImage2D () plutôt que glTexImage2D () comme cela a été fait dans le tutoriel NeHe. L'autre chose est que nous publions les données d'image après que nous ayons le nourrir à OpenGL - elle crée sa propre copie de la texture, nous avons donc à libérer pour éviter une fuite de mémoire.

Après cela, le reste de la configuration est à peu près les mêmes que dans le tutoriel original:
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
// Enable blending
glEnable(GL_BLEND);
Là où les choses deviennent vraiment différent est dans la méthode drawView. Certains d'entre vous avez probablement vu venir, mais nous ne pouvons pas utiliser glTexCoord2f () parce que nous ne pouvez pas utiliser glBegin () et glEnd () sur l'iPhone.

La solution est la même qu'avant - nous slideshows tous ceux coordonnées de texture dans un tableau appelé (attendre pour elle) une gamme coordonnée de texture. Les coordonnées de texture dans le tableau sont comme les valeurs que vous passeriez à glTexCoord2f () - Les valeurs entre 0,0 et 1,0. Reportez-vous au tutoriel d'origine pour une description de la façon que la cartographie fonctionne. C'est un peu difficile à Grok. Si vous n'avez pas entièrement l'obtenir, ne vous inquiétez pas - avant longtemps, nous allons écrire un objet-loader qui va gérer ça pour nous, puis nous n'aurons jamais à se rappeler comment il fonctionne à nouveau. Voici le tableau des coordonnées de texture que j'ai créé pour cette leçon, mais n'oubliez pas que seuls les 16 premières valeurs (correspondant aux quatre premiers polygones qui constituent l'avant et l'arrière du cube) sont en fait valables et cartographiées.
 const GLfloat cubeTextureCoords[] = {
1.0, 1.0, // Front
0.0, 1.0,
0.0, 0.0,
1.0, 0.0,

0.0, 0.0, // Back
0.0, 1.0,
1.0, 1.0,
1.0, 0.0,

0.0, 0.0, // Top
1.0, 1.0,
1.0, 1.0,
1.0, 1.0,

0.0, 0.0, // Bottom
0.0, 1.0,
1.0, 1.0,
1.0, 1.0,

0.0, 0.0, // Left
1.0, 1.0,
1.0, 1.0,
1.0, 1.0,

0.0, 0.0, // Right
1.0, 1.0,
1.0, 1.0,
1.0, 1.0,
};
Avant de nous faire des appels d'glDrawElements (), nous devons dire à OpenGL sur les coordonnées de texture, et nous le faisons en utilisant une fonction appelée glTexCoordPointer (), comme ceci:
glTexCoordPointer(2, GL_FLOAT, 0, cubeTextureCoords);
Le premier argument de cette fonction nous dit que nous avons deux valeurs de cartographie pour chaque élément puisse être établi. Le second argument indique à OpenGL que le tableau de textures contient des valeurs en virgule flottante, la troisième est que le paramètre Je continue à dire que vous ignorez et juste 0 pour offrir, et le dernier est le pointeur vers le tableau de coordonnées de texture réelle.

Avant que vous pouvez appeler glDrawElements, vous devez activer les tableaux de coordonnées de texture, en faisant cet appel:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
Comme les autres fonctions permettent, vous pouvez appeler cela une fois pendant l'installation, ou vous pouvez activer et désactiver lors de l'exécution des applications. Parce que seul l'un de nos deux objets devient cartographié, nous le permettent avant de tirer le cube, et le désactiver par la suite, ce qui maintiendra la pyramide d'obtenir ainsi cartographiés.

Pour texture mapping au travail, nous devons aussi appeler
glEnable(GL_TEXTURE_2D);
Ce ne doit être appelée une fois dans l'installation, ou vous pouvez également activer et le désactiver lors de l'exécution des applications, bien que généralement c'est juste allumé au début.

C'est à peu près tout. Lorsque nous appelons glDrawElements (), il va automatiquement chercher les données de coordonner et de carte de la texture dernière qui a été lié. Nous n'avons qu'une seule, qui nous avons lié lors de l'installation par glGenTextures appelant () et glBindTexture ().

Si nous avons eu beaucoup de textures (qui vous sera dans la plupart des situations), vous auriez normalement les charger tous en cours d'installation, puis d'activer les différents en rendant les appels ultérieurs à glBindTexture (), qui ne double devoir, à la fois la création, et en activant textures existantes. Le dernier qui a été adoptée à l'glBindTextures () est celui qui obtiendra mappé lorsque vous dessinez.

Ce fut une dure leçon au port. Ils ont opté pour cartographier le cube car il était facile - faces carrées, les textures carrées, cartographie très simple. Nous ne sommes plus chanceux sur l'iPhone, donc j'espère que vous pardonnerez le fait que celui-ci est incomplète. En retour, je promets de vous montrer comment charger des objets avec des cartes de texture. Probablement pas pour une semaine ou deux, si.

Leçon 5 à code fixe

J'ai le Leçon 5 code corrigé. Je pense que je vais laisser Leçon 05 comme il est, et faire le changement je pense au 06, car elle rendra plus facile mappage de texture, mais n'a pas vraiment grand chose à ajouter de la leçon 5 de discussion.

Attention OpenGL!

Si vous avez téléchargé mon modèle OpenGL, ou l'une des leçons NeHe porté (sauf Leçon 02, qui n'est pas affectée), s'il vous plaît re-télécharger eux. L'un des fichiers a été lié de manière incorrecte dans le projet, ce qui provoque des modifications d'aller à la matrice, pour ne pas le fichier. Je m'excuse pour la gêne occasionnée - il a été me rend fou pendant un jour ou deux, mais il m'a fallu si longtemps pour comprendre pourquoi les choses se comportaient étrangement.

J'ai mis à jour le modèle et les leçons 3 et 4. Je travaille toujours sur le 5 et cherche aussi à changer l'approche - je vais essayer d'obtenir tout cela redressé à la fin du week-end.

Les préparatifs pour la Leçon de portage NeHe 06

La prochaine leçon a trait à la gestion des textures. Les leçons NeHe charger une image bitmap et ensuite des cartes que l'image de quads. Parce que l'iPhone a moins de mémoire que les ordinateurs de bureau, nous allons utiliser un type d'image différent Afin de conserver la mémoire. C'est un format d'image spécial utilisé spécifiquement pour la cartographie de texture appelée PVRTC.

Avant que nous puissions aller de l'avant avec cela, il ya deux choses dont vous avez besoin. Le premier, est une image source qui sera mappé sur. Vous pouvez tirer celle de la Leçon 6 NeHe projet C + +, Ou vous pouvez utiliser votre propre image. Si vous utilisez votre propre image, il doit être dimensionné de telle sorte que les deux directions sont égaux et sont une puissance de 2, ce qui signifie que l'image doit être 2x2, 4x4, 8x8, 16x16, 32x32, 64x64, 128x128, 256x256, 512x512, ou 1024x1024 pixels (ce qui est de la texture plus grande taille en charge sur l'iPhone).

Il s'agit d'un outil de ligne de commande qui permettra de créer des images PVRTC pour vous à partir des fichiers source PNG. Cet outil se trouve à l'emplacement suivant:
/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/texturetool

Pour rendre la vie plus facile, vous pouvez ajouter / Developer / Platforms / iPhoneOS.platform / Developer / usr / bin / à votre variable PATH. J'utilise tcsh ma coquille, donc en ajoutant que pour mon chemin était juste une question de l'ajout / Developer / Platforms / iPhoneOS.platform / Developer / usr / bin / à mon. Cshrc (~ /. Cshrc). Voici ce que cette ligne dans mon cshrc ressemble.:
set path= ( /usr/X11/bin /opt/local /opt/local/bin ~/bin /usr/local/bin /usr/bin /bin  /usr/sbin /sbin /Users/jeff/bin /Developer/Tools /opt/local/bin /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/ )
Si vous êtes une personne bash, alors vous feriez dans votre profil bash, situé dans ~ / bash_profile, et la syntaxe est un peu différent.:
export PATH="/opt/local:/opt/local/bin/:Users/jeff/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/Users/jeff/bin:/Developer/Tools:/opt/local/bin:/usr/local/pgsql/bin:/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/"
Qu'est-ce qui va faire est de vous permettre d'utiliser texturetool partir de la ligne de commande sans avoir à taper le chemin complet, comme si texturetool étaient assis dans votre répertoire / bin.

Maintenant, dans le Terminal, naviguez jusqu'à l'emplacement de votre fichier image PNG source est d'utiliser la commande cd, puis générer votre fichier PVRTC avec l'outil texture, comme tant (dans mon cas, le fichier source est NeHe.png:
texturetool -e PVRTC -o NeHe.pvr4 NeHe.png
L'exécution de ce va générer un fichier avec une extension. Pvr4 extension. Vous ne serez pas en mesure d'afficher ce fichier image dans Preview.app, ou la grande majorité des images d'autres programmes de visualisation ou d'édition (assurez-vous donc cette conversion est la dernière étape), mais croyez-moi, c'est un fichier image. Enregistrez ce fichier pour la prochaine leçon, leçon 06.

Cela peut prendre quelques jours avant que je sois porté Leçon 06, cependant. Le fait que notre cube est composé de triangles, plutôt que de quads va dire quelques essais et erreurs avec les coordonnées de texture.

Tutoriels NeHe, Leçon 5 Porté sur iPhone

Dans la troisième dimension!



J'ai maintenant porté NeHe OpenGL Leçon 5. Celui-ci n'est pas exactement simple - ma description de la différence sera probablement plus longue que la leçon originale 5. C'est en partie parce que des fonctionnalités qui ne sont pas disponibles sur l'iPhone, et en partie parce que l'iPhone est un appareil relativement aux ressources limitées, donc je mis en œuvre certaines optimisations qui n'étaient pas strictement nécessaires, mais que vous devez vraiment utiliser sur l'iPhone.

Voici le lien pour la leçon 5 du projet porté.

Où allons-nous même commencer cette fois-ci?

Définir et dessin de la pyramide



Tout d'abord, parlons un fait fondamental de la vie. Lorsque nous avons été la définition de nos sommets, nous avons fait ça en utilisant des nombres à virgule flottante stockés dans les variables GLfloat. Or, généralement parlant, les nombres à virgule flottante sont plus lents que les entiers. Bien sûr, avec les GPU et les FPU ce n'est pas toujours aussi simple, mais c'est généralement une bonne règle de base lors de la programmation, y compris la programmation pour l'iPhone.

Nous ne voulons pas sacrifier la précision, cependant. Nous voulons définir nos sommets avec des nombres à virgule flottante, puis reportez-vous à les utiliser entiers. Jetez un oeil à cette image spiffy j'ai dessiné (je sais, pouvez-vous croire que je ne tire pas dans la vie?):

Ce sont les sommets de la pyramide. Notez que nous avons un total de cinq sommets qui composent cette forme en trois dimensions. Cependant, nous ne pouvons pas nourrir ces cinq sommets en OpenGL et s'attendre à ce qu'il sait quoi faire avec eux. Il ne fonctionne pas de cette façon. Nous devons être un peu plus précis que cela. Nous avons pour identifier chacune des faces ou des polygones qui forment la forme.

Pour la pyramide, nous n'allons pas tirer en bas, nous allons donc vous inquiétez pas pour ça, mais en dehors du fond, une pyramide est composée de quatre formes triangulaires, et nous devons tirer toutes quatre d'entre eux. Alors que les quatre triangles avec trois sommets chacune, pour un total de douze sommets que nous avons besoin pour nourrir OpenGL pour dessiner cette pyramide. Mais, regardez à nouveau l'illustration: Nous avons seulement cinq sommets au total dans la forme. Cela signifie que nous allons nourrir les mêmes sommets dans les temps OpenGL multiples, car les sommets des polygones ou des visages part.

Nous pourrions créer un tableau avec tous les vertex douze points, et ce serait beau travail. Mais il est inefficace, parce que nous faisons OpenGL jetez autour des cinq mêmes sommets (composé de trois valeurs à virgule flottante chacun) plusieurs fois. OpenGL ne va pas regarder les valeurs et déterminer si elles sont les mêmes - il va tout simplement de les utiliser pour dessiner, et dans le processus, vous allez faire la navette autour et faire des calculs sur un terrain de plus de points flottants Les valeurs que nécessaire.

Au lieu de cela, nous allons définir un tableau de vertex, comme avant, et il va seulement avoir cinq valeurs en elle - un pour chaque point unique dans l'espace qui composent le polygone.
static const GLfloat pyramidVertices[] = { 
0.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, -1.0f
};
Ensuite, nous allons à nourrir ce tableau de vertex à OpenGL, là encore, tout comme nous le faisions avant. Mais, nous n'allons pas utiliser glDrawArrays () pour lui dire de tirer le tableau de vertex, comme nous l'avons fait auparavant. Au lieu de cela, nous allons définir un autre tableau, mais celui-ci ne va pas pour contenir les sommets, il va contenir des valeurs entières tenant valeurs de l'indice de ce point dans le tableau de vertex qui contient les cinq sommets. Donc, pour se référer à la partie supérieure de la pyramide, au lieu de se référer à lui comme {0.0f, 1.0f, 0.0f}, nous allons voir par cet index du vertex dans le tableau de vertex.

C'est un peu déroutant, cependant, parce que nous n'allons pas à s'y référer en utilisant l'index dans le tableau réel, mais plutôt que nous allons prétendre que chaque sommet dans le tableau de vertex est un objet distinct, avec son propre index valeur, comme ceci:
static const GLfloat pyramidVertices[] = { 
0.0f, 1.0f, 0.0f, // These three values are one vertex with index 0
-1.0f, -1.0f, 1.0f, // These three values are one vertex with index 1
1.0f, -1.0f, 1.0f, // These three values are one vertex with index 2
1.0f, -1.0f, -1.0f, // These three values are one vertex with index 3
-1.0f, -1.0f, -1.0f // These three values are one vertex with index 4
};
Ou, pour utiliser notre illustration de fantaisie encore, c'est comment nous allons penser à ces indices:

Donc, nous allons créer un autre tableau qui définit réellement chaque face de la pyramide (souvenez-vous, nous ne sommes pas le dessin du bas). Ce tableau, peut être constitué d'un des types de données entières OpenGL. J'ai choisi GLubyte parce que c'est le plus petit et j'ai moins de 256 sommets dans mon tableau, donc il fonctionnera très bien. Voici ce que ce tableau ressemble
static const GLubyte pyramidVertexFaces[] = { 
0, 1, 2, // Defines Front Face
0, 3, 2, // Defines Right Face
0, 3, 4, // Defines Back Face
0, 1, 4 // Defines Left Face
};
Assez simple, non? Vous pouvez voir que nous avons encore des valeurs répétées, mais au moins ils sont gentils, les petites valeurs entières sur un octet qui peut être bousculés rapidement. Faire cela permet aussi d'OpenGL pour les calculs de cache qui correspondent à un sommet spécifiques afin qu'elles n'ont pas à faire plusieurs fois.

Pour la pyramide, nous sommes encore en utilisant ce tableau de couleurs pour nous donner cette fantaisie gradation mélangés, mais nous allons l'optimiser. Les couleurs peuvent être définies en utilisant la valeur en virgule flottante compris entre 0,0 et 1,0. Ils peuvent également être défini comme un entier compris entre 0 et 255. Parce que toutes nos couleurs peuvent être définies en utilisant adéquatement un octet par canal de couleur, ce sera un tout petit peu plus vite en OpenGL, et de petits morceaux peuvent s'additionner rapidement quand vous êtes de programmation sur un appareil mobile comme l'iPhone. Voici la nouvelle version du tableau de couleur.
static const GLubyte triVertexColors[] = { 
255, 0, 0, 255,
0, 255, 0, 255,
0, 0, 255, 255,
0, 255, 0, 255,
0, 0, 255, 255
};
Pourquoi avons-nous plus de valeurs cette fois-ci, vous pourriez vous demander? Eh bien, nous, c'est parce que nous définissons une couleur pour chaque élément dans le tableau de vertex. Lorsque nous nous référons au sommet par sa valeur d'index, OpenGL va et s'empare de la correspondance des couleurs de ce tableau, il ya un total de cinq sommets, et nous sommes attribuant une couleur à chacun. Vous voulez le même nombre de couleurs dans votre tableau de couleurs que vous avez sommets dans votre tableau de vertex.

Ah, voici une autre chose - en OpenGL, vous pouvez définir des couleurs avec trois valeurs dans un tableau de couleur. Non, cependant, dans OpenGL ES. Vous devez utiliser quatre valeurs pour définir une couleur - vous devez fournir la valeur alpha, même si c'est toujours 1.0 ou 255.

Nous avons également définir une constante qui identifie le nombre de sommets, nous allons dessiner - c'est le nombre de polygones ou des visages multipliés par le nombre de sommets dans chaque polygone.

static const GLubyte triNumberOfIndices = 12
Maintenant que nous avons notre tableau de vertex, à la couleur, et les visages définis, nous pouvons puiser. Nous n'allons pas utiliser glDrawArrays (), nous allons utiliser une nouvelle fonction appelée glDrawElements (). Nous allons appeler cette fonction une fois par polygone, ce qui signifie que nous ne sommes pas seulement un tableau dans l'alimentation et de laisser faire le reste OpenGL, nous allons faire une boucle à travers nos polygones et de les nourrir, un à la fois, à glDrawElements (). Ce n'est pas aussi difficile qu'il y paraît, cependant. Voici comment nous le faisons:
 glVertexPointer(3, GL_FLOAT, 0, pyramidVertices); 
glColorPointer(4, GL_UNSIGNED_BYTE, 0, triVertexColors);
for(int i = 0; i {
glDrawElements(GL_TRIANGLE_FAN, 3, GL_UNSIGNED_BYTE, &pyramidVertexFaces[i]);
}
Notez que nous avons changé notre appel à glColorPointer () pour utiliser GL_UNSIGNED_BYTE parce que nous avons changé notre gamme de couleurs à utiliser GLubyte. Puis on boucle à travers notre réseau de polygones, l'incrémentation par trois, afin que nous ne frapper chaque triangle une fois, et nous alimentons ce triangle dans l'appel glDrawElements ().

C'est un peu déroutant (et ce n'est pas si facile à expliquer non plus), mais il est vraiment plutôt simple une fois que vous avez enveloppé autour de votre tête l'idée de base. Le glDrawElements () Fonction sait que les valeurs que vous êtes l'alimentation sont des indices de ce point dans le tableau de vertex que vous avez fourni au plus tôt, et il trace un polygone sur la base des indices de sommets que vous le nourrissez.

Notre pyramide est composée de triangles (sauf le fond, que nous n'avons pas tirer), mais qu'en est-il le cube?

Définition et l'élaboration du Cube


Eh bien, OpenGL ES ne supporte pas GL_QUAD. Vous ne pouvez pas dessiner des carrés de OpenGL ES. Vous pouvez dessiner des points, des lignes, des boucles de ligne, des triangles, et les fans triangle, mais pas quads. Alors, comment pouvons-nous dessiner le cube, qui est composé de six quadrilatères?

En théorie, il est assez facile. Nous venons de subdiviser chaque carré en deux triangles. Tracez une ligne d'un coin à l'angle opposé du rectangle quelconque, et vous avez deux triangles. En fait, tout polygone peut être subdivisé en triangles. Ainsi, au lieu de dessiner six rectangles, nous avons juste à attirer l'douze triangles. Mais, la théorie est exactement la même que la pyramide. Nous définissons tous les sommets qui composent le cube (huit d'entre eux), puis créer un tableau de vertex d'eux. Nous définissons ensuite, en utilisant les particuliers, les douze triangles qui composent le cube. Voici ce que ces structures de données ressemblera à ceci:
 static const GLfloat cubeVertices[] = { 
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f,-1.0f, 1.0f,
-1.0f,-1.0f, 1.0f,
-1.0f, 1.0f,-1.0f,
1.0f, 1.0f,-1.0f,
1.0f,-1.0f,-1.0f,
-1.0f,-1.0f,-1.0f
};
static const GLubyte cubeNumberOfIndices = 36;

const GLubyte cubeVertexFaces[] = {
0, 1, 5, // Half of top face
0, 5, 4, // Other half of top face

4, 6, 5, // Half of front face
4, 6, 7, // Other half of front face

0, 1, 2, // Half of back face
0, 3, 2, // Other half of back face

1, 2, 5, // Half of right face
2, 5, 6, // Other half of right face

0, 3, 4, // Half of left face
7, 4, 3, // Other half of left face

3, 6, 2, // Half of bottom face
6, 7, 3, // Other half of bottom face

};
Nourrir à OpenGL est exactement la même. Une différence est que nous ne créons pas des gradations de couleur cette fois, mais sont plutôt le dessin de chaque côté du cube dans une couleur différente, donc on doit définir un éventail de couleurs, mais nous n'avons pas le nourrir à OpenGL comme un tableau de couleur, nous l'utilisons dans notre boucle de régler manuellement la couleur. Voici le tableau de couleur:
 const GLubyte cubeFaceColors[] = { 
0, 255, 0, 255,
255, 125, 0, 255,
255, 0, 0, 255,
255, 255, 0, 255,
0, 0, 255, 255,
255, 0, 255, 255
};
La chasse aux sorcières seulement ici, c'est que nous avons six couleurs, pour six faces, mais nous sommes de dessin douze triangles, donc nous devons nous rappeler de ne incrémenter l'indice de couleur tout autre triangle. Voici la boucle tirage au sort pour le cube:
 glVertexPointer(3, GL_FLOAT, 0, cubeVertices);
int colorIndex = 0;
for(int i = 0; i {
glColor4ub(cubeFaceColors[colorIndex], cubeFaceColors[colorIndex+1], cubeFaceColors[colorIndex+2], cubeFaceColors[colorIndex+3]);
int face = (i / 3.0);
if (face%2 != 0.0)
colorIndex+=4;

glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, &cubeVertexFaces[i]);
}

Bon, je sais que cela a été une lourde affichage. Cette annonce est probablement deux fois plus longtemps que la leçon NeHe originale. C'est le prix à payer pour la 3D sur un appareil mobile comme l'iPhone. Vous ne pouvez pas compter sur OpenGL ES à faire pour vous toutes les choses que bon OpenGL fait pour vous. Mais, une fois que vous commencez à obtenir le coup de lui, c'est vraiment pas si mal à travailler avec.

Je pense que je vais aller hors script après cette annonce. Je ne suis pas sûr qu'il ya beaucoup de valeur à aller leçon par leçon, à travers le prochain lot de tutoriels NeHe ... pas avant quelques-uns des sujets plus avancés. Je ne veux couvrir un certain nombre de choses, cependant - les normales, et les textures, par exemple. Donc je pense que je vais prendre une pause de NeHe pour les deux prochaines affectations et parler de ce normales sont et comment ils aident à dessin en 3D, et également montrer comment mapper les textures et les polygones. Puis, peut-être, je vais vous montrer comment charger un objet 3D créé dans un programme comme Maya ou Blender, au moins, une fois que j'ai compris comment le faire moi-même.

Tutoriels NeHe, Leçon 4 Porté sur iPhone

Leçon 4 NeHe a été très facile au port. La nouvelle fonctionnalité introduite tous les travaux à peu près tel quel.

Voici le lien pour la Leçon 4 projet porté.

La seule différence notable (autres que les éléments mentionnés dans les blogues précédents) est le fait que j'ai déclaré rtri et rquad que les variables statiques dans la méthode drawView plutôt que de déclarer des variables globales. Ce fut juste pour garder tout le code pertinent pour le projet ensemble, et n'a aucun impact sur functinoality du programme.

Un changement que je pourrais recommander serait de lier les augmentations et les rtri rquad à la quantité de temps écoulé. Il semble fonctionner assez bien, mais si vous voulez qu'il soit parfaitement lisse, qui serait la façon de l'accomplir. Pour ce faire, remplacez ce code:
 rtri+=0.2f;      // Increase The Rotation Variable For The Triangle ( NEW )
rquad-=0.15f; // Decrease The Rotation Variable For The Quad ( NEW )
avec quelque chose comme ce code, qui tourne à une constante 20 ^ 0 par seconde pour le triangle, et 15 ^ 0 par seconde pour le carré.
 static NSTimeInterval lastDrawTime;
if (lastDrawTime)
{
NSTimeInterval timeSinceLastDraw = [NSDate timeIntervalSinceReferenceDate] - lastDrawTime;
rtri+=20.0 * timeSinceLastDraw;
rquad-=15.0 * timeSinceLastDraw;
}
lastDrawTime = [NSDate timeIntervalSinceReferenceDate];
Une autre chose que vous pouvez faire - il ne changera pas la fonctionnalité, mais aidera pendant le débogage - est de garder la rotation au sein d'un 360 ^ 0 portée, qui peut être fait simplement en ajoutant quelques lignes de code:
 static NSTimeInterval lastDrawTime;
if (lastDrawTime)
{
NSTimeInterval timeSinceLastDraw = [NSDate timeIntervalSinceReferenceDate] - lastDrawTime;
rtri+=20.0 * timeSinceLastDraw;
if (rtri > 360.0)
rtri -= 360.0;

rquad-=15.0 * timeSinceLastDraw;
if (rquad rquad += 360.0;
}
lastDrawTime = [NSDate timeIntervalSinceReferenceDate];


Tutoriels NeHe, Leçon 3 Porté sur iPhone

Voici la version iPhone de Leçon 3 NeHe.

Voici le code porté pour la leçon 3.

Encore une fois, la plupart de ce qui est là est valable, et vous devriez lire la leçon originale - Je ne vais pas pour couvrir tout - mais il ya certains morceaux de fonctionnalité dans la leçon 03 qui ne sont pas disponibles sur l'iPhone.
Tout d'abord, glColor3f () n'existe pas dans OpenGL ES - vous devez utiliser glColor4f () au lieu. La seule différence est que vous devez passer, non seulement une valeur pour le rouge, vert et bleu, mais aussi pour l'alpha. Vous pouvez toujours définir vos propres glColor3f () comme ceci:

#define glColor3f(r,g,b) glColor4f(r,g,b,1.0)

Bien qu'il soit sans doute plus facile si vous venez de vous habituer à utiliser glColor4f ().

Les autres bits de fonctionnalité manquante est un peu plus complexe, et elle nous oblige à sauter en avant du tutoriel à nouveau. Dans le didacticiel, lors de l'élaboration du triangle, ils changent la couleur à chaque sommet. Entre les appels à glBegin () et glEnd (), ils ont mis une couleur, définir un sommet, définir une nouvelle couleur, de définir une autre vertext, etc OpenGL interpole ensuite les valeurs inbetween pour donner un effet joli dégradé. Cependant, parce que nous devons définir nos sommets en utilisant un large vertex dans OpenGL ES, il n'ya pas moyen de changer les couleurs entre les sommets de la façon dont ils faire dans cette leçon.

Tout n'est pas perdu, cependant. Il ya très peu en OpenGL qui ne peut pas être fait en OpenGL ES, et dans ce cas, nous pouvons obtenir la même fonctionnalité en utilisant un éventail de couleurs, ce qui est juste un tableau de valeurs comme le tableau de vertex de la leçon précédente. Dans la leçon, ils ont mis la couleur au rouge avant de définir le premier sommet, puis au vert avant le second, puis au bleu pour le troisième sommet. Nous pouvons réaliser la même chose en définissant un autre tableau de valeurs GLfloat, comme ceci:

const GLfloat triVertexColors[] = {
1.0f, 0.0f, 0.0f, 1.0f, // Red
0.0f, 1.0f, 0.0f, 1.0f, // Green
0.0f, 0.0f, 1.0f, 1.0f // Blue
};

Dans ce cas, nous définissons chaque couleur avec 4 valeurs (rouge, vert, bleu, alpha), et notre tableau a une couleur pour correspondre à chacun des sommets dans notre tableau de vertex, ce qui signifie une série de douze articles (4 chars par les temps de couleur trois sommets). Si OpenGL va tirer, il va utiliser les quatre premières valeurs de ce tableau pour définir la couleur pour le premier sommet du tableau de vertex, le second de quatre valeurs pour définir la couleur pour le deuxième sommet dans notre tableau, et les quatre dernières valeurs pour définir la couleur pour le dernier sommet.

Afin d'utiliser un tableau de couleur, nous avons pour l'activer, comme nous l'avons fait avec les vertex arrays. Encore une fois, cela peut être fait une fois, dans la configuration, ou peut être activée et désactivée au besoin à l'exécution. Généralement, vous l'activer avant que vous l'utilisez, puis désactiver postfaces, sinon les futurs appels d'glColor4f () sera ignoré, ce qui peut ne pas être ce que vous voulez. Voici l'appel pour permettre aux tableaux de couleur:
glEnableClientState (GL_COLOR_ARRAY);
et de désactiver
glDisableClientState (GL_COLOR_ARRAY);

Puis, avant que nous appelons glDrawArrays (), nous avons à dire au sujet de notre gamme OpenGL couleur. Nous faisons cela comme ceci:
glColorPointer (4, GL_FLOAT, 0, triVertexColors);
L'appel est très similaire à notre glVertexPointer () de la leçon 02 (qui est aussi utilisé dans ce projet, bien sûr). Le premier argument indique à OpenGL que chaque couleur est composée de quatre valeurs. Le second argument indique à OpenGL que ces valeurs sont GLfloats. La troisième valeur est celle que vous pouvez oublier pour l'instant, et le dernier est le pointeur vers le tableau de couleur.

C'est tout ce qu'il ya à faire - faire fonctionner maintenant, et vous aurez votre triangle jolie, tout comme dans la leçon NeHe:


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.