Depuis que je connais très bien OpenGL ES, j'ai fait un essai sur un projet de démonstration, en faisant une grande partie de ce que vous décrivez. L'intention spécifique était de tout faire de la manière la plus simple possible sous OpenGL ES tant que la performance était suffisante. À partir du modèle OpenGL fourni par Apple, j'ai écrit une nouvelle classe avec un fichier d'implémentation fortement commenté de 122 lignes qui charge les images PNG sous forme de textures. J'ai modifié le contrôleur de vue d'échantillon pour dessiner une skybox comme requis et pour répondre aux contacts avec une version du défilement inertiel normal d'iPhone, qui a signifié écrire moins de 200 lignes de code (également commenté).
Pour atteindre ce que je devais savoir:
- les CoreGraphics moyens pour obtenir des données de pixels d'un PNG
- comment mettre en place la pile de PROJECTION pour obtenir une projection en perspective avec le rapport d'aspect correct
- comment manipuler la pile MODELVIEW pour assurer une rotation à deux axes (first person shooter ou Google StreetView style) de la scène en fonction des variables membres et pour s'assurer que la géométrie du cube ne croise pas visiblement le plan
- comment spécifier vertex emplacements et coordonnées de texture OpenGL
- comment spécifier les triangles OpenGL doit construire entre les sommets
- comment définir les paramètres de texture OpenGL en conséquence de fournir un seul niveau de détail pour la texture
- comment suivre une touche pour manipuler les variables membres dictant la rotation, y compris un petit peu de mécanique pour donner une rotation inertielle
Bien sûr, les instructions du cycle de vie du contrôleur de vue normale sont respectées. Les textures sont chargées sur viewDidLoad et libérées sur viewDidUnload, par exemple, pour s'assurer que ce contrôleur de vue joue correctement avec les avertissements de mémoire potentiels.
Les principales observations sont que, au-delà de la connaissance des mécanismes de signalisation Objective-C, la plus grande partie de ce phénomène est constituée de C. Vous utilisez principalement des tableaux C et des références pour effectuer des appels de fonction C, à la fois pour OpenGL et CoreGraphics. Donc, une condition préalable pour coder vous-même est d'être heureux en C, pas seulement en Objective-C. Le contenu de CoreGraphics est un peu fastidieux, mais il suffit de lire les docs pour comprendre comment chaque type de chose se rapporte au suivant - rien de vraiment déroutant. Imaginez que vous avez besoin d'un fournisseur de données pour les données PNG, vous pouvez créer une image à partir de ce fournisseur de données, puis créer un contexte bitmap avec la mémoire que vous vous êtes allouée, dessiner l'image dans le contexte puis tout relâcher sauf la mémoire que vous vous êtes attribué pour être laissé avec le résultat. Ce résultat peut être directement téléchargé sur OpenGL. C'est assez court terme, mais OpenGL n'a pas de concept de PNG et CoreGraphics n'a pas de méthodes pratiques pour pousser les choses dans OpenGL.
J'ai supposé que les textures sont d'une taille appropriée sur le disque. Pour des raisons pratiques, cela signifie supposer qu'ils ont une puissance de deux sur chaque bord. Les miens sont 512x512.
La gestion de la texture OpenGL est assez facile; il s'agit simplement de lire le manuel pour en savoir plus sur les noms de texture, l'attribution de noms, les paramètres de texture et le téléchargement de données d'image. Plus de choses de routine qui sont plus sur la connaissance des bonnes fonctions que la gestion d'un saut intuitif.
Pour fournir la géométrie à OpenGL, je viens d'écrire les tableaux dans leur intégralité. Je suppose que vous avez besoin d'un peu d'esprit spatial pour le faire, mais esquisser un cube en 3D sur le papier et numéroter les coins serait d'une grande aide.Il y a trois tableaux pertinents:
- les positions sommet
- les coordonnées de texture qui vont avec chaque emplacement de sommet
- une liste d'indices faisant référence aux positions des sommets qui définissent la géométrie
Dans mon code J'ai utilisé 24 sommets, en traitant chaque face du cube comme une chose logiquement discrète (donc, six faces, chacune avec quatre sommets). J'ai défini la géométrie en utilisant uniquement des triangles, pour plus de simplicité. Fournir ce genre de choses à OpenGL est vraiment ennuyeux quand vous démarrez; Faire une erreur signifie généralement que votre programme se bloque dans le pilote OpenGL sans vous donner d'indices sur ce que vous avez fait de mal. Il est probablement préférable de construire un peu à la fois.
En termes d'UIView capable d'héberger du contenu OpenGL, j'ai plus ou moins utilisé les éléments de vanille qu'Apple fournit directement dans le modèle OpenGL. La seule modification que j'ai faite était explicitement de désactiver toute tentative d'utilisation d'OpenGL ES 2.x. 1.x est plus que suffisant pour cette tâche, donc nous gagnons en simplicité d'une part en ne fournissant pas deux chemins de rendu alternatifs et d'autre part parce que le chemin ES 2.x serait beaucoup plus compliqué. ES 2.x est le pipeline entièrement programmable avec pixel et vertex shaders, mais en ES, le pipeline fixe est complètement supprimé. Donc, si vous en voulez un alors vous devez fournir vos propres substituts pour les piles de matrice normales, vous devez écrire des vertex et fragment shaders pour faire un triangle avec une texture, etc.
Le suivi tactile n'est pas particulièrement compliqué, plus ou moins juste de me demander de comprendre comment fonctionne la vue frustum et comment les touches sont livrées dans Cocoa Touch. Une fois que vous avez tout fait, ce bit devrait être assez facile.
Notamment, les maths que j'ai dû mettre en œuvre étaient extrêmement simples. Juste le suivi tactile, vraiment. En supposant que vous vouliez une vue de type Google Maps, je pouvais compter entièrement sur la capacité intégrée d'OpenGL pour faire tourner les choses, par exemple. À aucun moment je ne gère explicitement une matrice. Donc, combien de temps cela vous prendrait pour écrire dépend de votre propre confiance avec C et avec CoreGraphics, et de la façon dont vous êtes parfois heureux de coder dans l'obscurité. Parce que je sais ce que je fais, tout cela a pris deux ou trois heures.
Je vais essayer de trouver un endroit pour télécharger le projet afin que vous puissiez y jeter un coup d'œil. Je pense qu'il serait utile de le feuilleter et de voir à quoi il ressemble. Cela vous donnera probablement une bonne idée de savoir si vous pouvez mettre en œuvre quelque chose qui répond à tous vos besoins dans les délais de votre projet.
J'ai laissé le contrôleur de vue comme ayant exactement une vue, qui est la vue OpenGL. Cependant, les règles normales de composition de l'iPhone s'appliquent et dans votre projet vous pouvez facilement mettre les contrôles normaux au-dessus. Vous pouvez récupérer ma petite mise en œuvre au mediafire. Les limites de longueur de publication de StackOverflow m'empêchent de mettre de gros extraits de code ici, mais n'hésitez pas à demander si vous avez des questions spécifiques.
Il est venu à mon attention que la rotation inertielle dans le projet d'échantillon prend la vitesse au doigt un peu trop littéralement. Cela fonctionne parfaitement dans le simulateur, mais pas tout à fait sur l'appareil. Je ne vois pas que c'est vraiment lié au problème, alors je vais laisser ça. De même, je n'ai pas implémenté le support de Retina Display dans ma version d'EAGLView - il s'agit principalement de choses Cocoa Touch normales, donc pas non plus quelque chose que je considère comme totalement pertinent. – Tommy
Tommy, pourriez-vous s'il vous plaît contacter sur mon courrier. Je voudrais vous remercier personnellement pour votre aide. – microspino
Tommy, quelqu'un essayait de télécharger votre implémentation de skybox: http: // stackoverflow.com/questions/10212991/skybox-avec-opengl-es-sur-ios-no-glkit-ios-5-0, mais il semble que Mediafire a supprimé ce fichier. Pourriez-vous re-télécharger votre projet là-bas ou ailleurs? Cela pourrait vraiment les aider. –