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

jeudi 22 mars 2012

Mise à jour sur UpdateConf

Je voulais juste vous faire savoir que je parle à une autre conférence. Je vais parler à la première UpdateConf in Brighton, Royaume-Uni le 5 Septembre.

Dans le cadre de la conférence, je suis aussi de donner un atelier intensif de deux jours sur OpenGL ES. L'atelier n'assume aucune expérience préalable avec le programme de graphisme, mais il sera assez rapide et couvrira beaucoup de terrain car il ya beaucoup de terrain pour couvrir de nouvelles. Je vais aller sur le GLKit nouvelles et l'incroyable nouvelle OpenGL débogueur ainsi que les mises à jour OpenGL ES modèles Instruments.

Pas intéressé à OpenGL ES? Il ya quatre autres ateliers de deux jours se passe avec certains instructeurs vraiment génial. Marcus Zarra fait un atelier de deux jours sur les données fondamentales, Drew McCormack fait un atelier sur Core Animation, Sarah Parmenter fait un sur iOS UI design, et Remy Sharp fait un sur HTML5 pour mobile. La pire chose que de donner cet atelier est que cela ne m'empêchera d'aller à l'un des ateliers d'autres grands.

La conférence proprement dite a un certain nombre d'intervenants, y compris les instructeurs d'atelier et c'est vraiment s'annonce assez d'une conférence, et aussi un bon volent au lb99 de billets lève-tôt à la conférence (les ateliers sont en sus). Vous pouvez vous inscrire à la conférence sur Eventbrite.

En espérant vous y voir!

Réflexions sur Unity3D

Comme je l'ai indiqué dans mon post précédent sur les moteurs 3D, Je vais faire quatre posts donner mon opinion sur chacun des quatre moteurs que j'ai regardé dans l'aide pour un projet récemment. Ces quatre moteurs sont Unity3D, Sio2, Ogre3D, Et Cocos3D. Je commence avec Unity3D, que nous avons sélectionnées pour l'un de nos récents projets.

Maintenant, permettez-moi de l'avant, que tous les quatre de ces moteurs sont compétents et j'ai pu voir des situations où je vous recommande trois des quatre moteurs pour des projets client et pourrait facilement imaginer des situations où tous les quatre d'entre eux serait une bonne choices.These quatre ne faites pas une liste exhaustive, il ya d'autres moteurs de là-bas, dont certains très bons, mais ils ont été les quatre que nous avons examiné pour ce projet spécifique. Autant que j'aime la UDK, Par exemple, je n'aime pas ça suffisant pour passer du bon temps dans Windows, de sorte que l'on est sur la table pour moi jusqu'à ce que l'amende gens de Epic décide de porter leurs dev et outils pour le contenu vers le Mac.

Aperçu unité

Unity3D précède en fait l'iPhone, et des quatre moteurs, c'est celui qui se sent le plus mature et possède les outils développeur les plus robustes. Il a également l'une des communautés de développeurs les plus actifs. Unity3D est un produit à code source fermé commerciales que vous devez payer, ce qui pourrait être un turn-off pour certains, mais il vaut chaque centime de la redevance.

Unité pros

L'unité est en fait assez facile à apprendre, mais a un ensemble de fonctionnalités qui est se compare favorablement à la plupart des autres moteurs. Pipelines actifs Unity est vraiment robuste et de leurs outils vous donnent la possibilité de faire des changements très rapidement et de tester ces changements.

Une des meilleures choses à propos Unity3D est le fait qu'il supporte à la fois Windows et Mac OS tout aussi plates-formes de développement. Peu importe la plateforme sur laquelle vous développez, vous pouvez générer des jeux qui fonctionne sur tous les supports Unité plate-forme (en supposant que vous êtes autorisé pour lui). Vous pouvez même avoir une partie de votre équipe de développement sur Mac et l'autre partie sur Windows sans aucun problème.

Au moment où j'écris ceci, il est possible de générer des jeux de l'Unité qui fonctionnent sur Mac OS X et Windows (les deux applications natives ainsi que des jeux jouables à travers un plug-in Web), iOS, Android, Wii, Xbox 360 , et la PS3. Les gens de l'unité sont également activement sur l'ajout du support de Linux. Licences de la console sont négociés sur une base individuelle et sont susceptibles assez cher, mais c'est agréable d'avoir la possibilité de prendre un jeu à succès aux plates-formes tant sans avoir à faire un port plein à chaque fois.

Ayant eu à le portage d'applications OpenGL ES à partir d'iOS à Android plus d'une fois (ce qui n'est pas drôle), je peux honnêtement affirmer que le soutien Android devrait être un point de vente énorme que vous donnez toute pensée à soutenir à la fois iOS et Android.

Moins unité

Les inconvénients d'Unity3D sont relativement rares, actually.It est la plus chère des moteurs j'ai regardé, et les coûts sont complètement à chargement frontal. Vous payez un appartement par développeur de licence par la plate-forme à l'avant, mais alors vous pouvez créer autant de matchs que vous voulez pour les plates-formes que vous êtes autorisé pour. Pour la licence de base iOS, c'est 400 $ par siège (un développeur utilisant jusqu'à deux machines), pour la licence Pro, vous cherchez à 3000 $ (parce que les 1500 $ iOS Pro nécessite l'Unité 1500 $ Pro), ce qui pourrait ressembler à un grand nombre d'argent, mais c'est vraiment une somme dérisoire par rapport à la quantité de temps de développement, il peut vous sauver. Le "Basic" version de l'unité, ce qui vous permet de générer Mac, Windows et le Web des jeux (quoique exclut certaines des fonctionnalités les plus avancées) est disponible entièrement gratuit.

L'autre inconvénient potentiel dans certaines situations, c'est que les sous-jacents C + + code source n'est pas disponible. Vous travaillez principalement en JavaScript ou C # (MonoScript) et à un niveau supérieur d'abstraction. Unity supporte quelques autres langues en plus de JavaScript et C #, mais seulement ces deux langues de travail pour le développement mobile.

Après environ deux semaines de passer mes soirées avec Unity, j'ai effectivement venu à la conclusion que ne pas avoir accès à la source n'est pas vraiment beaucoup d'un inconvénient, et pour beaucoup de développeurs, travaillant de cette manière sera better que de travailler en C + +. Le moteur prend en charge presque tous les trucs de bas niveau vous devez faire, mais même si elle n'a pas, l'unité a un langage de shader qui vous permet d'écrire du code qui s'exécute sur le GPU et tout ce qui doit fonctionner sur le CPU peut être fait par l'intérieur de l'unité de scripts.

Bien que la programmation en Unity3D se fait avec des langages de scripts, les scripts que vous écrivez sont réellement compilé, il n'ya donc pas une surcharge de performance énorme pour les utiliser. Dans la situation extrêmement rare, où C # ou Javascript n'est pas suffisante, il est possible d'envoyer des messages entrant et sortant de l'unité à partir de C de votre application ou de code Objective-C.

Learning Curve

J'ai trouvé l'unité étonnamment facile à apprendre. Il ya quelques ressources très bonne là-bas, y compris de nombreux didacticiels et des vidéos pédagogiques. En fait, j'ai eu un jeu de fonctionnement après environ deux heures de jeu. Elle était laide et la mécanique du jeu étaient simples, mais il était jouable. L'unité a également un forum de développeurs assez active communauté où vous pouvez aller chercher de l'aide lorsque vous êtes coincé.

Si vous ne connaissez pas déjà quelque chose sur la programmation graphique, vous n'avez toujours pas besoin d'être trop effrayés ou intimidés. La plupart des choses sont amassés gnarly où vous ne le verrez pas jusqu'à ce que vous en avez besoin, et vous pouvez faire une quantité surprenante d'un peu de configurer les choses dans l'interface de développement. Vous pouvez créer, par exemple, une simulation physique assez complet, sans jamais écrire une seule ligne de code. Vous voulez empiler un tas de caisses et de rouler une balle en eux et les regarder tous les automne? Vous pouvez le faire sans jamais ouvrir un éditeur de texte. Heck, vous pouvez même le faire sans avoir à ouvrir un programme en 3D.

Complexity

J'avais peur d'une chose entrer dans l'unité d'apprentissage: je craignais que parce qu'il était si facile (du moins je n'avais heard il était), que ça allait être un créateur de jeux dumbed qui sacrifiait des fonctionnalités plus avancées pour le bien de l'abaissement des obstacles à l'entrée. Mes craintes ont été complètement égaré, cependant. Ce n'est pas du tout le cas. Les gens de l'unité ont fait un travail vraiment formidable de faire de leurs outils faciles à utiliser tout en vous donnant la possibilité de faire la plupart tout ce que vous n'avais jamais besoin de faire. Il est même possible (bien que le processus est un peu alambiqué) afin d'intégrer et de UIKit Unity3D dans la même application.

Pipeline d'actifs

La chose qui m'a vraiment le plus impressionné unité est ce qu'ils appellent leur «pipeline d'actifs», qui est le processus par lequel vous obtenez des modèles 3D, textures et autres éléments d'actif dans votre jeu. Si vous avez déjà développé un jeu ou mod de jeu pour l'UDK, un jeu Source de Valve, ou d'autres moteurs commerciaux, généralement il ya une sorte de processus alambiqué que vous avez à passer pour obtenir vos actifs de jeu, incluant des personnages, des textures, des accessoires et environnements, dans le match. Vous avez en général d'utiliser des applications distinctes pour préciser les shaders et les options de physique, parfois écrire un script de compilation ou autre document texte pour définir certains trains, et ensuite compiler l'objet et le forfait le tout dans une sorte de bundle ou l'emballage. Tout en développant un mod simple, vous avez l'habitude parcourir ce processus de nombreuses fois. Il peut être un peu fastidieux et difficile à apprendre et nécessite habituellement l'utilisation de multiples outils et beaucoup d'essais et d'erreurs.

Unité contourne presque tous cet ennui. Lorsque vous enregistrez vos actifs à partir de votre programme 3D ou Photoshop, il vous suffit de les enregistrer dans votre projet Unity Assets dossier. Lorsque vous lancez l'unité, ou naviguez revenir si elle est déjà ouverte, l'unité détecte le nouveau fichier, ou toute modification que vous avez apportées à un fichier existant. Il l'importation et l'ajoute à la liste des assets.Anything disponibles que vous devez faire qui ne peut pas être fait dans votre programme 3D, tels que de spécifier un shader ou d'identifier les propriétés moteur physique de l'objet, vous n'avez droit à Unity, et la plupart de ce qui peut être fait sans écrire de code (bien que tout ce que vous pouvez configurer sans code peut également être modifiée à partir du code).

Quel programme avez-vous besoin 3D à utiliser? Quasiment toute celle que vous êtes confortable avec. Unity3D a en charge l'importation directe pour les formats de fichier natif de plusieurs programmes, notamment Blender, mais tout paquet qui peut exporter vers Autodesk FBX ou Collada peut être utilisé avec un support complet pour toutes les fonctions comme les os, les textures, les animations, etc.It prend également en charge native de Photoshop fichiers (. psd) pour les textures, l'aplatissement des couches d'une manière non-destructive lorsque vous construisez votre app.Assets peut même être donné des caractéristiques différentes pour différentes plateformes. Vous auriez pu, par exemple, un atout 2048x2048 texture pour la version desktop de votre jeu, mais dites Unité d'utiliser une version 1024x1024 pour les consoles de jeu et une version 512x512 sur iOS et Android.

The Bottom Line

Comme je l'ai indiqué précédemment, il ya des situations où je pouvais voir l'un des quatre moteurs j'ai regardé à être un bon choix, comme on pouvait beaucoup d'autres moteurs, je ne regarde pas. Mais, honnêtement, si je devais prendre une décision moteur sans informations détaillées, Unity3D serait ma première recommandation. Les outils sont solides, le soutien de l'entreprise et la collectivité est génial, il supporte de nombreuses plateformes, et d'obtenir des actifs dans votre jeu ne pouvait pas être plus facile. Il est relativement facile de commencer à utiliser à la fois pour les développeurs expérimentés et ceux qui ne sont pas.

Un bon programmeur expérimenté graphiques travaillant dans le droit mobiles peuvent désormais facilement demander 200 $ par heure ou plus, car la demande dépasse largement l'offre. Figure it out. Unity licence complète iOS est essentiellement l'équivalent de 15 heures de temps d'un programmeur graphique. Pourtant, l'unité sera facilement couper cinq fois ce nombre d'heures hors de l'horaire de tout projet logiciel de taille décente jeu, probablement beaucoup plus.

Je donne deux Unity3D big thumbs up. Je l'utilise sur un projet maintenant et nous espérons l'utiliser sur plus nombreuses à l'avenir parce que c'est amusant à utiliser et élimine une grande partie de l'ennui associé à la programmation 3D sans enlever le pouvoir.


1 Beaucoup de fonctionnalités plus avancées nécessitent le plus cher "Pro" de licence, cependant, et vraiment caractéristiques de pointe à partir les derniers jeux prennent généralement un peu de temps à apparaître dans les outils

Jeu en 3D et des moteurs graphiques

Une chose que je me pose au sujet de beaucoup est de savoir si vous devez utiliser un jeu ou un moteur graphique au lieu d'apprendre OpenGL ES. Souvent, ces courriels sont précédées par une déclaration au sujet de la difficulté de programmation graphique. J'ai eu à répondre à cette question suffisamment de fois, maintenant qu'il apparaît comme un bon sujet pour un article de blog.

Honnêtement, je trouve ça un peu difficile de répondre, car je ne vois pas le "utilisant un moteur" et "l'apprentissage de la programmation graphique» comme étant distincts ou des approches mutuellement exclusifs. Même si un bon jeu ou moteur graphique gérera une grande partie des tâches de programmation plus noueux pour vous et pour raccourcir votre temps de développement, vous avez encore besoin de comprendre les concepts sous-jacents à construire quoi que ce soit de n'importe quelle complexité.

Tous ces moteurs sont construits sur le dessus d'OpenGL (et / ou s'ils supportent DirectX sous Windows), et sont soumis aux mêmes limitations et des forces. Ne pas comprendre, au moins à un certain niveau, la façon dont ces graphiques de bas niveau des bibliothèques de travail et les mathématiques de base de la programmation 3D finira par vous retenir.

Mais ... qui ne signifie pas nécessairement que vous devez apprendre OpenGL avant que vous puissiez commencer à utiliser efficacement ces outils. Vous n'avez pas. C'est juste que certaines des difficultés, les mathématiques et les concepts collant qui pourrait être vous effrayer d'OpenGL sont toujours là (bien mieux cachés), et vous pouvez ainsi toujours à traiter avec eux à un certain point, si vous faites le codage sur le jeu (par opposition à simplement créer des actifs ou de faire le level design).

Voici une sorte de règle de mot simple:

Si vous aimez la programmation graphique ou sont fascinés par elle, puis étude OpenGL ES et les maths sous-jacente et d'oublier d'utiliser les moteurs au premier abord (si l'étude de leur source est une excellente façon d'apprendre). Il y aura toujours du travail à des programmeurs de bons graphiques et vous ne pouvez pas mettre un prix sur ce que vous aimez.

Si, d'autre part, votre but est de faire un jeu ou d'autres graphiques lourdes applications et la programmation graphique est juste un moyen à cette fin, puis d'utiliser un moteur, car elle réduira la quantité de travail que vous avez à faire énormément , ce qui augmente intrinsèquement vos chances de faire de l'argent parce que le temps c'est de l'argent et il n'ya jamais assez de lui.

Ainsi, lorsque vous utilisez ne doit pas un moteur existant, si votre objectif est de faire un jeu et non d'essayer d'être le prochain John Carmack? Presque jamais. Rouler votre moteur propre jeu devrait être un travail d'amour. Il doit y avoir une démangeaison vous ne pouvez pas rayer; le genre de désir que je ne pourrais probablement pas vous parler de toute façon. Sinon, c'est juste un gaspillage de votre temps.

Qu'en est-il quand il n'y a tout simplement pas un moteur qui fonctionne pour ce que vous voulez faire?

Honnêtement, ce n'est pas tout que probable dans cette journée et l'âge, mais même si elle est, vous êtes bien mieux commencer par un moteur existant et ensuite le modifier pour répondre à vos besoins.

Du point de vue commercial et financier, il est presque jamais mieux repartir de zéro. Même de nombreux moteurs AAA jeu commercial sont des dérivés d'autres moteurs. Pour donner un exemple: Valve Source Engine, Est dérivé de leurs anciens Goldsource moteur, Qui lui-même était fourchue de la Moteur de Quake retour aux alentours de 1996.

Bien qu'il y ait tout à fait un jeu de quelques moteurs autour, Un très grand pourcentage de jeux haut de gamme commerciale, les deux consoles et PC, sont fondées soit sur l'Unreal Engine ou le moteur de Quake ou un de leurs dérivés. Si vous jetez dans une poignée d'autres moteurs, comme le CryEngine, Vous avez probablement couvert tous, mais quelques valeurs aberrantes.

Si ce n'est pas rentable pour les grandes équipes de développement multi-personnes avec des budgets de plusieurs millions pour développer leurs moteurs propre jeu, ce n'est probablement pas le meilleur choix pour les développeurs indépendants individuels ou les petits commerces.

Donc, ne pas réinventer la roue. Utilisez un moteur et se tenir sur les épaules de John Carmack et d'autres comme lui. Ne passez pas votre temps à essayer de résoudre les problèmes qui sont à long résolu. Juste être conscient que l'utilisation d'un moteur ne peut pas éliminer complètement le besoin d'apprendre un peu de mathématiques ou de comprendre les concepts sous-jacents.

Engines

Il se trouve que pour un certain nombre de propositions que j'ai fait dernièrement, j'ai regardé dans les moteurs de jeu en profondeur. Je ne vais pas faire des "critiques" en soi, mais au cours des prochaines semaines, je vais essayer et après mes réflexions sur plusieurs des moteurs disponibles pour iOS, y compris Unity3D, Sio2, Ogre3D, Et Cocos3D.

Je ne vais pas discuter de la UDK, Même si c'est un moteur phénoménal, car il nécessite l'utilisation de Windows pour de nombreuses tâches, et je ne veux pas passer du temps dans Windows. Si vous avez un Mac et une machine Windows, cependant, et ne me dérange pas de temps clivage entre OS X et Windows, vous pouvez le vérifier. Beaucoup de temps et de matière grise est allé dans obtenir l'UDK pour avoir des performances incroyables sur iOS et les conditions de licence ont été modifiées pour être beaucoup plus convivial pour les petits magasins indépendants (99 $ plus 25% des redevances après la première tranche de 50.000).

Videz OpenGL ES application Xcode 4 Modèle

Jacques De Schepper a envoyé dans une version actualisée de ma ancienne modèle vide OpenGL ES application, Mis à jour pour utiliser Xcode 4 de templates entièrement remanié mécanisme. Vous pouvez télécharger la nouvelle version de Xcode 4 de la bon modèle ici. Je n'ai pas encore eu l'occasion de tester cela, mais une fois que je fais, je vais aussi l'ajouter à GitHub. Merci, Jacques!

Blender 2.57 Exporter le script Objective-C

Il ya quelques jours, le Blender Foundation mis hors la première release candidate de Blender 2.5. Cette version inattendue brisé la compatibilité avec la plupart des scripts Python 2.5, y compris mon Objective-C Exporter le script d'en-tête.

Quel a été le moment une grande, car j'avais besoin d'utiliser le script aujourd'hui. J'aurais pu simplement retourné à une ancienne version de Blender, mais a plutôt décidé de ré-écrire le script pour travailler. Je viens d'ajouter à GitHub, la nouvelle version compatible 2.57 du script d'exportation. Cette version est de nouveau à être un add-on que vous pouvez ajouter dans les préférences utilisateur.

J'ai aussi ajouté quelques options que vous pouvez sélectionner lors de l'exportation (ils sont sur le côté gauche de l'écran de sélection de fichier, en dessous des volumes et des lieux récemment visités). Vous pouvez voir les nouvelles options dans la capture d'écran suivante:

Screen shot 2011 04 05 at 2 32 44 PM

La première option vous permet de spécifier si des modificateurs sont appliqués avant d'exporter le maillage. Si vous décochez cette, le script va dépouiller les modificateurs avant d'exporter, sinon, il sera de les appliquer à la maille avant de l'exporter.

La deuxième option va tourner l'objet de 90 ^ 0 sur l'axe X, qui transforme l'objet de Blender jusqu'à Z-espace de coordonnées à l'OpenGL Y jusqu'à coordonnée spatiale. J'ai fait ce défaut, la, mais je ne pouvais prévoir les situations où les gens voudraient ignorer la conversion.

La dernière option se déplace à l'exportation de l'objet à l'aide de son espace coordonnées du monde plutôt que de l'exporter en utilisant les coordonnées d'espace objet. Cette option, par exemple, conserver la distance relative entre plusieurs objets exportés à partir du même fichier dans différents en-têtes. Ou, pour le dire autrement, les objets exportés aura normalement utiliser leurs coordonnées telles qu'elles se rapportent à l'origine de l'objet, indépendamment du lieu où l'objet est dans la scène de Blender. Si cette case est cochée, les coordonnées des sommets sera exporté par rapport à l'origine de la scène.

NB: Il y avait un problème avec le code de triangulation dans la version affichée précédemment. Si vous rencontrez des problèmes, tirer à nouveau à partir de GitHub.

lundi 19 mars 2012

Blender 2.5 beta 6 Objective-C d'exportation

Un lecteur de type mis à jour ma Objective-C le script d'exportation pour Blender à travailler avec le 2.5 beta 6 version de Blender. Vous pouvez trouver la nouvelle version sur GitHub.

Sur une note liée, si vous faites un changement à votre clone d'un de mes dépôts publics sur Github, vous pouvez m'envoyer une demande pull. Je suis heureux de prendre des ajouts, des corrections de bugs, et autres mises à jour dans le référentiel maître.

Merci à John Becker pour la mise à jour du script!

MC3D - plateforme agnostique 3D Fondation

Désolé pour le manque de postes récemment. Les choses ont été, et bien ... vous le savez. Même vieille histoire. Super occupé. Ce qui est bon, mais c'est assassiner sur la fréquence blog.

J'ai récemment eu quelques travaux au port OpenGL ES Je n'ai d'iOS à Android. Il fut un temps que cela aurait été incroyablement douloureuses (par opposition à seulement douloureux). J'aurais dû convertir le code Objective-C à Java, puis de maintenir ensembles complètement distincts de code qui font la même chose exacte. Heureusement, le Android NDK (Kit de développement natif) vous permet d'écrire du code pour Android en C / C + +. La version du NDK en charge sur 2,2 nécessite encore partie de l'activité (l'homologue d'Android à un contrôleur iOS vue) d'être écrit en Java, mais ne vous permettent d'appeler en C / C + + code utiliser JNI. En 2.3 et 3.0, vous pouvez faire des activités ensemble en C ou C + +.

C'est un énorme pas en avant pour Android pour ceux d'entre nous qui ne les performances sont cruciales travailler sur plusieurs plates-formes, mais ce n'est pas sans une certaine douleur. Débogage à travers le pont JNI est ... moins facile. Mais, être capable de partager le code entre plates-formes est une grande victoire, et être capable d'obtenir des vitesses de maternelle dans le processus est le awseome.

Durant ces projets, je prends beaucoup de mes 3D liés code et la création d'un nouvel ensemble de fonctions C la plate-forme agnostique et types. J'ai été nettoyer et faire des noms cohérents, et en plaçant appropriée pré-compilateur de macros pour s'assurer que le code compile correctement partout. Sur iOS, la bibliothèque sera de profiter du cadre de s'accélérer dans les lieux, mais ne nécessite pas accélérer pour fonctionner.

J'ai choisi C, parce que je n'aime pas le mélange C + + et Objective-C. Les modèles d'objet sont trop différentes à mon goût. Mais j'ai aussi fait en sorte d'inclure les déclarations extern bon ifdef'd de sorte que vous pouvez importer les fichiers d'en-tête MC3D à partir de C + + sans tracas.

J'ai baptisé cet ensemble de fonctions MC3D, Et je le fais open source sous une version simplifiée de la licence BSD simplifiée (simplifiée simplifiée licence BSD?). J'ai pris la condition d'attribution, donc la seule exigence est que si vous re-distribuer le code source, vous devez laisser le texte de copyright et la licence intacte. C'est tout. Sinon, vous pouvez l'utiliser gratuitement dans tout projet, commerciale ou autre, sans rien payer, sans lui attribuer, et sans demander (pas vraiment, vous n'avez pas besoin de demander).

MC3D est toujours très un travail en cours, et je suis seulement l'ajout de code au garde que je me sens prête pour la consommation publique. Une grande partie de ce qu'il ya dans MC3D a été affichée ici avant, avec parfois des noms différents ou dans une forme légèrement différente.

Je n'ai d'autre code que j'ai l'intention d'ajouter à l'avenir, y compris de haut niveau des fonctionnalités telles que le chargement du modèle, la gestion des lieux, et l'animation du squelette, mais je ne vais pas ajouter quelque chose jusqu'à ce que son agnostiques fois solide et plate-forme.

Actuellement, la documentation est très clairsemée, et je ne peut actuellement pas offrir aucun soutien ou d'aide à l'utiliser, de sorte caveat emptor! Il me fera plaisir d'accepter des contributions, des corrections de bugs, et à l'arrière de nouvelles fonctionnalités dans la ligne de code MC3D.

MC3D sur GitHub.

Lien fixe, désolé à ce sujet

Les courbes d'animation plus que vous pouvez secouer un bâton à

Core Animation est impressionnant. Il fait faire beaucoup de complexes, des animations de fantaisie carrément facile. Un des très agréable de fonctionnalités intégrées de Core Animation est la capacité à utiliser les courbes d'animation. Ces courbes permettent de spécifier si l'animation se passe linéairement (au même rythme tout au long de l'animation), ou si l'animation ralentit en, dégressif, ou fait les deux.

Lorsque vous avez d'aller plus au métal et à l'utilisation d'OpenGL ES, vous n'êtes pas aussi chanceux. Nous n'avons pas les courbes d'animation prévu pour nous dans OpenGL ES. Nous avons d'interpoler nous-mêmes. Heureusement, les maths derrière les courbes d'animation est simple. De plus, il ya des courbes bien plus que l'offre d'Apple quatre.

Je n'ai pas couru à travers une bonne bibliothèque pour générer des courbes d'animation, j'ai donc décidé de libérer mes fonctions courbe d'animation dans le domaine public (aucun attribut nécessaire, aucun droit réservé). Voici un graphique de l'ensemble des courbes d'animation différente Je suis libérant:
Ease.png

Voici le documents originaux Numbers.app qui a généré le graphe, Et voici le Projet Xcode qui a généré les données. Le projet contient également toutes les fonctions nécessaires pour tracer ces courbes.

Apple ne documente pas où ils utilisent des calculs pour soulager, mais je suppose que ce sont quadratiques. Je ne suis pas sûr, cependant, car la plupart des courbes de rendement des résultats similaires.

Toutes les fonctions d'interpolation inclus dans le projet Xcode ci-dessus tiennent trois entrées et retourner une GLfloat contenant la valeur interpolée. Le premier paramètre, t, est le pour cent de la voie grâce à l'animation que vous voulez une valeur calculée pour. C'est un flotteur serré qui devrait être dans la plage de 0.0 à 1.0. Les valeurs supérieures à 1,0 seront considérées comme des valeurs inférieures à 1,0 et 0,0 sont traités par 0,0. Le deuxième paramètre, lancer, est la valeur quand l'animation commence. Le troisième paramètre, fin, est la valeur finale à être animé vers.

Si vous souhaitez appliquer une courbe à une CGPoint ou Vector3D, vous devez appeler la fonction à plusieurs reprises pour chaque composante (X / Y ou X / Y / Z).

Amusez-vous!

Voici les fonctions incluses dans le projet ci-dessus:

#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
#include <math.h>

#define BoundsCheck(t, start, end) \
if (t <= 0.f) return start; \
else if (t >= 1.f) return end;


GLfloat LinearInterpolation(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return t * end + (1.f - t) * start;
}

#pragma mark -
#pragma mark Quadratic
GLfloat QuadraticEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return -end * t * (t - 2.f) -1.f;
}

GLfloat QuadraticEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * t * t + start - 1.f;
}

GLfloat QuadraticEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.f;
if (t < 1.f) return end/2.f * t * t + start - 1.f;
t--;
return -end/2.f * (t*(t-2) - 1) + start - 1.f;
}

#pragma mark -
#pragma mark Cubic
GLfloat CubicEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t--;
return end*(t * t * t + 1.f) + start - 1.f;
}

GLfloat CubicEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * t * t * t+ start - 1.f;
}

GLfloat CubicEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.;
if (t < 1.) return end/2 * t * t * t + start - 1.f;
t -= 2;
return end/2*(t * t * t + 2) + start - 1.f;
}

#pragma mark -
#pragma mark Quintic
GLfloat QuarticEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t--;
return -end * (t * t * t * t - 1) + start - 1.f;
}

GLfloat QuarticEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * t * t * t * t + start;
}

GLfloat QuarticEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.f;
if (t < 1.f)
return end/2.f * t * t * t * t + start - 1.f;
t -= 2.f;
return -end/2.f * (t * t * t * t - 2.f) + start - 1.f;
}

#pragma mark -
#pragma mark Quintic
GLfloat QuinticEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t--;
return end * (t * t * t * t * t + 1) + start - 1.f;
}

GLfloat QuinticEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * t * t * t * t * t + start - 1.f;
}

GLfloat QuinticEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.f;
if (t < 1.f)
return end/2 * t * t * t * t * t + start - 1.f;
t -= 2;
return end/2 * ( t * t * t * t * t + 2) + start - 1.f;
}

#pragma mark -
#pragma mark Sinusoidal
GLfloat SinusoidalEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * sinf(t * (M_PI/2)) + start - 1.f;
}

GLfloat SinusoidalEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return -end * cosf(t * (M_PI/2)) + end + start - 1.f;
}

GLfloat SinusoidalEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return -end/2.f * (cosf(M_PI*t) - 1.f) + start - 1.f;
}

#pragma mark -
#pragma mark Exponential
GLfloat ExponentialEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * (-powf(2.f, -10.f * t) + 1.f ) + start - 1.f;
}

GLfloat ExponentialEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return end * powf(2.f, 10.f * (t - 1.f) ) + start - 1.f;
}

GLfloat ExponentialEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.f;
if (t < 1.f)
return end/2.f * powf(2.f, 10.f * (t - 1.f) ) + start - 1.f;
t--;
return end/2.f * ( -powf(2.f, -10.f * t) + 2.f ) + start - 1.f;
}

#pragma mark -
#pragma mark Circular
GLfloat CircularEaseOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t--;
return end * sqrtf(1.f - t * t) + start - 1.f;
}

GLfloat CircularEaseIn(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
return -end * (sqrtf(1.f - t * t) - 1.f) + start - 1.f;
}

GLfloat CircularEaseInOut(GLclampf t, GLfloat start, GLfloat end)
{
BoundsCheck(t, start, end);
t *= 2.f;
if (t < 1.f)
return -end/2.f * (sqrtf(1.f - t * t) - 1.f) + start - 1.f;
t -= 2.f;
return end/2.f * (sqrtf(1.f - t * t) + 1.f) + start - 1.f;
}


Le blog Petite Grashopper

Eh bien, je ne sais pas comment je n'ai jamais couru à travers l'avant, mais Philip Rideout, Auteur de O'Reilly iPhone 3D (Un livre que je recommande la semaine dernière), a un enfer d'un blog pour les personnes intéressées en OpenGL. Beaucoup de postes sont spécifiques à bureau OpenGL (et les versions récentes d'OpenGL à ça!), Mais il ya des tonnes d'informations qui s'applique à une grande OpenGL ES ainsi. C'est un véritable trésor de la bonté des graphiques de pointe à partir d'un gars qui a été fait pendant des années.

dimanche 18 mars 2012

Recommandation OpenGL ES livre

Depuis l'annulation de ma OpenGL ES 2.0 pour iOS 4 livre, j'ai eu plusieurs recommandations de personnes ouvrage demande à utiliser à la place de mon livre. Honnêtement, je n'ai pas vraiment eu un pour donner, avant aujourd'hui, en partie parce que j'ai intentionnellement évité la lecture de livres en compétition tout en travaillant sur le mien.

Aujourd'hui, alors coincé dans un train, j'ai vérifié sur Philip Rideout Programmation 3D iPhone par O'Reilly. Maintenant, il n'est jamais facile de donner un avis objectif sur un livre qui rivalise avec celui que vous avez écrit, et même si mon livre n'est pas actuellement sur un calendrier de production et je n'ai pas le temps de travailler dessus, j'ai tendance à toujours penser à moi comme travailler sur un livre d'OpenGL ES. Bien qu'il existe plusieurs choses que j'aurais faites différemment, je sais aussi qu'il est injuste de juger un livre de cette façon. Décider quoi inclure et quoi ne pas inclure dans un livre est une chose horriblement difficile avec un sujet vaste comme OpenGL ES et pas deux auteurs vont faire la même décision précise à cet égard, donc je ne vais pas critiquer Rideout Philippe pour, ainsi, pour ne pas être moi. L'enfer, normalement pas être pris comme moi est un peu un compliment de toute façon.

Pourtant, si ce n'est pas le livre que j'aurais écrit, je peux le recommander sans réserve. L'information est solide et utile et il est présenté d'une manière qui ne suppose pas ou exiger un doctorat en mathématiques. Une chose qui ne Rideout faire que je choisi de ne pas même tenter, est de donner à la fois l'OpenGL ES 1.1 et OpenGL ES 2.0 approche pour les tâches qui peuvent être faites dans les deux environnements, ce qui est réellement intéressant sur des motifs multiples. Un, c'est une grande transition pour les gens qui savent 1.1 mais pas 2.0, mais aussi, il montre les façons intéressantes de personnes ont trouvé pour contourner les limitations du pipeline fixe. Ces types de solutions me fascinent parce qu'ils sont le résultat de gens qui refusent d'accepter des limitations techniques.

Beaucoup (tous?) De la matière de ce livre est disponible en ligne gratuit, Mais je vous conseille d'acheter le livre, qui vous donne accès au code source du livre et aussi aidera également à obtenir un ange ses ailes. Eh bien, je ne suis pas sûr à 100% sur le dernier, mais il semble probable que ce temps de l'année.

Si vous êtes patauge un peu avec OpenGL ES, ce livre est bien utile de votre temps.

OpenGL ES Cours sur iTunes University

Ceux d'entre vous attendent pour le prochain chapitre de l'OpenGL ES 2.0 pour iOS vous pouvez faire une faveur en vérifiant ce cours sur iTunes University. C'est un cours de développement avancé iOS enseigné par Brad Larsson à la Madison Area Technical College, Et la leçon la plus récente se trouve sur OpenGL ES. Vous pouvez aussi trouver les notes de cours here.

OpenGL ES Update

Désolé pour le silence autour d'ici dernièrement.

Malheureusement, le prochain chapitre de l'OpenGL ES 2.0 Je prévois de publier contient des informations détaillées, étape par étape les instructions basées sur Xcode 4 (pour la plupart écrits à l'époque du DP2), qui est encore sous NDA. En conséquence, ce chapitre va prendre un peu plus de frotter, et je n'ai pas eu beaucoup de temps à frotter ces derniers temps.

En attendant, j'ai réalisé que je n'ai jamais lié à la PowerVR Insider SDK, Donc je suis rectifier cela. La société qui fabrique le GPU dans tous les appareils iOS a un SDK, vous pouvez télécharger - en fait, ils ont plusieurs versions de ce pour différentes plateformes, y compris iOS. La plupart du code est assez générique C + + avec juste assez d'Objective-C autour d'eux pour travailler, mais il ya une buttload métriques de code de bonne là pour faire toutes sortes de choses. Certainement en valeur la signature et le téléchargement, parce qu'ils vous montrer comment faire beaucoup de tâches courantes. Ce n'est pas très débutant-friendly, d'accord, mais toujours une grande ressource que vous devez connaître. La plupart du code est général OpenGL ES et pas vraiment spécifiques à leur matériel, même si certains des outils de texture et d'optimisations liées sont conçus pour des performances optimales sur leur matériel et, dans certains cas d'utilisation spécifiques au fournisseur d'extensions. Si vous êtes un dev iOS seule, ce n'est pas un problème du tout à moins d'Apple change leur fournisseur GPU.

OpenGL ES 2.0 pour iOS, Chapitre 4 - Présentation du pipeline programmable

Le code de ce chapitre peut être trouvé here.
Je l'ai mentionné OpenGL ES 2.0 de l ' pipeline programmable, Mais il peut ne pas être clair pour vous exactement ce que ce terme signifie. Si c'est le cas, disons clairement jusqu'à maintenant. Le terme «pipeline» se réfère à la séquence des événements, à partir de quand vous dites OpenGL ES de dessiner quelque chose (généralement appelé rendering), Par le point où les objets présentés ont été entièrement dessinée. Typiquement, un programme OpenGL ES est à plusieurs reprises le dessin comme le programme s'exécute, avec chaque image achevée début considéré comme un frame.

Versions d'OpenGL ES 2.0 avant (y compris 1.1, qui est soutenu par tous les appareils iOS) utilisé ce qu'on appelle un pipeline de rendu fixe, Ce qui signifie que l'image finale a été générée par OpenGL ES sans aucune chance pour vous de faire quelque chose. Un meilleur terme car il pourrait avoir été «pipeline fermé», parce que vous fourrer des choses dans un seul but, et il sort de l'autre bout et vous n'avez aucune possibilité de l'influencer une fois qu'il commence à descendre le pipeline

Dans le pipeline fixe, la totalité de l'image est rendue sur la base des valeurs que vous soumettez à OpenGL ES dans les appels de votre application API précédentes. Chaque fois que l'OpenGL ES 1.x rend quelque chose, il le fait en utilisant le même ensemble d'algorithmes et de calculs. Si vous voulez une lumière, par exemple, vous appelez une poignée de fonctions OpenGL ES dans votre code d'application pour définir le type de lumière que vous voulez, la position de la lumière, la force de la lumière, et peut-être un peu d'attributs d'autres. OpenGL ES 1.1 prend alors les informations que vous avez fournis et fait tout les calculs nécessaires pour ajouter la lumière à votre scène. Il figure sur la manière de l'ombre de vos objets afin qu'ils ressemblent à la lumière les frappe et les entraîne en conséquence. Le pipeline fixe, vous isole de beaucoup de choses. Il dit essentiellement: «Oh, miel ... me donner des informations sur votre scène, et ne vous inquiétez pas de votre jolie petite tête de toutes les mathématiques."

La bonne chose au sujet des programmes de pipeline fixe, c'est qu'il est conceptuellement simple et facile. Oh, je sais ... il ne feel facile quand vous êtes à l'apprendre, mais par rapport au pipeline programmable, l'idée de base est beaucoup plus facile à saisir. Vous souhaitez créer une vue qui simule la perspective? OpenGL ES sera essentiellement le faire pour vous si vous lui donnez une poignée d'entrées en utilisant un couple d'appels API. Souhaitez déplacer, faire pivoter ou redimensionner un objet? Il ya des fonctions pour le faire pour vous aussi. Voulez-vous ajouter une lumière ou six à la scène? Il suffit de faire quelques appels par la lumière avant de tirer, et vous êtes bon à faire.

La mauvaise chose au sujet de la canalisation fixe est qu'elle limite ce que vous pouvez faire. Un grand nombre de l'éclairage de fantaisie et d'effets de texture que vous voyez dans les jeux 3D modernes, par exemple, ne peut être créé facilement (ou pas du tout) en utilisant le pipeline fixe. Avec le pipeline fixe, vous êtes seulement en mesure de faire ce que les auteurs de la bibliothèque graphique anticipé vous pourriez avoir besoin de faire, dans la façon dont ils ont anticipé vous auriez besoin de le faire. Vous voulez un lens flare ou la profondeur de champ? Eh bien, vous pouvez probablement trouver un moyen de faire ce genre de choses en utilisant le pipeline fixe, mais il ne sera pas facile ni simple. Des gens sont venus avec quelques contournements vraiment ingénieux pour déjouer les limites de la canalisation fixe, mais même si vous parvenez à trouver un moyen de contourner les limitations de la canalisation fixe pour atteindre un certain effet, votre code est susceptible d'être un peu un hack --- et plus important encore, une partie du code que vous écrivez pour l'implémentation de cette fonctionnalité va probablement être exécuté dans le mauvais endroit pour de meilleures performances. Parlons pourquoi c'est, parce que c'est un élément essentiel de l'information une fois que nous commencer à travailler avec le pipeline programmable.

Architecture matérielle

OpenGL ES, vous isole d'avoir à code à tout un matériel spécifique, mais il est important de comprendre, au moins à un niveau très élevé, comment les appareils iOS calculer et d'afficher du contenu graphique. Chaque appareil iOS jamais fait a deux processeurs à l'intérieur. Ils ont tous un processeur à usage général a appelé le processeur, ainsi que d'un second processeur appelé GPU, ce qui signifie unité de traitement graphique.^ 1Le CPU peut ne plus rien vous devez faire, et c'est là où le code de votre application fonctionne principalement. Le processeur est très rapide à faire des opérations entières, mais pas n'importe où près aussi rapide quand il s'agit de faire des opérations en virgule flottante ^ 2. Le GPU, d'autre part, est beaucoup plus spécialisé. C'est bon pour faire un grand nombre de petits calculs en virgule flottante très rapidement. Il a été conçu pour travailler comme aide à la CPU pour gérer ces tâches que le CPU n'est pas particulièrement bon, plutôt que de servir comme un processeur autonome. La CPU, en substance, les mains hors de certaines tâches que le GPU est mieux à la scène. Avec deux processeurs travaillant en parallèle, l'appareil est capable de faire beaucoup plus de travail à la fois. Mais cette «aide» ne se fait pas automatiquement dans vos programmes.

Lorsque vous écrivez C, Objective-C ou C + + code dans Xcode, le code binaire compilé s'exécute sur le processeur. Il ya quelques bibliothèques, telles que Core Animation, qui implicitement la main hors tâches au GPU en votre nom, mais en général, vous devez utiliser des bibliothèques spéciales pour avoir accès au GPU. Heureusement, OpenGL ES, est juste une telle bibliothèque. Tous les deux avec le pipeline fixe et le pipeline programmable, la plupart du rendu OpenGL ES qui se passe sur le GPU. Cela fait sens, si vous pensez cela: des calculs pour les graphismes sont ce que le GPU a été conçu pour faire (d'où le «G» dans le GPU). Beaucoup de pipeline OpenGL ES 2.0 's, comme l'ensemble des canalisations fixes, est hors de votre contrôle. Il ya, cependant, deux endroits spécifiques où vous pouvez (et, en fait, doit) écrire du code. Le code que vous écrivez s'exécute sur le GPU et ne peut pas être écrite en Objective C, C ou C + +. Elle doit être écrite dans une langue particulière spécialement conçu à cet effet. Programmes que vous écrivez pour le pipeline programmable fonctionner sur le GPU et sont appelés shaders. La langue que vous écrivez dans les shaders GLSL est appelé, ce qui signifie GL Shading Language.

Le terme shader est un autre exemple de nommer non intuitif en OpenGL. Les shaders sont rien de plus que de petits morceaux de code qui s'exécutent sur le GPU au lieu du CPU. Parmi les tâches qu'ils accomplissent est le calcul de l'ombrage (ou couleur) de chaque pixel qui représente un des objets virtuels, mais ils peuvent faire beaucoup plus que cela. Les shaders sont des programmes à part entière écrite dans un langage de programmation Turing-complet.

OpenGL ES Shaders

Il existe deux types de shaders que vous pouvez écrire pour OpenGL ES: vertex shaders and fragment shaders. Ces deux shaders forment le "programmable" partie du pipeline OpenGL ES 2.0 programmable. Le langage GLSL que vous programmez ces shaders avec utilise une syntaxe C-like. Nous allons étudier quelques exemples simples de GLSL dans ce chapitre, et nous allons travailler avec lui longuement dans le reste du livre.

Une chose importante à réaliser sur les shaders, c'est qu'ils ne sont pas compilées lorsque vous générez votre application. Le code source de votre shader est stockée dans votre application bundle comme un fichier texte, ou dans votre code comme une chaîne littérale. A l'exécution, avant d'utiliser les shaders, votre application doit charger et de les compiler. La raison de cette compilation différée est de préserver l'indépendance de périphérique. Si les shaders ont été compilées quand vous avez construit votre application, puis d'Apple ont été changer pour un autre fabricant GPU pour une version iPhone de l'avenir, les shaders compilés pourrait très bien ne pas fonctionner sur le nouveau GPU. Reporter le compiler pour l'exécution évite ce problème, et tout le GPU --- même ceux qui n'existent pas lorsque vous créez votre application --- peut être entièrement pris en charge sans besoin de reconstruire votre application.

Vertex Shaders

Le shader qui passe d'abord dans le pipeline OpenGL ES est appelé le vertex shader parce qu'il s'exécute une fois pour chaque vertex que vous soumettez à OpenGL ES. Si vous soumettez une scène 3D avec un millier de sommets, le vertex shader sera appelée mille fois lorsque vous soumettez cette scène d'OpenGL ES à tirer, une fois par sommet. Le vertex shader est l'endroit où vous faites ce que des appels OpenGL ES imaginative vertex. C'est là que vous manipulez le déplacement, le détartrage, ou des objets en rotation, en simulant la perspective de la vision humaine, et de faire tout autre calcul qui affecte sommets ou dépend d'un certain morceau de données que vous avez sur une base par vertex.

Shaders n'ont pas de valeurs de retour, mais deux shaders de vertex et fragment ont exigé des variables de sortie que vous devez écrire une valeur avant la fin des années shaders main() fonction. Ces variables de sortie fonctionnent essentiellement comme des valeurs de retour exigé. Pour le vertex shader, la puissance requise est la position finale de l'actuel sommet. Rappelez-vous, le shader est appelée une fois pour chaque sommet, alors la sortie du shader est la position finale du sommet, le shader est en cours d'exécution pour. Dans certains cas, il peut juste être la valeur d'origine le sommet, mais le plus souvent, chaque sommet sera modifié en quelque sorte. Faire des calculs sur les sommets à l'échelle, faire pivoter ou déplacer un objet est quelque chose que le GPU est beaucoup mieux que le CPU, si typiquement, nous ne cherchons pas à mettre en œuvre ce genre de calculs dans notre code de l'application, mais au lieu de les faire ici le vertex shader. Une fois votre shader a calculé la position finale d'un sommet donné, il a besoin de définir une variable de sortie spécial appelé gl_Position. Si votre vertex shader ne pas écrire gl_Position, Il en résulte une erreur.

Il ya un hic cependant minimes. L' gl_Position variable est une vec4 variable, qui correspond à vecteur de 4. L' vec4 est un type de données qui contient quatre valeurs à virgule flottante. Vous vous souvenez probablement que dans un système de coordonnées cartésiennes, nous utilisons trois valeurs (X, Y, Z), et non pas quatre, et il semblerait donc que la puissance requise doit être un vec3, Qui contient trois valeurs à virgule flottante juste le Vertex3D struct nous avons écrit le dernier chapitre. Les trois premières valeurs dans gl_Position représenter les X cartésien, Y, Z et les valeurs pour le courant de vertex. La quatrième valeur est généralement appelée W. Ne vous inquiétez pas trop pourquoi il ya un élément supplémentaire. Il deviendra important quelques chapitres à partir de maintenant quand nous commençons à parler de quelque chose appelé matrice de transformations, Mais pour l'instant, il suffit de penser W comme une valeur de travail (qui n'est pas vraiment ce qu'il représente, cependant) que nous aurons besoin pour faire certains calculs à manipuler notre sommets. Sauf si vous savez w devrait être fixé à une valeur différente, elle a mis à 1,0.

Voici un exemple très simple d'un vertex shader:

void main() {     gl_Position = vec4(0.0, 0.0, 0.0, 1.0); } 

Tous ce shader ne se déplacer chaque vertex à l'origine. La fonction vec4() est intégré dans GLSL, et tout ce qu'il fait est de créer un type de vecteur avec quatre membres. Nous l'utilisons pour créer un sommet à l'origine (0,0,0) avec une valeur aw à 1.0. En attribuant une valeur à gl_Position, Nous sommes en indiquant la position finale de l'actuel sommet. Ce n'est pas, peut-être, un exemple très pratique fragment shader - tout modèle que vous soumettez à ce shader aurez transformé en un point à l'origine - mais il est un simple qui illustre comment vous définissez la valeur finale du sommet, qui est la tâche un tous les vertex shader doit faire chaque fois qu'il s'exécute.

Nous allons faire beaucoup de travail avec les vertex shaders au long du livre, ne vous inquiétez pas si vous n'avez pas bien les comprendre encore. C'est un sujet complexe, mais ils vont commencer à donner un sens une fois que vous les avez utilisés. Pour l'instant, les points importants à retenir à propos de vertex shaders sont les suivants:
  • Vertex shaders exécuté une fois pour chaque vertex qui attire OpenGL ES.
  • Vertex shaders doit définir gl_Position pour indiquer l'emplacement du sommet courant en utilisant les coordonnées cartésiennes (x, y, z), avec une valeur supplémentaire appelé W. Pour le moment, nous serons toujours ensemble W à à 1.

Fragment shaders

La deuxième partie du pipeline programmable OpenGL ES 2.0 programmable est appelé un fragment shader, Et il est appelé parce que, bien ... le fragment shader s'exécute une fois pour chaque fragment dans l'opération de dessin. Ce n'est probablement pas très utile, hein? Alors ... Qu'est-ce qu'un «fragment»?

Pensez à un fragment comme possibles pixel établi. Un fragment comprend toutes les différentes choses dans le monde virtuel qui pourrait potentiellement affecter la couleur finale d'un pixel est. Imaginez que d'une vue OpenGL ES sur votre iPhone ou iPad d'écran est une fenêtre sur un monde virtuel. Maintenant prenez un seul pixel de votre vue OpenGL. Si vous deviez prendre une tranche de votre monde virtuel à partir de ce pixel, et le déménagement dans le monde virtuel aussi loin que l'œil peut voir, tout ce qui se cache derrière ce pixel-ci constitue le fragment pour ce pixel. Parfois, vous verrez fragment shaders appelé pixel shaders. C'est effectivement un peu un abus de langage, mais il est utile pour visualiser un fragment.

Comme les vertex shaders, fragment shaders ont besoin d'une sortie, qui est la couleur finale du pixel qui correspond au fragment courant. Vous indiquez la couleur du pixel en définissant une variable spéciale appelée GLSL gl_FragColor. Voici le fragment shader simple possible; elle fixe simplement la couleur du fragment d'un bleu opaque:

void main() {     gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);   } 

Couleurs, comme nous l'avons vu dans le dernier chapitre, sont représentés par quatre composants dans OpenGL ES (rouge, vert, bleu et alpha) et OpenGL ES attend de ces composants dans cet ordre précis. GLSL n'a pas un type de données spécialement conçue pour les couleurs de portefeuille. Au lieu de cela, il utilise le même type de données qu'il utilise pour les vecteurs et les sommets, donc par la construction d'un vec4 (Un type de vecteur avec quatre membres de virgule flottante) avec ces quatre valeurs, nous créons une couleur dans laquelle le rouge et le vert sont mis à zéro, et le bleu et alpha sont mis à un, ce qui est d'un bleu opaque. En attribuant cette valeur à gl_FragColor, Nous disons à OpenGL ES comment dessiner le pixel correspondant à ce fragment.

On pourrait s'attendre à ce fragment shader pour créer une vue qui est entièrement rempli avec du bleu, mais ce n'est pas forcément ce qu'il fait. Comprendre cela vous aidera à comprendre la différence entre un fragment et un pixel. Chaque trame commence vide, avec l'arrière-plan définie sur une couleur spécifique - souvent noir, mais il peut être réglé à n'importe quelle couleur. Les données de vertex (et autres données) décrivant la scène à en tirer sont soumis à OpenGL ES, et une fonction est appelée pour lancer le pipeline de rendu. Si il n'y a rien dans le monde virtuel qui peut affecter un pixel d'écran particulier, le fragment shader ne fonctionne pas pour ce pixel; on obtient juste à gauche à la couleur de fond. C'est la raison pour laquelle le "pixel shader" terme n'est pas techniquement correct: un pixel dont aucun fragment correspondant ne sont pas traitées par le shader. Un fragment a un et un seul pixel, mais un pixel ne doit pas nécessairement avoir un fragment.


pixel_no_fragment.png


Cette scène contient une seule texture mappée objet. Toute la région qui est dessinée en noir sont pixels avec aucun fragment, car aucun objet dans la scène peut affecter leur couleur finale.


Ce que le fragment shader ci-dessus ne se fixe aucune pixel qui a une partie d'un ou plusieurs objets virtuels «derrière» (façon de parler) au bleu. C'est probablement un peu confus, mais il deviendra clair quand nous écrivons notre première application OpenGL ES dans le chapitre suivant. Pour l'instant, les points à retenir à propos fragment shaders sont les suivantes:
  • Fragment shaders exécuté une fois pour chaque fragment, ce qui signifie une fois pour chaque pixel dans lequel quelque chose peut potentiellement être tirées.
  • Fragment shaders doit définir gl_FragColor pour indiquer la couleur de ce pixel le fragment devrait être attirée.

Envoi de données à l'Shaders

Shaders n'ont pas accès à la mémoire principale de votre application. Toutes les données que d'un shader doit faire son travail doit être spécifiquement envoyés sur le GPU de votre code d'application. Envoi cette surcharge de données encourt et peut être un goulot d'étranglement dans le pipeline de rendu. Afin de maintenir les performances de rendu en place, il est important d'envoyer uniquement les données que votre shaders ont besoin. Il existe deux types de données que vous pouvez envoyer à partir de votre code d'application à votre shaders: attributes and uniforms.
Attributes
An attribute est une donnée pour laquelle vous avez une valeur distincte pour chaque sommet étant soumis. Si, par exemple, vous présentez une scène avec un millier de sommets, tous les attributs que vous passez doit contenir un millier de valeurs. Si vous avez un attribut de couleurs, vous devez passer de mille couleurs. Si vous avez un attribut de vecteurs, vous devez passer dans un millier de vecteurs. Vous aurez presque toujours au moins un attribut, contenant les coordonnées cartésiennes de chaque sommet pour être étirés ou, du moins, la position de départ de chaque sommet avant qu'il ne soit transformé par le processeur de vertex. Sans ces données, il n'ya vraiment aucun moyen de faire quelque chose dans votre vertex shader. Vous ne pouvez soumettre des données en virgule flottante dans un attribut, et non pas des données entières, si vous pouvez fournir plusieurs valeurs à virgule flottante à chaque sommet dans un seul attribut. Une couleur, par exemple, contient quatre nombres à virgule flottante, afin de fournir des données pour les attributs de couleur, vous devez fournir un tableau contenant quatre floats multiplié par le nombre de sommets d'être soumis. Cet attribut sera de même dans le shader vient comme un seul vec4.

Chaque fois que votre vertex shader s'exécute, le pipeline sera lui fournir juste la valeur qui correspond au sommet que le shader est exécuté pour. Donc, dans votre code d'application, les attributs sont représentés par un tableau avec une ou plusieurs valeurs pour chaque sommet, mais dans votre vertex shader, vous devez traiter qu'avec un seul bloc de données de ce tableau présenté, qui contient les valeurs qui correspondent aux l'actuel sommet. Nous allons voir comment envoyer les attributs de votre application au shader un peu plus tard dans le chapitre, mais voici comment vous travaillez avec un attribut insode votre vertex shader:

attribute vec4 position;  void main() {     gl_Position = position; } 

C'est assez simple: vous déclarez l'attribut dans la partie supérieure du shader, et c'est à peu près tout ce que vous avez à faire dans le shader de côté. Le pipeline OpenGL ES prend soin de remettre votre shader l'élément de données à chaque fois. Cela signifie que vous pouvez traiter l'attribut (position, Dans ce cas) comme une variable d'entrée, presque comme un argument à une fonction. Dans cet exemple, nous prenons la valeur de l'attribut position pour ce sommet et en l'assignant comme-est de l'spéciaux gl_Position variable de sortie. Dans ce cas, notre position finale pour chaque sommet est la position de départ qui nous a été fournie par notre code de l'application. Nous allons voir comment envoyer des attributs de notre code de l'application un peu plus tard dans ce chapitre -. Il ya une autre information nous avons besoin d'aller plus avant il sera logique
Uniforms
Uniforms sont le deuxième type de données que vous pouvez passer de votre code d'application à votre shaders. Les uniformes sont disponibles pour les shaders de vertex et fragment de deux - contrairement attributs, qui sont seulement disponibles dans le vertex shader. La valeur d'un uniforme ne peut pas être changé par les shaders, et aura la même valeur à chaque fois un shader fonctionne pour un trajet donné à travers le pipeline. Uniformes peut être à peu près n'importe quel type de données que vous voulez transmettre à utiliser dans votre shader.

Nous allons voir comment passer des uniformes à partir de votre code d'application un peu plus tard, mais dans votre shader, en travaillant avec un uniforme est comme travailler avec un attribut. Vous déclarez dans le haut et ensuite le traiter comme une valeur d'entrée dans votre code, comme ceci:

attribute vec4 position; uniform float translate;  void main() {     gl_Position = position;     gl_Position.y += translate; } 

Dans cet exemple, nous passons une valeur en virgule flottante appelée translate, Puis l'utiliser pour modifier les gl_Position variable de sortie, en déplaçant le sommet selon l'axe Y sur la valeur de l' translate uniforme. NB: Ce n'est pas ainsi que vous le feriez normalement déplacer un objet dans votre shader. Ceci est juste un exemple simple pour illustrer comment les uniformes de travail.

Varyings

Depuis les attributs sont disponibles uniquement dans le fragment shader et la valeur de l'uniforme ne peut pas être changé, comment le fragment shader savoir ce que les valeurs à utiliser lors de l'élaboration d'un pixel donné? Disons, par exemple, que nous avons un attribut contenant par vertex couleurs. Afin d'être en mesure de déterminer la couleur finale du pixel dans notre fragment shader, nous aurions besoin de l'accès à cette pièce particulière de l'information par vertex, ne ferions-nous?

Pourquoi, oui, nous serions. Et c'est là que quelque chose appelé un varying entre en scène. Varyings sont variables spéciales qui peuvent être transmis par le vertex shader pour le fragment shader, mais il est plus cool que ça en al'air. Il n'ya aucune relation entre les sommets et mis fragments. Alors, comment peut-on la valeur du vertex shader être utilisé plus tard dans le fragment shader? Comment le comprendre quelle valeur vertex à utiliser? Qu'est-ce qui se passe avec varyings est que la valeur définie dans le vertex shader est automatiquement interpolés pour une utilisation dans le fragment shader basé sur la distance relative des pixels du fragment de partir des sommets qui l'affectent. Regardons un exemple simple. Disons que nous sommes à tracer une ligne:

fragment.png
Un ensemble variant dans le vertex shader pour V1 et V2 auraient une valeur mi-chemin entre ces deux valeurs lorsque le fragment shader fonctionne pour le fragment F. Si la variable color a été mis au rouge dans le vertex shader pour V1 et au bleu dans le vertex shader pour V2, lorsque le fragment shader pour le fragment correspondant au pixel à F exécute et lit que variées, il contiendra ni bleu ni rouge. Au lieu de cela, il aura une couleur pourpre, à mi chemin entre le rouge et bleu parce que ce fragment est à peu près à mi-chemin entre ces deux sommets. Le pipeline détermine automatiquement quels sommets affectent le dessin d'un fragment de donnée et interpole automatiquement les valeurs fixées pour les varyings dans les vertex shaders basés sur les distances relatives des fragments de ceux sommets.

triangle.png


Varier l'interpolation n'est pas limité à l'interpolation des valeurs de deux sommets, que ce soit. Le gazoduc va comprendre tous les sommets qui influencent le fragment et de calculer la valeur correcte. Voici un exemple simple avec trois sommets ayant chacun une couleur différente.




Les variables sont faciles à utiliser: il vous suffit de les déclarer dans les deux shaders. Puis toute valeur que vous définissez dans le vertex shader sera disponible, sous forme interpolée, dans le fragment shader. Voici un exemple très simple d'un vertex shader qui attribue une valeur à partir d'une couleur par vertex à une variable:

attribute vec4 position; attribute vec4 color;  varying vec4 fragmentColor;  void main() {     gl_Position = position;     fragmentColor = color; } 

Dans cet exemple, color est la couleur de ce sommet qui a été transmis à partir de notre code d'application. Nous avons déclaré un varying called fragmentColor de nous laisser passer une valeur de couleur pour le fragment shader. Nous avons déclaré une vec4 parce que les couleurs sont composées de quatre valeurs composant. En plus d'établir gl_Position basé sur la valeur la position du vertex qui a été adoptée dans le shader en utilisant les position attribut, nous avons également affecter la valeur de la color par vertex attribuer à la variable appelée fragmentColor. Cette valeur sera ensuite disponible dans le fragment shader sous forme interpolée.

Screen shot 2010-11-01 at 8.00.15 PM.png


Dans le shader ci-dessus, si l'on a tracé une ligne et avait un attribut qui définit la couleur au premier point que le rouge et la couleur au second point que le bleu, c'est ce qui se dessiné.


Voici ce qu'un fragment shader simple en utilisant la même que la variation pourrait ressembler:

varying lowp vec4 fragmentColor;  void main() {     gl_FragColor = fragmentColor; } 

La déclaration de la variable dans le fragment shader a le même nom (fragmentColor) Comme il l'a fait dans le vertex shader. Ceci est important, si les noms ne correspondent pas, OpenGL ES ne réalisera pas que c'est la même variable. Il a également pour être le même type de données. Dans ce cas, il est vec4, Tout comme il a été dans le vertex shader. Notez, cependant, qu'il ya un mot clé supplémentaire, lowp. C'est un mot-clé GLSL utilisé pour spécifier le precision ou, en d'autres termes, le nombre d'octets utilisés pour représenter un nombre. Les octets de plus utilisé pour représenter un nombre, le moins de problèmes que vous aurez avec l'arrondi qui se passe nécessairement par des calculs en virgule flottante. Selon le degré de précision dont vous avez besoin, vous pouvez spécifier lowp, mediumpOu highp pour indiquer combien d'octets va stocker la valeur en virgule flottante alors qu'il est utilisé dans les shaders. Le nombre réel d'octets utilisés pour représenter une variable est décidé par OpenGL ES, mais le mot clé de précision vous permet de donner une indication sur la précision combien vous pensez que cela besoins variables dans cette situation.

GLSL permet à l'utilisateur de modificateurs de précision tout moment une variable est déclarée, mais c'est le seul endroit où cela est nécessaire. Si vous n'avez pas l'inclure lors de la déclaration varyings dans votre fragment shader, votre shader échouera à compiler. Dans d'autres endroits, le modificateur de précision est facultative et la spécification GLSL énonce un ensemble de règles qui seront utilisées pour déterminer la précision quand aucun modificateur explicite est fourni.

The lowp mot-clé qui va donner le meilleur rendement, mais le moins de précision lors de l'interpolation. Il est souvent le meilleur choix pour des choses comme les couleurs, où les petites erreurs d'arrondi ne sera pas vraiment d'importance. En cas de doute, commencer par lowp. Vous pouvez toujours augmenter la précision de mediump or highp si le manque de précision entraîne des problèmes dans votre application.

Tous nous le faisons avec la valeur de fragmentColor, Qui est la version de interpolée les valeurs de couleur définie dans le vertex shader, est-il assigner à gl_FragColor de sorte que le pixel est dessiné dans la couleur interpolée. Cela crée un gradient entre les sommets si ces sommets ne sont pas la même couleur.

Avant de regarder comment passer des attributs et des uniformes pour les shaders à partir de notre code d'application, nous devons d'abord parler de la façon shaders obtenir chargés et compilés, car la façon dont nous transmettons les données dans s'appuie sur ce mécanisme. Regardons maintenant, puis nous allons revenir à des attributs et des uniformes de l'autre côté de la canalisation.

OpenGL ES Programmes

Shaders toujours travailler par paires dans OpenGL ES. À un moment donné, il peut y avoir qu'un seul shader de sommet actif et un fragment shader actif, et quand vous dites OpenGL ES de dessiner quelque chose, un shader de vertex et fragment actif doit déjà être en place. Même si une seule paire shader peut être actif à un instant donné, vous pouvez avoir paires shader différent pour dessiner des objets différents. Cela vous permet, par exemple, appliquer un éclairage différent ou des effets différents à des objets dans la même scène.

OpenGL ES est un concept appelé program qui combine un vertex shader et fragment shader avec leurs attributs dans un objet OpenGL ES unique. Vous pouvez créer autant de ces programmes que vous voulez, mais un seul d'entre eux peut être actif à un moment précis. Si vous faites un programme actif, le programme qui a été précédemment actif devient inactif. Généralement, les programmes sont créés et les shaders chargés et compilés lorsque votre application démarre, ou à un autre moment avant de réellement être le dessin, comme lors du chargement d'un niveau dans un match. Vous ne voulez pas attendre jusqu'à ce que vous avez besoin du shader de charger et de le compiler, car cela peut être une opération coûteuse qui causerait un hoquet notable dans le processus de dessin.

Chargement des programmes et de les préparer à utiliser est un peu un processus impliqué. Voici le flux de base:

  1. Créer et compiler les shaders. Les étapes suivantes doivent être effectuées deux fois par --- une fois pour le vertex shader, et encore pour le fragment shader:

    1. Chargez le code source du shader en mémoire.
    2. Call glCreateShader() pour créer un objet Shader vide, sauver la valeur retournée pour faire référence à ce shader dans les futurs appels.
    3. Use glShaderSource() de passer l'objet Shader nouvellement créé son code source.
    4. Call glCompileShader() pour compiler le shader.
    5. Use glGetShaderiv() pour vérifier l'état de compiler et faire en sorte que le shader compilé correctement.
  2. Call glCreateProgram() de créer un programme vide et sauver la valeur retournée de sorte que vous pouvez utiliser le programme dans les futurs appels.
  3. Fixez les deux shaders pour le programme en utilisant glAttachShader().
  4. Supprimer les shaders à l'aide glDeleteShader(). Le programme aura fait sa propre copie des shaders, afin de supprimer entre eux n'a pas empêcher le programme de travail.
  5. Liez chacun des attributs du vertex shader pour le programme en utilisant glBindAttribLocation().
  6. Lier le programme à l'aide glLinkProgram().
  7. Lorsque vous voulez utiliser ce programme pour la première fois, ou si vous voulez changer le programme actif à ce programme, appelez glUseProgram().
  8. Lorsque vous avez terminé avec un programme, de s'en débarrasser à l'aide glDeleteProgram().

Ce qui suit est un exemple d'un code assez typique OpenGL ES chargement du programme pour iOS 4. Ne pas trop se soucier de ce que cela fait, il suffit de numériser sur et et secouer un peu la tête:

GLuint          program;         GLuint          vertShader;          GLuint          fragShader;          GLint           status; const   GLchar          *source;  NSString *vertShaderPathname = [[NSBundle mainBundle] pathForResource:@"shader"                                                                 ofType:@"vsh"]; source = (GLchar *)[[NSString stringWithContentsOfFile:vertShaderPathname                                                encoding:NSUTF8StringEncoding                                                   error:nil] UTF8String]; if (!source) {     // Deal with error }  vertShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(*vertShader, 1, &source, NULL); glCompileShader(*vertShader);  glGetShaderiv(*vertShader, GL_COMPILE_STATUS, &status); if (status == 0) {     glDeleteShader(*vertShader);     // Deal with error }  NSString *fragShaderPathname = [[NSBundle mainBundle] pathForResource:@"shader"                                                                 ofType:@"fsh"]; source = (GLchar *)[[NSString stringWithContentsOfFile:fragShaderPathname                                                encoding:NSUTF8StringEncoding                                                   error:nil] UTF8String]; if (!source) {     // Error checking }  fragShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(*fragShader, 1, &source, NULL); glCompileShader(*fragShader);  glGetShaderiv(*fragShader, GL_COMPILE_STATUS, &status); if (status == 0) {     glDeleteShader(*fragShader);     // Error checking! }  glAttachShader(program, vertShader); glAttachShader(program, fragShader); glBindAttribLocation(program, 1, "position");  glLinkProgram(program);  glGetProgramiv(program, GL_LINK_STATUS, &status); if (status == 0)     return NO;  if (vertShader)     glDeleteShader(vertShader); if (fragShader)     glDeleteShader(fragShader);  glUseProgram(program);
C'est assez moche, n'est-ce pas? Ce n'est pas beaucoup de plaisir à écrire, non plus. Heureusement, nous pouvons simplifier le processus un peu en créant notre propre classe wrapper Objective-C pour représenter les programmes OpenGL ES. Au lieu de marcher à travers le code ci-dessus et en l'examinant, nous allons ensemble cette même fonctionnalité en une forme plus réutilisables et en discuter, à la place. Cela tue deux oiseaux avec une pierre: elle nous permet de parcourir et de comprendre les processus impliqués dans la création de programmes en OpenGL ES, et rend notre vie plus facile sur la route en nous évite d'avoir à écrire du code méchants comme ça à chaque fois que nous avons besoin pour créer un programme.
La rédaction du GLProgram class
Ouvrez Xcode ou un éditeur de texte et de créer deux fichiers texte vides. Appelez l'un d'eux GLProgram.h et l'autre GLProgram.m. Nous allons utiliser cette classe dans chacun des projets que nous créons dans ce livre, alors assurez-vous de sauver les deux fichiers quelque part, vous pouvez les trouver facilement. Ou, si vous préférez, de copier ma version à partir du dossier de code fourni avec le livre.

Mettez le code suivant dans GLProgram.h:

#import <Foundation/Foundation.h> #import <OpenGLES/ES2/gl.h> #import <OpenGLES/ES2/glext.h>  @interface GLProgram : NSObject  {  } - (id)initWithVertexShaderFilename:(NSString *)vShaderFilename  fragmentShaderFilename:(NSString *)fShaderFilename; - (void)addAttribute:(NSString *)attributeName; - (GLuint)attributeIndex:(NSString *)attributeName; - (GLuint)uniformIndex:(NSString *)uniformName; - (BOOL)link; - (void)use; - (NSString *)vertexShaderLog; - (NSString *)fragmentShaderLog; - (NSString *)programLog; @end 

Jetez un oeil au fichier d'en-tête que nous venons de créer, remarquez que nous n'avons pas créé de propriétés, et nous n'avons pas toutes les variables d'instance dans notre tête. Nous n'avons pas exposés ici quelque chose car il ne doit pas être une nécessité pour d'autres classes d'avoir un accès direct à n'importe lequel de nos variables d'instance. Tout le programme a besoin de faire doivent être manipulés en utilisant des méthodes différentes sur notre GLProgram object.


Nouveau Objective-C Caractéristiques

Parce que ce livre se concentre sur iOS 4, je suis sur un grand nombre de nouvelles fonctionnalités en Objective-C 2.0 et 2.1. Une instance est en GLProgram: J'ai utilisé la capacité de nouvelles Objective-C de déclarer des variables d'instance dans une extension de classe. Cela me permet d'avoir des variables d'instance privées qui ne sont pas annoncés à d'autres classes parce qu'ils ne sont pas contenues dans le fichier d'en-tête de ma classe ». Cette fonctionnalité n'est pas disponible sur l'iOS avant le SDK 4.0, cependant, si vous essayez d'utiliser certains des échantillons de code de ce livre dans les anciennes versions du SDK, vous pouvez obtenir problèmes de compilation. Si vous rencontrez ce problème, copiez les déclarations variable d'instance de l'extension de classe dans le fichier d'en-tête de la classe.

La première méthode dans notre classe est notre méthode d'initialisation. Il prend le nom du fichier contenant le code source de vertex shader et le nom du fichier qui contient le code source fragment shaders comme arguments. Cette méthode charge la source et compile les shaders dans le cadre de l'initialisation de l'objet.

Après cela, nous avons la méthode qui sera utilisée pour ajouter des attributs à notre programme, suivie par deux méthodes qui peuvent être utilisés pour récupérer les valeurs d'index pour un attribut donné, ou uniforme. Ces valeurs de l'indice sont utilisés pour fournir des données pour les shaders et peuvent être récupérés à tout moment après le programme est lié. Tous les attributs du programme doit être ajouté au programme avant de lier.

La méthode suivante, nous déclarons, link, Est similaire à la liaison qui se passe après que vous compiler le code source de votre application. Xcode poignées compiler et lier en une seule étape lorsque vous créez votre application, mais avec les shaders, c'est une étape nécessaire distincts qui relie tous les différents composants et les prépare à utiliser. Nous ne pouvions pas bon lien après nous avons compilé les shaders OpenGL, car a besoin de connaître les attributs du programme avant qu'il ne puisse lier correctement.

The use méthode est appelée lorsque nous voulons attirer l'utilisation des shaders de ce programme. Vous pouvez appeler cette méthode à plusieurs reprises, vous permettant de basculer entre les shaders à l'exécution.

Les trois dernières méthodes sont principalement à des fins de débogage. Depuis les shaders sont compilés à l'exécution, et non pas du temps de construction, une erreur de syntaxe ou autre problème dans un shader ne causera pas de construire notre application à l'échec dans Xcode, mais il fera le shader compiler et / ou le lien du programme à l'échec à l'exécution. Si les link retour de la méthode NOCes trois méthodes sont comment nous pouvons trouver ce qui n'allait pas afin que nous puissions y remédier.

Assurez-vous que vous enregistrez GLProgram.h, Puis passer à l'autre fichier texte que vous avez nommé GLProgram.m et mettre le code suivant dans celle-ci (ou vous pouvez simplement copier la mine du dossier du livre de code source):

#import "GLProgram.h" #pragma mark Function Pointer Definitions typedef void (*GLInfoFunction)(GLuint program,      GLenum pname,      GLint* params); typedef void (*GLLogFunction) (GLuint program,      GLsizei bufsize,      GLsizei* length,      GLchar* infolog); #pragma mark - #pragma mark Private Extension Method Declaration @interface GLProgram() {     NSMutableArray  *attributes;     NSMutableArray  *uniforms;     GLuint          program,         vertShader,          fragShader; } - (BOOL)compileShader:(GLuint *)shader      type:(GLenum)type      file:(NSString *)file; - (NSString *)logForOpenGLObject:(GLuint)object      infoCallback:(GLInfoFunction)infoFunc      logFunc:(GLLogFunction)logFunc; @end #pragma mark -  @implementation GLProgram - (id)initWithVertexShaderFilename:(NSString *)vShaderFilename      fragmentShaderFilename:(NSString *)fShaderFilename {     if (self = [super init])     {         attributes = [[NSMutableArray alloc] init];         uniforms = [[NSMutableArray alloc] init];         NSString *vertShaderPathname, *fragShaderPathname;         program = glCreateProgram();          vertShaderPathname = [[NSBundle mainBundle]              pathForResource:vShaderFilename              ofType:@"vsh"];         if (![self compileShader:&vertShader              type:GL_VERTEX_SHADER              file:vertShaderPathname])             NSLog(@"Failed to compile vertex shader");  // Create and compile fragment shader         fragShaderPathname = [[NSBundle mainBundle]              pathForResource:fShaderFilename              ofType:@"fsh"];         if (![self compileShader:&fragShader              type:GL_FRAGMENT_SHADER              file:fragShaderPathname])             NSLog(@"Failed to compile fragment shader");          glAttachShader(program, vertShader);         glAttachShader(program, fragShader);     }      return self; } - (BOOL)compileShader:(GLuint *)shader      type:(GLenum)type      file:(NSString *)file {     GLint status;     const GLchar *source;      source =          (GLchar *)[[NSString stringWithContentsOfFile:file          encoding:NSUTF8StringEncoding          error:nil] UTF8String];     if (!source)     {         NSLog(@"Failed to load vertex shader");         return NO;     }      *shader = glCreateShader(type);     glShaderSource(*shader, 1, &source, NULL);     glCompileShader(*shader);      glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);     return status == GL_TRUE; } #pragma mark - - (void)addAttribute:(NSString *)attributeName {     if (![attributes containsObject:attributeName])     {         [attributes addObject:attributeName];         glBindAttribLocation(program,              [attributes indexOfObject:attributeName],              [attributeName UTF8String]);     } } - (GLuint)attributeIndex:(NSString *)attributeName {     return [attributes indexOfObject:attributeName]; } - (GLuint)uniformIndex:(NSString *)uniformName {     return glGetUniformLocation(program, [uniformName UTF8String]); } #pragma mark - - (BOOL)link {     GLint status;      glLinkProgram(program);     glValidateProgram(program);      glGetProgramiv(program, GL_LINK_STATUS, &status);     if (status == GL_FALSE)         return NO;      if (vertShader)         glDeleteShader(vertShader);     if (fragShader)         glDeleteShader(fragShader);      return YES; } - (void)use {     glUseProgram(program); } #pragma mark - - (NSString *)logForOpenGLObject:(GLuint)object      infoCallback:(GLInfoFunction)infoFunc      logFunc:(GLLogFunction)logFunc {     GLint logLength = 0, charsWritten = 0;      infoFunc(object, GL_INFO_LOG_LENGTH, &logLength);         if (logLength < 1)         return nil;      char *logBytes = malloc(logLength);     logFunc(object, logLength, &charsWritten, logBytes);     NSString *log = [[[NSString alloc] initWithBytes:logBytes          length:logLength          encoding:NSUTF8StringEncoding]          autorelease];     free(logBytes);     return log; } - (NSString *)vertexShaderLog {     return [self logForOpenGLObject:vertShader          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog];  } - (NSString *)fragmentShaderLog {     return [self logForOpenGLObject:fragShader          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog]; } - (NSString *)programLog {     return [self logForOpenGLObject:program          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog]; } #pragma mark - - (void)dealloc {     [attributes release];     [uniforms release];      if (vertShader)         glDeleteShader(vertShader);      if (fragShader)         glDeleteShader(fragShader);      if (program)         glDeleteProgram(program);      [super dealloc]; } @end

Profitons de cette pièce par pièce et assurez-vous que nous sommes clairs sur ce qu'il fait. La première section pourrait sembler un peu déroutant. Nous avons défini deux types de données pour représenter les pointeurs de fonction:

typedef void (*GLInfoFunction)(GLuint program,      GLenum pname,      GLint* params); typedef void (*GLLogFunction) (GLuint program,      GLsizei bufsize,      GLsizei* length,      GLchar* infolog);

Pendant l'écriture du code pour les trois méthodes journal, il est devenu clair que les trois méthodes étaient presque identiques. Les deux journaux shaders étaient exactement les mêmes sauf pour la valeur passée dans les deux fonctions OpenGL ES. Le fichier journal du programme avait une logique presque identique, sauf qu'il a utilisé deux différents appels d'API OpenGL ES pour récupérer les données du journal. Cependant, ces fonctions ont exactement les mêmes arguments dans les deux cas. Cela nous permet d'écrire une méthode générique pour gérer les trois types de journaux en acceptant les pointeurs de fonction comme paramètre, le raccourcissement du code, et de le rendre plus facile à maintenir car la logique --- log n'aurait pas à être répété. Ces définitions de type de rendre le code avec des pointeurs de fonctions faciles à lire.

Ensuite, nous utilisons une extension d'Objective-C pour déclarer les variables d'instance et de deux méthodes privées de deux méthodes. La variable de première instance que nous avons est un tableau modifiable qui sera utilisé pour suivre les attributs du programme. Il n'y a aucune raison de garder une trace de varyings ou des uniformes. Le varyings sont strictement entre les deux shaders, et de déclarer une variable dans les deux shaders est tout ce qu'il faut pour le créer. Nous avons également n'avez pas besoin de garder une trace des uniformes parce OpenGL ES assignera chacun des uniformes une valeur d'index quand il relie le programme. Avec des attributs, cependant, nous devons arriver à un numéro d'index pour chacun d'eux et de dire ce que OpenGL ES numéro d'index que nous utilisons pour l'attribut quand on les lier. OpenGL ES ne pas céder indices attribut pour nous pour les attributs. S'en tenir les attributs dans un tableau et en utilisant les valeurs de l'indice du tableau est le moyen le plus facile à manipuler que la tâche en Objective-C, c'est ce que nous faisons.

Après le tableau, nous avons trois GLuints. Ce sont pour garder la trace des nombres que l'OpenGL ES assigne pour identifier notre programme et de ses deux shaders.

Puis nous avons deux méthodes privées, qui sont des méthodes qui seront utilisées au sein de cette classe, mais que le code en dehors de cette classe ne devrait jamais besoin d'accéder. L'une est une méthode qui compile un shader. Depuis le processus de compilation d'un shader de fragment et un vertex shader est exactement la même, nous créons une méthode pour faire les deux. La deuxième méthode est la méthode log générique mentionné précédemment qui est utilisé par les trois méthodes de log public.

#pragma mark - #pragma mark Private Extension Method Declaration @interface GLProgram() {     NSMutableArray  *attributes;     NSMutableArray  *uniforms;     GLuint          program,         vertShader,          fragShader; } - (BOOL)compileShader:(GLuint *)shader      type:(GLenum)type      file:(NSString *)file; - (NSString *)logForOpenGLObject:(GLuint)object      infoCallback:(GLInfoFunction)infoFunc      logFunc:(GLLogFunction)logFunc; @end

Après cela, nous avons une init méthode. Cette méthode prend le nom des deux shaders (sans l'extension), les charges et tente de compiler tous les deux, puis crée un programme pour les retenir. Une fois qu'il a un programme, il attache les deux shaders pour le programme et retourne l'objet initialisé. Elle crée également le tableau modifiable qui sera utilisé pour stocker les informations d'attributs. Si les shaders ne pas compiler, il renvoie toujours un objet valide. Si nous devions libérer l'objet et le retour nil, Nous n'aurions aucun moyen pour arriver à des données du journal qui me dit ce qui n'allait pas. En retournant un objet valide lorsque la compilation shaders échoue, le link étape va échouer et retourner NO, Qui sera l'indication du code appelant que quelque chose s'est mal passé et les journaux doivent être vérifiées.

- (id)initWithVertexShaderFilename:(NSString *)vShaderFilename      fragmentShaderFilename:(NSString *)fShaderFilename {     if (self = [super init])     {         attributes = [[NSMutableArray alloc] init];         uniforms = [[NSMutableArray alloc] init];         NSString *vertShaderPathname, *fragShaderPathname;         program = glCreateProgram();          vertShaderPathname = [[NSBundle mainBundle]              pathForResource:vShaderFilename              ofType:@"vsh"];         if (![self compileShader:&vertShader              type:GL_VERTEX_SHADER              file:vertShaderPathname])             NSLog(@"Failed to compile vertex shader");          // Create and compile fragment shader         fragShaderPathname = [[NSBundle mainBundle]              pathForResource:fShaderFilename              ofType:@"fsh"];         if (![self compileShader:&fragShader              type:GL_FRAGMENT_SHADER              file:fragShaderPathname])             NSLog(@"Failed to compile fragment shader");          glAttachShader(program, vertShader);         glAttachShader(program, fragShader);     }      return self; }
Pour réellement charger et compiler les shaders, la méthode init appelle la méthode suivante dans le fichier deux fois, pour chaque shader:

- (BOOL)compileShader:(GLuint *)shader      type:(GLenum)type      file:(NSString *)file {     GLint status;     const GLchar *source;      source =          (GLchar *)[[NSString stringWithContentsOfFile:file                                               encoding:NSUTF8StringEncoding                                                  error:nil] UTF8String];     if (!source)     {         NSLog(@"Failed to load vertex shader");         return NO;     }      *shader = glCreateShader(type);     glShaderSource(*shader, 1, &source, NULL);     glCompileShader(*shader);      glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);     return status == GL_TRUE; }
Le fichier contenant la source de shader est chargé de l'application bundle. Si la méthode est incapable de charger le fichier spécifié, il retourne NO. Si elle a pu obtenir source du shader, puis il utilise OpenGL ES fonctions API pour créer un shader, donner le shader nouvellement créé le code source chargé, puis le compiler. Après la compilation, le statut de compilation est vérifiée et une valeur retournée selon si le shader est compilé avec succès.

Une fois qu'une GLProgram Ainsi a été créé et initialisé, la prochaine chose que nous devons faire est de lui dire quels sont les attributs les utilisations vertex shader. La méthode suivante dans le fichier est utilisé à cette fin:

- (void)addAttribute:(NSString *)attributeName {     if (![attributes containsObject:attributeName])     {         [attributes addObject:attributeName];         glBindAttribLocation(program,              [attributes indexOfObject:attributeName],              [attributeName UTF8String]);     } }

Cette méthode vérifie que l'attribut n'a pas déjà été ajouté à la attributes tableau avant de l'ajouter, car les attributs doivent avoir des noms uniques. Il appelle également glBindAttribLocation() de laisser OpenGL ES savoir sur l'attribut. Rappelez-vous: OpenGL ES a besoin de connaître tous les attributs avant de lier le programme, et c'est ainsi que nous le faisons. Les attributs sont identifiés par leurs numéros d'index, et nous indiquer le numéro d'index de mon tableau quand nous appelons glBindAttribLocation(). Cela garantit que chaque attribut a une valeur d'index unique. L'approche traditionnelle pour les attributs est de créer une enum pour chacun des attributs à utiliser, mais notre approche rend le code un peu plus lisible et la fonctionnalité du programme plus autonome.

Uniformes n'ont pas besoin d'être gardé la trace de ou ajouté avant de lier. OpenGL va attribuer à chaque uniforme, un indice sans l'entrée. Lorsque les shaders sont compilés, OpenGL ES fera découvrir les uniformes. Quand nous lier le programme, OpenGL ES assignera chacun des uniformes utilisés dans les shaders une valeur d'index.


Attributs et indices uniforme



Pourquoi les indices d'attributs doivent être spécifiés avant de lier, mais les indices uniformes sont assignés par OpenGL ES sans apport? Je ne sais pas. Autant que j'ai pu découvrir, la raison de la différence n'est pas spécifiquement documenté.

J'ai une théorie, toutefois, que cela peut être dû à la façon dont les attributs et les uniformes sont stockés. Tous les attributs de prendre au moins l'espace d'un vec4. Cela signifie que, si vous avez un attribut qui contient une valeur unique point flottant pour chaque sommet, il va toujours prendre la même quantité d'inscrire l'espace sur le GPU comme un attribut qui contient quatre valeurs à virgule flottante pour chaque vertex.


Uniformes, d'autre part, sont emballées de façon plus efficace dans l'espace registre disponible sur le GPU. Si nous avons quatre float uniformes, par exemple, ils seront rassemblés en un seul registre. Pour ce faire, OpenGL ES peuvent avoir à réorganiser les uniformes de rendre l'utilisation plus efficace de l'espace disponible.

Il semble probable que, puisque les attributs ne sera pas emballé et ne seront donc pas être réorganisées durant la phase de construction; par conséquent, OpenGL ES peut nous laisser choisir nos valeurs d'index pour les attributs. Toutefois, OpenGL ES prend la responsabilité d'assigner les valeurs pour les uniformes de sorte qu'il peut faire le meilleur usage de l'espace de registre à la disposition.

Vous pouvez lire plus sur la façon GLSL fonctionne en lisant les spécifications GLSL pour OpenGL ES (qui est différent de la spécification OpenGL GLSL pour régulières) ici: http://www.khronos.org/files/opengles_shading_language.pdf. En fait, une fois que vous en avez fini avec le livre et ont un peu de réconfort avec la façon générale dont OpenGL ES fonctionne, je recommande fortement la lecture de la spécification. Il peut être un peu sec, mais il est plein d'informations que vous devez savoir si vous faites aucune programmation sérieuse avec OpenGL ES.

Des informations spécifiques sur l'emballage uniforme peut être trouvée dans l'Annexe A, partie 7.

Les deux méthodes suivantes il suffit de retourner le nombre d'index pour un attribut donné, ou uniforme. Pour l'attribut, il sera de retour l'index du tableau parce que c'est ce que nous dit l'OpenGL ES à utiliser lorsque nous avons appelé glBindAttribute(). Pour les uniformes, nous devons nous demander OpenGL ES pour nous donner la valeur de l'indice qu'il affecté au moment de liaison. Notez que ces deux méthodes impliquent faisant cordes compare, si possible, ils devraient être appelés qu'une seule fois. La classe contrôleur qui crée l'instance de GLProgram devrait probablement garder une trace des valeurs renvoyées par attributeIndex: and uniformIndex:. Recherches sont coûteuses cordes assez leur faire quelques centaines de fois par seconde pourrait avoir un impact notable sur le dessin de performance.

- (GLuint)attributeIndex:(NSString *)attributeName {     return [attributes indexOfObject:attributeName]; } - (GLuint)uniformIndex:(NSString *)uniformName {     return glGetUniformLocation(program, [uniformName UTF8String]); }

La prochaine étape est la méthode qui est appelée à relier le programme après les attributs ont été ajoutés. Il fait le lien et valide le programme, récupère alors l'état du lien. Si le lien a échoué, nous avons immédiatement le retour NO. Si l'opération s'est passé avec succès un lien, nous supprimons les deux shaders et puis revenir YES pour indiquer la réussite. La raison pour laquelle nous ne supprimez pas les shaders quand le lien ne l'est notre objet sera encore l'accès aux journaux shader, et nous pouvons débogage si quelque chose va mal. Une fois un shader est supprimé, son journal sont allés aussi.

- (BOOL)link {     GLint status;      glLinkProgram(program);     glValidateProgram(program);      glGetProgramiv(program, GL_LINK_STATUS, &status);     if (status == GL_FALSE)         return NO;      if (vertShader)         glDeleteShader(vertShader);     if (fragShader)         glDeleteShader(fragShader);      return YES; }

La méthode pour faire de ce programme un actif est appelé use, Et il ne fait rien de plus que d'appeler une méthode simple OpenGL ES, en passant program:

- (void)use {     glUseProgram(program); }

Les quatre prochaines méthodes sont les méthodes les journaux. Comme je l'ai mentionné précédemment, nous avons une méthode privée qui gère la fonctionnalité, et que cette méthode est appelée par la méthode des trois publics. La façon dont vous avez des logs d'OpenGL ES est une école de petite vieille. Non, c'est une école ancien lot. C'est pratiquement médiévale. Nous devons d'abord demander à OpenGL ES pour nous dire combien de temps le journal spécifique qui nous intéresse est donc allouer un buffer de considérer que beaucoup de données, puis récupérez le long dans ce tampon. Dans notre cas, nous avons ensuite transformer ces personnages dans une NSString and free() la mémoire tampon avant de retourner le NSString par exemple avec les données du journal:

- (NSString *)logForOpenGLObject:(GLuint)object      infoCallback:(GLInfoFunction)infoFunc      logFunc:(GLLogFunction)logFunc {     GLint logLength = 0, charsWritten = 0;      infoFunc(object, GL_INFO_LOG_LENGTH, &logLength);         if (logLength < 1)         return nil;      char *logBytes = malloc(logLength);     logFunc(object, logLength, &charsWritten, logBytes);     NSString *log = [[[NSString alloc] initWithBytes:logBytes          length:logLength          encoding:NSUTF8StringEncoding]          autorelease];     free(logBytes);     return log; }

Les trois prochaines méthodes sont les méthodes les journaux grand public, et ils sont tous simplement appeler la méthode privée ci-dessus:

- (NSString *)vertexShaderLog {     return [self logForOpenGLObject:vertShader          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog];  } - (NSString *)fragmentShaderLog {     return [self logForOpenGLObject:fragShader          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog]; } - (NSString *)programLog {     return [self logForOpenGLObject:program          infoCallback:(GLInfoFunction)&glGetProgramiv          logFunc:(GLLogFunction)&glGetProgramInfoLog]; }

Enfin, nous avons nos dealloc méthode, qui libère le tableau modifiable, puis vérifie les deux shaders et le programme, et si aucun d'entre eux sont non-nulle, cela signifie qu'il ya un objet OpenGL ES qui doit être supprimé, afin que nous les supprimer.

- (void)dealloc {     [attributes release];     [uniforms release];      if (vertShader)         glDeleteShader(vertShader);      if (fragShader)         glDeleteShader(fragShader);      if (program)         glDeleteProgram(program);      [super dealloc]; }

Vous avez tout compris? Bon. Maintenant vous pouvez oublier l'essentiel. Vous devez vous souvenir de ce que les programmes, les shaders, les attributs et les uniformes sont et comment ils se rapportent les uns aux autres, mais vous pouvez oublier les moindres détails de la création de programmes. Certains type d'explication ou d'encouragement ici? Pourquoi était-il important de passer par tout cela? A partir de maintenant, il suffit d'utiliser GLProgram pour charger vos shaders. Prenons un coup d'œil maintenant à la façon d'utiliser GLProgram.

Using GLProgram

Utilisation de la GLProgram objet que nous venons de créer est relativement facile. Vous devez d'abord allouer et initialiser une instance en fournissant les noms des deux fichiers contenant le code source du shader ", laissant hors de la .vsh and .fsh extensions.

GLProgram *theProgram = [[GLProgram alloc] initWithVertexShaderFilename:@"Shader" fragmentShaderFilename:@"Shader"]; 

Ensuite, ajouter les attributs utilisés dans votre shader au programme. Si vous aviez deux attributs, l'un avec la position de chaque sommet a appelé position, Et une avec une couleur pour chaque sommet a appelé color, Votre code d'ajouter des attributs ressemblerait à ceci:

[program addAttribute:@"position"]; [program addAttribute:@"color"]; 

Après avoir ajouté les attributs, les liens du programme. Si le programme est incapable de lien, il sera de retour NO et vous devriez vider le logs sur la console de sorte que vous pouvez déboguer le problème. Une fois que vous avez jeté les journaux, c'est une bonne idée de publier le programme, afin de libérer la mémoire qu'ils utilisent, et si vous n'essayez pas d'utiliser un programme non valides:

if (![program link]) { NSLog(@"Link failed"); NSString *progLog = [program programLog]; NSLog(@"Program Log: %@", progLog);  NSString *fragLog = [program fragmentShaderLog]; NSLog(@"Frag Log: %@", fragLog); NSString *vertLog = [program vertexShaderLog]; NSLog(@"Vert Log: %@", vertLog); [program release]; program = nil; } 

Si le processus de liaison a été un succès et les retours YES, Récupérer les uniformes et les indices d'attribut et puis appeler use pour commencer à utiliser les shaders dans ce programme pour dessiner des objets:

GLuint positionAttribute = [program attributeIndex:@"position"]; GLuint colorAttribute = [program attributeIndex:@"color"]; GLuint translateUniform = [program uniformIndex:@"translate"]; [program use]; 

Une fois que vous avez appelé use, Vous êtes prêt à commencer à soumettre des données uniformes et d'attributs.
Envoi des attributs et des uniformes pour les Shaders
Nous sommes presque prêts à essayer le pipeline OpenGL ES programmable par écrit notre première application complète OpenGL ES, mais avant nous faisons cela, nous avons besoin de parler de comment nous expédier les attributs et les uniformes plus au shader. C'est en fait un processus simple, bien qu'il puisse paraître intimidant la première fois qu'on voit dans le code. Le processus pour les attributs et les uniformes sont un peu différentes, donc nous allons les regarder individuellement.
Uniformes Présentation
Regardons premiers uniformes parce qu'ils sont un peu plus facile à Grok. Après nous relions à notre programme, nous récupérons la valeur de l'indice pour chacune de nos uniformes et enregistrer cette valeur d'index afin que nous puissions l'utiliser pour présenter les données de cet uniforme d'OpenGL ES:

GLuint translateUniform = [program uniformIndex:@"translate"]; 

Une fois que nous avons la valeur de l'indice (translateUniform dans la ligne de code précédente), nous avons juste à utiliser une fonction appelée glUniform() de soumettre les données pour que l'uniforme à nos shaders. glUniform() est un de ces «alphabet soup" des fonctions qui prend de nombreuses formes différentes. Parce que les shaders fonctionner sur le GPU, et les offres GPU principalement avec nombres à virgule flottante, l'ensemble des glUniform() variantes prendre une ou plusieurs GLfloats ou d'un ou plusieurs pointeurs GLfloats. ^ 3 Pour envoyer une valeur unique point flottant comme un uniforme, par exemple, nous avions sélectionner soit glUniform1f() or glUniform1fv(), Selon que nous avions besoin d'envoyer un GLfloat ou un pointeur vers une GLfloat. Si nous voulions envoyer un seul sommet, qui serait représenté par un vec3 dans le shader, nous avions le choix entre glUniform3f() or glUniform3fv().

Peu importe lequel des glUniform() variantes que nous choisissons, le premier argument, nous passons doit être l'indice de l'uniforme nous soumettre des données pour, qui est la valeur que nous précédemment récupérées à partir uniformIndex:. Lors de l'utilisation des variantes non-pointeur de la glUniform() (Celles avec un nom se terminant en f), L'indice uniforme est suivie par les données soumises dans le bon ordre. Si nous avons besoin de soumettre un emplacement vertex, par exemple, nous présentions la valeur pour X comme second argument, la valeur de Y que le troisième argument, et la valeur de Z comme le quatrième argument. Alors, pour passer d'un seul pointeur non valeur à l'aide glUniform(), Nous ferions ceci:

glUniform1f(translateUniform, 25.3f); 

Pour passer d'un sommet avec trois valeurs d'un uniforme, nous ferions quelque chose comme ceci:

glUniform3f(vectorUniform, 2.3f, -1.34f, 0.34f); 

Lorsque vous utilisez le glUniform() variantes qui se terminent par v, Nous suivons l'indice de l'uniforme avec la taille des données étant passée puis un pointeur sur les données réelles, comme ceci:

GLfloat vertex[3]; vertex[0] = 2.3f; vertex[1] = -1.34f; vertex[2] = 0.34f; glUniform3fv(vectorUniform, 1, vertex); 

En effet, ce code est exactement identique à l'exemple précédent, mais nous utilisons l'une des variantes du pointeur glUniform() de passer tous les trois valeurs de la matrice qui composent le vec3 uniforme. La chasse aux sorcières ici est la size argument. Vous pourriez penser que vous devez passer 3 dans l'exemple ci-dessus parce que le vertex tableau a une longueur de trois, mais parce que nous utilisons glUniform3fv(), Nous spécifions 1 car cette méthode suppose que chaque élément de données est déjà trois GLfloats longtemps. Si elles étaient plus courtes, vous seriez à l'aide glUniform2fv() or glUniform1fv().
Attributs Présentation
Envoi des données d'attribut pour le shader est seulement légèrement plus impliqués que les uniformes soumettre. D'abord, vous devez récupérer la valeur d'index de l'attribut, comme ceci:

GLuint positionAttribute = [program attributeIndex:@"position"]; 

Tout comme avec les indices uniforme, vous aurez envie de faire cela qu'une seule fois, si possible, et certainement pas à chaque fois que vous tracez, car il invoque une opération de comparaison de chaînes comme elle boucles à travers la attributes tableau, qui est coûteux en calcul. Une fois que vous avez l'index, vous devez soumettre les données à l'aide de la famille OpenGL ES Fonction appelée glVertexAttrib(). Comme glUniform(), glVertexAttrib() est une fonction alphabet soupe avec de nombreuses versions différentes. Cependant, puisque vous êtes presque toujours aller à l'envoi d'un large éventail de données pour le shader lorsque vous travaillez avec des attributs, en pratique, vous devrez presque toujours utiliser la même fonction: glVertexAttribPointer(), Qui vous permet de soumettre un bloc de longueur variable de données à l'attribut dans votre shader. Voici ce qu'est un appel typique à glVertexAttribPointer() pourrait ressembler:

glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, 0, 0, vertices); 

Le premier paramètre (positionAttribute dans la ligne de code précédente) est l'indice qui correspond à l'attribut nous fournir des données pour, celle que nous venons récupérées à partir attributeIndex:. Le second paramètre (3 ci-dessus) raconte OpenGL ES combien d'éléments de données sont présents pour chaque sommet ou, en d'autres termes, comment grand une bonne partie des données soumises doivent obtenir envoyé à chaque exécution du vertex shader. Donc, si vous soumettez des données de position vertex (x, y, z), chaque exécution du vertex shader a besoin de trois éléments de données, et cet argument doit être réglé 3. Si vous envoyez une couleur (r, g, b, a) pour chaque sommet, chaque exécution du vertex aurait besoin de quatre éléments et vous passeriez 4. L'argument suivant indique à OpenGL ES quel type de données est soumis. Dans ce cas, chaque sommet est composé de trois GLfloats, alors passer GL_FLOAT pour lui dire que. En théorie, il existe plusieurs valeurs que vous pourriez passer ici, mais en réalité, puisque les attributs doivent être constitués d'une ou plusieurs variables à virgule flottante, vous aurez toujours passer GL_FLOAT.

Le quatrième argument de glVertexAtttribPointer() peut être ignoré. Il suffit de passer 0 pour cet argument. Cet élément est utilisé uniquement avec GL_FIXED types de données. L' GLfixed datatype vous permet de représenter une valeur en virgule flottante en utilisant des nombres entiers, ce qui permet des calculs plus rapides sur les systèmes qui sont lents à flotter opérations en virgule, soit parce qu'il n'y a aucun GPU, ou parce que le GPU utilise en interne des représentations point fixe de données. Tous les appareils iOS ont un GPU qui utilisent en interne des représentations en virgule flottante et qui sont capables de faire rapidement les mathématiques à virgule flottante, alors nous ne serons jamais utiliser le GLfixed datatype lors de la programmation pour l'iOS, et vous n'avez pas à vous soucier qu'ils soient fixes données de point les valeurs sont normalisées lorsque envoyé au shader.

Nous n'allons pas à regarder le cinquième élément en ce moment. Nous allons juste faire passer 0 pour cet élément, pour le moment. Le cinquième argument est connu comme le stride argument, et il peut être utilisé pour emballer plus d'un type de données dans un seul bloc de données. Nous pourrions, par exemple, emballer nos couleurs et les sommets dans un seul tableau entrelacé et utilisez l'argument foulée de laisser OpenGL ES savoir pour sauter les données de couleur lors du passage des attributs de vertex pour le shader. Nous allons voir comment faire entrelacement de données dans le chapitre sur l'optimisation performance.will Ajouter X-Ref lors chapitre existe

L'argument final glVertexAttribPointer() est le pointeur vers les données réelles nous soumettre pour cet attribut. Cela va être soit un tableau ou un pointeur sur une portion de mémoire créée avec alloc().

Pour chaque attribut, il ya un deuxième appel que nous avons appelé à faire glEnableVertexAttribArray(), En passant l'index de l'attribut que nous sommes favorables. Par défaut, tous les attributs sont désactivés, donc nous devons dire à OpenGL ES spécifiquement pour permettre à un attribut pour qu'il expédier les données de l'attribut dans le shader. Vous pouvez appeler cette fonction qu'une seule fois après que vous liez votre programme et ensuite ne jamais s'en soucier. Cependant, c'est un appel très faible hauteur, et si un attribut été désactivé en quelque sorte d'obtenir, ce serait un problème très difficile à comprendre. En conséquence, il n'est pas rare de faire appel glEnableVertexAttribArray() chaque fois que vous tracez pour s'assurer que les données d'attribut est envoyé au shader.

Une fois vos attributs ont tous été activé et que vous avez soumis vos données d'attribut, vous êtes prêt à raconter OpenGL ES à dessiner.

Tire à sa fin

Le fait de raconter OpenGL ES pour commencer le rendu est lancé par l'un des deux appels de fonction: glDrawArrays() or glDrawElements(). Il ya de nombreuses nuances au dessin, et la meilleure façon d'apprendre ces nuances est d'utiliser les deux fonctions. Dans le prochain chapitre, nous allons construire notre première application, qui va utiliser glDrawArrays(). Quelques chapitres plus tard, nous allons en apprendre davantage sur glDrawElements() et les raisons pour avoir deux fonctions différentes de dessin, en premier lieu.

Dans ce chapitre, nous avons pris un coup d'oeil au pipeline OpenGL ES 2.0 de l 'programmables. Vous avez appris que les vertex shaders exécuté une fois pour chaque vertex et fragment shaders qui exécuter une fois pour chaque fragment, ce qui correspond à une fois pour chaque pixel qui sera tiré. Vous avez également vu ce simple fragment et vertex shaders ressembler, et appris à les compiler et lier un shader paire dans un programme OpenGL ES unique. Vous avez même vu comment passer des données à partir de votre code d'application pour les shaders en utilisant des uniformes et des attributs et comment passer des données entre le vertex shader et le fragment shader utilisant varyings.

Cela a été un long chapitre, mais maintenant nous sommes prêts à mettre le pipeline programmable à utiliser. Prenez une profonde respiration, vous tape dans le dos pour traverser tout cela ennuyeux, mais importante, jusqu'à l'avant-stuff.


1 - En fait, l'iPad et l'iPhone 4 d'Apple utilisent A4 "système sur une puce», qui a un CPU et GPU intégré sur une seule puce au lieu de CPU GPU et les puces séparées, mais qui n'a pas vraiment affecter la façon dont vous programmez pour elle, ne modifie pas la méthode de base que les deux processeurs d'interagir les uns avec les autres.

2 - La puce à tous les appareils iOS est capable de faire vite à virgule flottante en utilisant quelque chose qui s'appelle processeurs vectoriels. Votre code ne signifie pas automatiquement profiter des processeurs vectoriels, cependant, si cette affirmation est vraie, généralement parlant. Nous allons voir comment exploiter les processeurs vectoriels dans le code de l'application qui s'exécute sur le processeur dans le chapitre sur l'optimisation.

3 - Il ya aussi une fonction similaire appelé glUniformMatrix() que nous allons examiner quand nous discuterons des transformations de matrice dans un prochain chapitre. Nous ne voulons pas prendre de l'avance de nous-mêmes, mais les matrices sont vraiment rien de plus que deux dimensions des tableaux de GLfloats.