Affichage des articles dont le libellé est Objective-C. Afficher tous les articles
Affichage des articles dont le libellé est Objective-C. Afficher tous les articles

vendredi 23 mars 2012

Ajouts CGAffineTransform

Comme vous le savez probablement, Apple fournit un tas de fonctionnalités pour la manipulation des objets dans l'espace 2D en utilisant CGAffineTransform. Curieusement, Apple ne vous fournit pas un moyen d'extraire l'échelle, de transformer et d'informations de rotation d'un CGAffineTransform et ils ne fournissent pas toute la fonctionnalité de cisaillement à tous.

Voici quelques fonctions supplémentaires en ligne que j'utilise. Cela ajoute la capacité d'extraire les valeurs des composants de l'CGAffineTransform et ajoute également la possibilité de créer et d'extraire des informations de cisaillement.

Comme toujours, ce code est libre d'utiliser sans restriction ni limitation, mais a aucune garantie. Si vous fixez un bug, n'hésitez pas à me le faire savoir sur le correctif afin que je puisse intégrer le correctif.

#ifndef __MCP_AFFINE_TRANSFORM_ADDITIONS__ #define __MCP_AFFINE_TRANSFORM_ADDITIONS__  #import <CoreGraphics/CoreGraphics.h>  #ifdef __cplusplus extern "C" { #endif  #define degreesToRadian(x) (M_PI * x / 180.0) #define radiansToDegrees(x) (180.0 * x / M_PI)  static inline CGAffineTransform CGAffineTransformMakeShear(CGFloat shearX, CGFloat shearY) {     return CGAffineTransformMake(1.f, shearY, shearX, 1.f, 0.f, 0.f); } static inline CGAffineTransform CGAffineTransformShear(CGAffineTransform transform, CGFloat shearX, CGFloat shearY) {     CGAffineTransform sheared = CGAffineTransformMakeShear(shearX, shearY);     return CGAffineTransformConcat(transform, sheared); } static inline CGFloat CGAffineTransformGetDeltaX(CGAffineTransform transform) {return transform.tx;}; static inline CGFloat CGAffineTransformGetDeltaY(CGAffineTransform transform) {return transform.ty;}; static inline CGFloat CGAffineTransformGetScaleX(CGAffineTransform transform) {return sqrtf( (transform.a * transform.a) + (transform.c * transform.c) );}; static inline CGFloat CGAffineTransformGetScaleY(CGAffineTransform transform) {return sqrtf( (transform.b * transform.b) + (transform.d * transform.d) );}; static inline CGFloat CGAffineTransformGetShearX(CGAffineTransform transform) {return transform.b;}; static inline CGFloat CGAffineTransformGetShearY(CGAffineTransform transform) {return transform.c;}; static inline CGFloat CGPointAngleBetweenPoints(CGPoint first, CGPoint second)  {     CGFloat dy = second.y - first.y;     CGFloat dx = second.x - first.x;     return atan2f(dy, dx); } static inline CGFloat CGAffineTransformGetRotation(CGAffineTransform transform) {     // No exact way to get rotation out without knowing order of all previous operations     // So, we'll cheat. We'll apply the transformation to two points and then determine the     // angle betwen those two points          CGPoint testPoint1 = CGPointMake(-100.f, 0.f);     CGPoint testPoint2 = CGPointMake(100.f, 0.f);     CGPoint transformed1 = CGPointApplyAffineTransform(testPoint1, transform);     CGPoint transformed2 = CGPointApplyAffineTransform(testPoint2, transform);     return CGPointAngleBetweenPoints(transformed1, transformed2); }      #ifdef __cplusplus } #endif      #endif 


Code de session en ligne pour les gros objets (Plus un avertissement)

Dans le chapitre 9 du Développement Plus pour iPhone, Nous avons écrit un ensemble de classes qui imitait le comportement des GameKit peer-to-peer connectivité, mais pour les connexions réseau régulier (fonctionne uniquement avec GameKit connexions Bluetooth et réseau local). Fondamentalement, nous avons écrit une classe qui vous permet d'envoyer et de recevoir tout ce qui peut être emballé dans une instance de NSData. Comme il est relativement trivial à mettre en œuvre pour la plupart des classes de NSCoding, cela signifie passer des objets entre les apps iOS deux (ou une iOS et une application Mac) devient assez facile. Vous n'avez pas d'interroger les données, ou de s'inquiéter de chunking les données. Vous avez juste faire un appel de méthode et passer une instance NSData pour envoyer des données, puis mettre en œuvre une méthode déléguée pour recevoir des données de retour de l'autre extrémité. La vie est belle, non?

Hmm...

Peut-être pas. Il ya une limitation assez grand dans la mise en œuvre du livre. C'est la mise en oeuvre, conçu pour passer des petits paquets de données (se déplace jeu TicTacToe), tout conservé en mémoire. Si vous essayez d'envoyer une image de bonne taille à la connexion d'autres, probablement vous à court de mémoire assez rapidement.

Il ya quelque temps, j'ai été confronté exactement à cette situation. Pour une application kiosque qui MartianCraft a été écrit pour un client, j'ai eu besoin d'envoyer de grandes images prises avec un appareil photo reflex numérique à partir d'un programme Cocoa de Mac à un programme d'iPad et aussi nécessaire pour envoyer des photos prises avec l'appareil de l'iPad est de retour à l'application Mac Cocoa. Ces images, comprimé, variait d'environ un à environ cinq megs. J'ai attrapé la classe à partir OnlineSession More, En pensant, j'ai eu le code réseau essentiellement fait, et regardé ma demande de descendre dans un flamboiement de ... bien ... pas la gloire, c'est sûr. Non seulement l'iPad à court de mémoire, il a manqué de mémoire rapide ... beaucoup plus vite que prévu. Même l'envoi des images plus petites caméras iPad souvent causé peu de mémoire se bloque.

Il y avait deux problèmes fondamentaux avec la classe OnlineSession lorsque vous essayez de l'utiliser pour l'envoi de gros volumes de données. Tout d'abord, comme j'ai dit, c'est qu'il s'appuyait uniquement sur la mémoire physique. Étant donné que les limites physiques de l'iPad d'origine, ce fut problématique. Mais il y avait un autre problème, beaucoup plus grand.

Le deuxième problème était que pendant le processus de chunking les données à envoyer, le code a continué à faire des copies inutiles des données. Dit simplement, j'ai fait une erreur n00b. L'erreur n'a pas d'impact de l'application TicTacToe parce que le jeu serait se déplace facilement dans le tampon d'émission, mais c'est une erreur que j'ai faite avant et devrait définitivement avons connu mieux.

Alors, quoi, précisément, a été cette erreur, demandez-vous?

L'utilisation régulière de NSData dataWithBytes constructeur de commodité: longueur: lors de la création de la nouvelle instance NSData pour stocker la partie de l'image qui ne s'insère pas dans le tampon d'émission. Si vous lisez la description de dataWithBytes: longueur: il dit très clairement que cela fait une copie des données que vous fournissez. Donc, chaque fois qu'un paquet a été envoyé, le code serait de créer une nouvelle instance NSData pour tenir le reste qui ne rentrait pas dans le tampon, et il serait copier toutes les données non envoyés restantes pour chaque paquet. Ouch.

Donc, comme un exemple simple, si nous devions envoyer une image 5 meg, et le tampon d'émission a été fixé à 128k, le code serait de faire une copie 4,825 meg après le premier paquet a été envoyé, puis une copie de 4.75 meg, après le deuxième paquet a été envoyé, une copie de 4,265 meg après le troisième paquet, et ainsi de suite. Après chaque paquet, une autre copie légèrement plus petit des données a été faite. Une progression descendante qui mangent mémoire rapide.

Après beaucoup de jurons à moi, j'ai fait quelques modifications de la classe de faire deux choses.

Tout d'abord, je suis passé à l'aide de dataWithBytes NSData: NoCopy: longueur: qui utilise les données fournies en place sans faire de copie. Ce gardé l'empreinte mémoire beaucoup plus petit. Dans certains cas, car les images DSLR ont été si grande et si notre application nécessaire pour envoyer tant d'années, j'ai toujours rencontré des problèmes de mémoire. Ainsi, la deuxième chose que j'ai faite a été d'ajouter la mise en cache système de fichiers de la file d'attente sortante afin que tous les objets codés en attente d'être envoyés n'ont pas eu à tenir en mémoire pour l'application de fonctionner correctement.

La nouvelle version des fonctions de classe exactement comme celle de la livre, alors vous devriez être capable de tout rendez-remplacer les OnlineSession du chapitre 9 avec celui-ci sans apporter aucune modification à votre code d'application.

Vous pouvez télécharger la nouvelle version ici.

lundi 19 mars 2012

Un couple Goodies CGAffineTransform

Merci à Core Animation, nous iOS programmeurs ont tendance à utiliser transformations affines (Par voie de CGAffineTransform) un lot. En étant capable de combiner plusieurs transformations 2D dans une seule matrice, nous avons la capacité de faire beaucoup d'effets d'animation cool avec seulement quelques lignes de code.

Prenons l'exemple suivant, qui est assez typique:

    CGAffineTransform transform = CGAffineTransformMakeTranslation(0, -translation);
transform = CGAffineTransformScale(transform, scaleFactor, scaleFactor);
view.transform = transform;


Pas mal, non? En seulement trois lignes de code, nous sommes capables à la fois à l'échelle et de traduire une vue ou une couche. Mais en réalité, il ya en fait assez peu d'opérations qui se passe derrière ces trois lignes de code. L' CGAffineTransformScale() les appels de fonction CGAffineTransformConcat() pour effectuer une opération de multiplication de matrice entre deux matrices affines. Mais, comme vous le savez probablement, vous ne pouvez pas multiplier une matrice 2x3 par une autre matrice 2x3. Pour multiplier les transformations affines, ils doivent être reconverti en 3x3 matrices vectorielles premier.

Sur les périphériques d'aujourd'hui (même les dispositifs mobiles), tout cela prend une quantité insignifiante de puissance de traitement. Mais parfois, lorsque vous faites beaucoup de ces transformations - disons mille ou dizaines de milliers par seconde - il peut être utile d'être capable d'éviter que la conversion et la multiplication des matrices.

Il se trouve que avec certains CGAffineTransforms couramment utilisés, vous pouvez tricher. Certaines matrices peuvent être réunis sans effectuer la multiplication matricielle. Par exemple, voici les matrices créées par CGAffineTransformMakeScale () et CGAffineTransformMakeTranslation (), respectivement:

Equation08 Equation06


Allez-y et multiplier ces deux ensemble. Branchez n'importe quel nombre de tx, ty, sx, Et sy et exécuter les numéros. Je vais attendre. Bon, vous n'avez pas à. C'est ce que vous obtiendrez:
Equation0x

Donc, si ce n'est le résultat que nous allons obtenir, pourquoi s'embêter passant par la multiplication des matrices, en premier lieu? Pourquoi ne pas simplement alimenter la matrice à la fois avec l'échelle et de traduire les valeurs dès le départ? Eh bien, nous le pouvons. Nous pouvons aussi faire la même chose avec de traduire et faire pivoter.

Cela est d'autant qu'il ya à faire:

static inline CGAffineTransform CGAffineTransformMakeRotateTranslate(CGFloat angle, CGFloat dx, CGFloat dy)
{
return CGAffineTransformMake(cosf(angle), sinf(angle), -sinf(angle), cosf(angle), dx, dy);
}

static inline CGAffineTransform CGAffineTransformMakeScaleTranslate(CGFloat sx, CGFloat sy, CGFloat dx, CGFloat dy)
{
return CGAffineTransformMake(sx, 0.f, 0.f, sy, dx, dy);
}


C'est tout. Il enregistre seulement vous deux lignes de code:

    view.transform = CGAffineTransformMakeScaleTranslate(scaleFactor, scaleFactor, 0, -translation);


Mais, votre allocation de pile est considérablement plus petit (un CGAffineTransform au lieu de deux CGAffineTransforms et un tableau 3x3 intermédiaires. Il vous fait également gagner dix-huit multiplications en virgule flottante et neuf additions en virgule flottante. 99,9% du temps, que nombre d'opérations va avoir aucune notable incidence sur votre demande - c'est une infime partie de la mémoire et FLOPS dans la plupart des situations normales.

Mais ... si vous faites beaucoup par seconde, ils peuvent s'additionner et il est agréable de savoir qu'il ya une façon que vous pouvez vous épargner peu de surcharge dans certaines situations.

dimanche 18 mars 2012

Tile Cutter Mise à jour

A dû ré-tuile une grande image, donc passé un peu de temps à convertir coupe-carreaux à utiliser NSOperationQueue. Après un peu de jeu, j'ai opté pour une seule opération par ligne, ce qui semble donner le meilleur tout autour de la performance pour la plus grande variété d'images. Vous pouvez télécharger la dernière version à partir de here, Ou tirer la source à partir de GitHub.

Pour ceux d'entre vous ayant des difficultés à exécuter l'application, j'ai aussi ajouté à l'i386 architectures supportées. En raison de mon utilisation de blocs, Snow Leopard est requis pour exécuter l'application.

samedi 17 mars 2012

Outlets, Cocoa Cocoa Touch vs

J'ai presque toujours suivre l'exemple d'Apple sur le cacao et les conventions Cocoa Touch. Je suppose que par le temps à l'extérieur des développeurs comme moi voir quelque chose pour la première fois, les ingénieurs d'Apple ont été vivre avec cette chose pendant de nombreux mois, alors qu'ils ont probablement obtenu une bien meilleure idée que moi sur la meilleure façon d'utiliser cette nouvelle chose.

Mais, après avoir passé du temps avec leurs trucs, parfois - pas souvent, mais parfois - je suis en désaccord avec ce qui semble être d'Apple recommande «meilleures pratiques» pour faire quelque chose. Je pense que je suis venu à la décision que le comportement IBOutlet dans iOS est l'un de ces domaines.

Si vous regardez des extraits de documentation d'Apple et des exemples de code, vous constaterez qu'ils conservent presque toujours propriétés IBOutlet, comme:

 #import <UIKit/UIKit.h>   @interface FooView : UIView  {  } @synthesize (nonatomic, retain) IBOutlet UIButton button; @synthesize (nonatomic, retain) IBOutlet UITextField textField; @synthesize (nonatomic, retain) IBOutlet UIImageView imageView; @end 


Il ya une bonne raison à cela. Dans iOS, la documentation stipule explicitement que vous devez conserver tous les points car le chargeur bundle pour iOS autoreleases tous les objets créés à la suite du chargement d'une plume.
Les objets dans le fichier nib sont créés avec un nombre de 1 conservent puis autoreleased. Comme il reconstruit la hiérarchie d'objets, cependant, UIKit rétablit les connexions entre les objets en utilisant l'setValue: forKey: méthode, qui utilise la méthode setter disponible ou conserve l'objet par défaut si aucune méthode setter est disponible. Si vous définissez des débouchés pour nib fichier des objets, vous devez toujours définir une méthode setter (ou biens déclarés) pour accéder à cette sortie. Méthodes setter de débouchés devraient conserver leurs valeurs, et les méthodes setter pour les points contenant des objets de haut niveau doivent conserver leurs valeurs pour les empêcher d'être libéré. Si vous ne stockez pas les objets de haut niveau dans les points, vous devez conserver soit le tableau renvoyé par la loadNibNamed: le propriétaire: options: méthode ou les objets à l'intérieur du tableau pour éviter ces objets d'être libérés prématurément.

Ceci est différent de cacao sur le Mac, où il n'était pas nécessaire de conserver les débouchés et les gens ont rarement fait. En fait, nous n'avons généralement pas s'embêter avec des méthodes d'accès ou de mutator pour les points (il était juste en tapant supplémentaires inutiles dans la plupart des cas), nous venons de mettre le mot-clé IBOutlet en face de la variable d'instance et le chargeur nib était heureux de joindre nos points de vente comme ça, en conservant les objets qui avaient besoin de soutènement.

Le comportement sous Cocoa / Mac n'est pas réellement de conserver tout dans la plume, mais plutôt de conserver tous les objets qui n'a pas un objet parent de le conserver. Donc, en d'autres termes, si un objet dans une plume sera retenue par autre chose, comme un SuperView, le chargeur de nib ne dérange pas de le conserver encore. Mais, si elle n'a pas, le chargeur bundle il conserve afin qu'il ne soit pas libéré.

C'est une approche logique et, en fait, était nécessaire de retour dans le 2.0 de pré-Objective-C jours parce prises à l'époque étaient juste Ivars et il n'y avait pas de moyen facile pour la classe contrôleur de conserver des objets qui devaient être conservés.

Je me demande pourquoi ils changer le comportement fondamental d'un objet de fondation comme NSBundle entre Mac OS et iOS? NSBundle ne fait pas partie du cacao ou de Cocoa Touch, ça fait partie de la Fondation, et le point entier de la Fondation est d'avoir des objets communs entre les différents systèmes d'exploitation.

J'ai écrit une petit projet pour tester si le chargeur Bundle vraiment se comporter différemment, tel que documenté, en utilisant une instance de UIView dans le bec sans SuperView. Evidemment, lorsque je n'ai pas de conserver la prise, soit je suis une EXC_BAD_ACCESS ou un objet tout à fait différent quand j'ai imprimé la prise d'NSLog (). La différence est réelle. Le chargeur de botte sur le Mac conservera points pour vous si ils ont besoin pour être conservé, ce qui vous permet de continuer à utiliser des variables d'instance, ou des propriétés avec le mot clé attribuer. Cela signifie que vous n'avez pas à communiquer vos points de vente dans dealloc et vous n'avez pas à perdre son temps avec quelque chose comme viewDidUnload sur iOS.

Le chargeur de paquet sur l'iOS, d'autre part, ne conserve rien pour vous, alors si un objet n'est pas un objet parent de le conserver, vous devez le conserver dans votre classe contrôleur ou vous allez vous retrouver avec un invalide sortie.

Je ne vois vraiment pas la valeur à changer ce comportement. Je devine que la décision a été prise pour des raisons d'efficacité de la mémoire dans les premiers jours de l'iPhone. L'idée étant que vous pouvez charger une plume avec des instances d'objets que vous ne sont pas réellement à l'aide, et avec l'ancien comportement, ceux qui prendraient la mémoire aussi longtemps que la plume a été chargé. Cela ne veut pas nécessairement ressembler à une bonne idée sur un appareil embarqué sans mémoire virtuelle et 128 Mo de RAM, ce qui est de l'iPhone original et l'iPhone 3G avait.

Malgré cela, je pense que le remède est ici pire que le mal. Si vous ne vous souvenez de libérer vos points de vente dans les viewDidUnload (qui, si je me souviens bien, nous ne pouvions même pas faire dans la version 2.0 du SDK), vos points de vente continueront à utiliser de la mémoire après la plume est déchargé, ce qui évite aucun avantage de l'lazy loading. Essentiellement, il est plus fragile car il repose sur le programmeur fait la bonne chose et il ya peu, voire aucun des situations où un programmeur aurait besoin pour ne pas faire la bonne chose.

En vertu de la chargeuse bundle ne conservant pas prises, elle exige aussi plus par cœur le code réutilisable, qui sera écrit dans chaque classe contrôleur dans chaque application iOS, mais il fonctionne aussi bien d'un risque d'utilisation de la mémoire inutile, sans doute un plus grand risque. En d'autres termes, le remède n'est pas meilleur que la maladie.

iPhones sont de plus robuste et moins de mémoire limitée avec chaque nouvel appareil qui sort. Je dirais que c'est déjà l'heure (ou, à tout le moins, sera bientôt le temps), pour amener le comportement des deux chargeurs bundle ensemble. S'ils sont réunis, ils devraient être réunis en utilisant le comportement de cacao vieille pas le comportement de nouveaux iOS. Quand vous pensez au nombre de personnes codant pour l'iOS maintenant, ces dealloc supplémentaire requis et les lignes viewDidUnload dans chaque classe unique contrôleur de chaque application iOS sont vraiment ajouter jusqu'à beaucoup d'heures d'ingénierie ont perdu sur le passe-partout.

Il ya quelques semaines, j'ai commencé à expérimenter avec l'aide de céder au lieu de le conserver pour IBOutlets sauf dans les cas où l'objet du point de vente n'a pas eu une superview ou un autre objet à son maintien. Si une prise n'est pas une vue ou un contrôle, alors j'utilise aussi conserver. En substance, je suis imitant l'ancien comportement de la plume dans la conception de mes classes de contrôleur.

Cela a conduit à une frappe beaucoup moins et moins de code à maintenir parce que 95% ou plus des points de vente que je crée sont connectés à des objets retenus par leurs superview pendant l'existence entière de la classe contrôleur.

Maintenant, je ne suis pas nécessairement dire que vous devriez faire ce que je fais. Il peut être difficile, parfois, se souvenant de laquelle les objets doivent être conservés et qu'ils peuvent être difficiles à déboguer, si vous vous trompez. Apple a fait une recommandation de bonnes raisons et je ne pense pas que vous devriez ignorer cette recommandation à la légère. Cela étant dit, si vous êtes suffisamment à l'aise avec la gestion de la mémoire en Objective-C et le chargeur bundle pour être en mesure de distinguer si un objet nib sera automatiquement retenue par autre chose, vous pourriez vous épargner un peu juste de taper dans le temps.

Normalement, je essayer de tenir compte des changements d'Apple, mais aussi dans ce cas, je ne peux pas me convaincre que c'était un bon changement. Le comportement nib anciens de conserver les seules choses qui ont besoin de retenue a été en usage depuis plus de 20 ans, qui remonte à quand les ordinateurs de bureau sont moins puissants que nos iPhones sont, et il ne semble pas être un avantage pratique pour le changement. D'autre part, nous serions tous bénéficier de revenir à l'ancien comportement de Mac OS bundle parce que nous aurions moins de rendre le travail à faire lors de la création d'une classe contrôleur. Il ya aussi peu de danger à changer ce comportement, car code qui suit les recommandations actuelles d'Apple continuerait de fonctionner correctement.

Plus sur dealloc

Je ne m'attendais vraiment pas à la coup d'envoi d'une telle shitstorm hier avec mon message dealloc. Quelques personnes m'ont accusé de prosélytisme de la pratique de Ivars nil'ing, au moins pour code de déblocage. Peut-être que j'ai fait, mais ma véritable intention était de partager les raisons pour lesquelles vous pourriez choisir une approche plutôt qu'une autre, pour ne pas dire «vous devriez faire de cette façon." J'ai surtout écrit le message de blog pour m'assurer que j'avais ma tête complètement enroulé autour du débat parce qu'il était venu lors de la révision du début de développement iPhone.

Daniel Jalkut répondu avec une très lucides écriture jusqu'à qui représente l'un des points de vue communs sur ce sujet. Ce point de vue pourrait se résumer en "crash, bébé, crash". Si vous voulez trouver des bugs, la meilleure chose que vous pouvez faire est de plantage quand ils se produisent, de cette façon vous savez qu'il ya un problème et de savoir pour le chercher. Ce n'est pas une idée nouvelle. Je crois me souvenir d'une extension du système de retour à l'ancien système Mac Système 6 ou 7 jours qui effectivement causer votre système d'accident si votre application a fait une chose certaine mauvaise, même si cette chose mauvaise ne pas causer de problèmes notables dans votre app . Je ne me souviens pas honnêtement les détails, mais il avait quelque chose à voir avec le mécanisme de piégeage, je pense (que quelqu'un sait ce que je parle?). Bien sûr, Apple n'a pas expédier cette extension aux non-développeurs.

Ce qui rend ce un argument difficile est que Daniel a parfaitement raison ... parfois. Il existe des scénarios où les planter est beaucoup mieux que, disons, perte de données ou l'intégrité des données. Les règles générales sont toujours problématique, mais si je vois son point, je suis coller avec "ne pas s'écraser sur les clients" étant une bonne règle générale ... sauf quand il n'est pas.

Dans l'intérêt de la divulgation complète, il ya en fait un modèle dealloc tiers, mais une lointaine troisième en popularité, mais il est définitivement devenu plus populaire que quand j'ai la tête de celui-ci. Dans cette approche, vous cédez votre variable d'instance à une variable pile locale, alors nul la variable d'instance before le relâcher, comme ceci:

- (void)dealloc {     id fooTemp = foo;     foo = nil;     [fooTemp release]; } 

Dans l'approche presse-alors-nul, dès que vous relâchez, il ya une petite fenêtre entre la libération et l'assignation de néant où, dans le code multithread, le pointeur invalide pourrait encore être théoriquement être utilisés. Cette approche évite ce problème en nil'ing premier. Ce point de vue représente l'extrémité opposée du spectre de celui déclaré Daniel. Dans cette approche, votre but est de coder de manière défensive et ne laissez jamais votre accident app si vous pouvez l'aider, même dans le développement. Si vous êtes un programmeur prudent et croient dans le Tao de la programmation défensive, alors là vous allez - c'est votre approche de dealloc.

Pour moi, personnellement (avertissement - je suis sur le point de formuler un avis) je ne peux pas justifier le code supplémentaire et le temps de l'approche défensive. C'est un traitement préventif d'un problème si rare que c'est presque ridicule que cette discussion est encore passe. J'ai été écrit en Objective-C depuis 1999 et je n'ai vu qu'une seule fois un scénario où l'approche dealloc aurait fait une différence dans le comportement réel de la demande, et qui a été créé un scénario pour un exercice de débogage dans un atelier , alors nous sommes vraiment couper les cheveux ici.

Alors, voici mon dernier mot sur dealloc:
  1. Si vous avez déjà une opinion bien arrêtée sur celle à utiliser pour le type de codage de vous le faites, utilisez celui-là. Si ce n'est pas ...
  2. Si vous préférez que les bugs toujours planter votre application si vous savez à leur sujet, utilisez le traditionnel communiqué seule approche
  3. Si vous préférez ne pas se bloquer si vous pouvez l'aider et préfèrent trouver des bugs en utilisant d'autres moyens, utilisez la nouvelle approche
  4. Si vous voulez que votre application à planter pour vous, mais pas vos clients, utilisez le MCRelease () macro ou utiliser # si debug directives pré-processeur
Ce qui est important est que vous comprenez les avantages et les problèmes des différentes approches, et non que vous utilisez le même que celui que je fais (ou Daniel ne, ou n'importe qui d'autre).

Après tout, vous êtes celui qui doit vivre avec les conséquences de votre décision.

Dealloc

La semaine dernière il y avait un peu de Twitter en combat dans la communauté iOS sur la «bonne» façon de libérer votre variables d'instance dans dealloc. Je pense que Rob réellement démarré, pour être honnête, mais je ne devrais probablement pas être en avoir parlé.

Fondamentalement, plusieurs développeurs ont été affirmant qu'il n'y a jamais une raison pour définir une variable d'instance à zéro en dealloc, tandis que d'autres soutenaient que vous devriez toujours le faire.

Pour moi, il ne semble pas être un gagnant clair et convaincant entre les deux approches. J'ai utilisé aussi bien dans ma carrière. Cependant, puisque nous sommes en train d'essayer de décider de l'approche à utiliser dans la prochaine édition de début de développement iPhone, j'ai tendu la main à Apple Developer Tools évangéliste, Michael Jurewitz, Pour voir s'il y avait un fonctionnaire ou d'approche recommandée pour la manipulation des variables d'instance dans le dealloc.

Autre que le fait que vous devriez jamais, jamais l'utilisation des mutateurs dans dealloc (ou init, d'ailleurs), Apple n'a pas une recommandation officielle sur le sujet.

Cependant, Michael et Matt Drance of Bookhouse Software et un évangéliste lui-même ancien, avait discuté de cette question en profondeur la semaine dernière. Ils ont gentiment partagé leurs conclusions avec moi et m'a dit que tout allait bien pour moi d'en faire un blog. Alors, c'est ici. Heureusement, j'ai capturé tout correctement.

Les deux grandes approches

Juste pour vous assurer que nous sommes tous sur la même page, regardons les deux approches qui ont constitué les deux côtés différents de l'argument de la semaine dernière.

Il suffit de relâcher

L'approche la plus traditionnelle est tout simplement de libérer votre variables d'instance et les laisser pointant vers l'objet libéré (et potentiellement libérée), comme ceci:
- (void)dealloc {     [Sneezy release];     [Sleepy release];     [Dopey release];     [Doc release];     [Happy release];     [Bashful release];     [Grumpy release];     [super dealloc]; } 
Dans cette approche, chacun des pointeurs sera pointant vers un objet potentialy invalide pour une période de temps très court - jusqu'à ce que le retour de la méthode - à quel point la variable d'instance va disparaître avec son objet propriétaire. Dans une application mono-thread (le pointeur devra être consulté par quelque chose déclenchée par le code soit dans la mise en œuvre de cet objet d'dealloc ou dans le dealloc de l'un de ses super, il ya très peu de chances que les variables d'instance sera utilisé avant de se rendre loin, ce qui est probablement ce qui a conduit à la proclamation faite par plusieurs «il n'existe pas de valeur dans la mise en variables d'instance à néant» dans dealloc.

Dans un environnement multi-thread, cependant, il ya une possibilité très réelle que le pointeur sera accessible entre le moment où elle est libérée et le temps que son objet est fait d'être libéré. De manière générale, ce n'est que va se produire si vous avez un bug ailleurs dans votre code, mais avouons-le, vous pouvez très bien. Quiconque codes sur l'hypothèse que l'ensemble de leur code est parfait est la mendicité pour une SmackDown, et Xcode juste attend son heure d'attente pour l'occasion.

Libération et nulle

Dans les dernières années, une autre approche à dealloc est devenue plus courante. Dans cette approche, vous relâchez votre variable d'instance, puis immédiatement à les mettre à néant avant de libérer la variable d'instance suivante. Il est commun de mettre réellement la libération et l'assignation à zéro sur la même ligne séparés par une virgule plutôt que sur des lignes consécutives séparées par des virgules, mais c'est purement stylistique et n'a aucune incidence sur la façon dont le code est compilé. Voici ce que notre méthode dealloc précédente pourrait ressembler à l'aide de cette approche:

- (void)dealloc {     [sneezy release], sneezy = nil;     [sleepy release], sleepy = nil;     [dopey release], dopey = nil;     [doc release], doc = nil;     [happy release], happy = nil;     [bashful release], bashful = nil;     [grumpy release], grumpy = nil;     [super dealloc]; } 
Dans ce cas, si certains morceau de code accède à un pointeur entre le moment où commence et dealloc l'objet est réellement libérée, elle échouera presque certainement parce gracieusement envoyer un message à nil est parfaitement correct en Objective-C. Toutefois, vous faites un petit peu de travail supplémentaire en assignant nulle à tout un tas de pointeurs qui vont s'en aller momentanément, et vous créez un petit peu de frappes au clavier pour vous-même dans chaque classe.

Le Showdown

Donc, voici la vraie vérité de l'affaire: La grande majorité du temps, ça ne va pas faire de différence notable que ce soit. Si vous n'êtes pas accéder aux variables d'instance qui ont été libérés, il n'y a tout simplement pas y avoir de différence dans le comportement entre les deux approches. Si vous êtes, cependant, la question est: qu'est-ce que vous voulez arriver lorsque votre code est-ce que une mauvaise chose?

Dans la première approche, votre demande sera généralement collision avec une EXC_BAD_ACCESS, mais vous pouvez aussi retrouver avec toute forme de comportement étrange (que nous appelons un «heisenbug") si l'objet est libérée libérée et sa mémoire est ensuite réutilisée pour un autre objet détenue par votre application. Dans ces cas, vous pouvez obtenir une exception de sélection n'est pas reconnu lorsque le message est envoyé à l'objet désallouée, ou vous pouvez simplement obtenir un comportement inattendu de la même méthode appelée sur le mauvais objet.

Dans l'autre approche, votre application va tranquillement envoyer un message à nil et aller sur son petit bonhomme de chemin, généralement sans un accident ou tout autre problème immédiatement identifiable.

La première approche est réellement bon quand vous êtes en développement, le débogage, et de faire les tests unitaires, car il rend plus facile de trouver votre code problématique. D'autre part, cette approche est vraiment, vraiment mauvais dans une application d'expédition parce que vous ne voulez vraiment pas s'écraser sur vos utilisateurs si vous ne pouvez l'éviter.

La dernière approche, à l'inverse, peuvent se cacher des bugs lors du développement, mais gère ces bugs avec plus de grâce quand ils se produisent, et vous êtes beaucoup moins susceptibles d'avoir votre application monter dans une grosse boule de feu devant vos utilisateurs.

Le gagnant?

Il n'est vraiment pas un gagnant claire, qui est probablement pourquoi Apple n'a pas une recommandation officielle ou de position. Lors de leur discussion, Matt et Michael venu avec "le meilleur des deux mondes" une solution, mais elle exige un peu juste de code supplémentaire dans l'une des approches communes.

Si vous voulez que votre application crash quand un pointeur publié est accessible durant le développement et le débogage, la solution est d'utiliser l'approche traditionnelle dans votre configuration de débogage. Si vous voulez que votre application dégradé pour vos utilisateurs, la solution est d'utiliser la nouvelle approche dans votre communiqué et ad hoc configurations.

Une mise en œuvre quelque peu pédant de cette approche serait la suivante:

- (void)dealloc { #if DEBUG     [Sneezy release];     [Sleepy release];     [Dopey release];     [Doc release];     [Happy release];     [Bashful release];     [Grumpy release];      [super dealloc]; #else     [sneezy release], sneezy = nil;     [sleepy release], sleepy = nil;     [dopey release], dopey = nil;     [doc release], doc = nil;     [happy release], happy = nil;     [bashful release], bashful = nil;     [grumpy release], grumpy = nil;      [super dealloc]; #endif } 

Ce code suppose que votre configuration de débogage a une définition du précompilateur DEBUG, ce qui vous avez généralement à ajouter à votre projet Xcode - la plupart des modèles de projet Xcode ne le donnez pas à votre place. Il ya plusieurs façons que vous pouvez l'ajouter, mais je généralement il suffit d'utiliser le Macros préprocesseur mise en configuration de construction du projet:
Screen shot 2010-09-23 at 7.56.28 PM.png

Bien que le code ne-dessus, en effet, de nous donner le meilleur de deux mondes - un crash lors du développement et de débogage et gracieux dégradantes pour les clients - c'est moins doubler la quantité de code que nous avons à écrire dans chaque classe. Nous pouvons faire mieux que cela, cependant. Que diriez-vous d'une magie petite macro? Si l'on ajoute la macro suivante pour notre projet pch.:

#if DEBUG #define MCRelease(x) [x release] #else #define MCRelease(x) [x release], x = nil #endif


Nous pouvons ensuite utiliser cette macro dans dealloc, et notre meilleur-de-deux-mondes code devient beaucoup plus court et plus lisible:

- (void)dealloc  {      MCRelease(sneezy);     MCRelease(sleepy);     MCRelease(dopey);     MCRelease(doc);     MCRelease(happy);     MCRelease(bashful);     MCRelease(grumpy);      [super dealloc]; }


Une fois que vous avez la macro dans votre projet, cette option n'est en fait pas plus de travail ou en tapant à l'une des méthodes dealloc autres.

Mais, vous savez quoi? Si vous voulez continuer à faire les choses comme vous l'avez toujours fait, c'est vraiment bien, quelle que soit la façon dont vous le faites. Si vous êtes cohérent dans votre utilisation et sont conscients des compromis, il n'ya vraiment aucune raison impérieuse d'utiliser l'un sur l'autre en dehors de préférence personnelle.

Donc, en d'autres termes, c'est une sorte de bêtise pour nous tous de faire valoir plus, surtout quand il ya déjà la politique, les religions, et des sports pour remplir ce rôle.

L'angle de collecte des ordures

Il ya un dernier point que je veux aborder. J'ai entendu à quelques reprises par différentes personnes que la mise en une variable d'instance à néant dans des actes dealloc comme un indice de la garbage collector lorsque vous utilisez l'option a permis-pas-besoin GC (lorsque l'option requise est utilisée, dealloc n'est même pas appelé, de finaliser l'est). Si cela était vrai, la compatibilité ascendante serait un autre argument possible pour préférer la nouvelle approche de dealloc sur l'approche traditionnelle.

S'il est vrai que dans Java et autres langages de la collecte des ordures, du bruit résiduel à un pointeur que vous en avez terminé avec l'aide garbage collector savons que vous avez terminé avec cet objet, donc ce n'est pas tout à fait improbable que le garbage collector Objective-C fait la même chose, cependant aucun bénéfice pour les variables d'instance nil'ing fois que nous aurons collecte des ordures dans iOS serait au mieux marginal. Je n'ai pas été capable de trouver quelque chose d'autorité qui soutient cette revendication, mais même si c'est 100% vrai, il semble probable que, lorsque l'objet propriétaire est désalloué quelques instructions plus tard, le garbage collector se rendra compte que l'objet se fait avec désallouée tout ce qu'il a été utilisé.

Si il ya un avantage dans ce scénario, qui semble improbable, il semble que ce serait une telle différence minuscule qui il ne serait même judicieux d'en tenir compte dans votre décision. Cela étant dit, je n'ai aucune preuve solide d'une manière ou l'autre sur cette question et souhaiterait être éclairé.

Après avoir écrit cela, Michael Jurewitz m'a cinglé à confirmé qu'il n'y a absolument aucun avantage en termes de GC pour la libération de dealloc, mais il en est autrement une bonne idée de pointeurs nuls, vous en avez terminé avec la CG..

Merci à @ et @ borkware eridius pour souligner certaines des questions

Update: Ne manquez pas excellente Daniel Jalkut de response.

Transparent Tableviews Groupés

J'ai rencontré un problème aujourd'hui avec une vue de tableau regroupés transparente. Sur le tableau, j'ai mis opaque pour le NO et la couleur de fond d'clearColor sorte que l'image derrière le tableau serait montrer à travers:
Screen shot 2010-08-19 at 1.55.43 PM.png
Je ne peux pas vous montrer l'application réelle, je travaillais sur parce que je suis sous NDA, mais j'ai créé un projet exemple qui montre le problème en utilisant une image de fond vraiment moche. Avis du noir autour des coins des sections du groupe:
Screen shot 2010-08-19 at 1.54.21 PM.png

Il m'a fallu un moment pour comprendre pourquoi cela se passait, mais avec un peu grâce débogage foule source à Twitter, j'ai rétréci le coupable. Même si vous pouvez clairement voir dans la première image que la couleur de fond la vue du tableau a été mis à clearColor dans Interface Builder, ce paramètre est soit pas respectée, ou est changé quelque part. Maintenant, je suis en utilisant des éléments de stock ici - pas de vues personnalisées à tous - je sais que je ne suis pas le changer.

Mon corriger originale pour ce fut plutôt en cause, mais après un processus d'élimination où je gardais commentant bits du correctif et l'impact et de voir ce qu'elle avait, j'ai été en mesure de retirer tout le code de mon fix sauf pour cette ligne de code :

- (void)viewDidLoad
{
[super viewDidLoad];
self.tableView.backgroundColor = [UIColor clearColor];
}


Il s'avère que toutes les autres parties étaient rouges restes harengs de mon diverses tentatives pour résoudre le problème. Donc, si vous rencontrez ce problème, il suffit de nouveau manuellement l'image de fond la vue du tableau d'clearColor et vous devriez être bon.

(Et oui, je vais déposer un rapport de bug maintenant)

Core Data partir de données

Hier, j'ai tweeté pour demander des conseils sur la meilleure façon de fournir un ensemble de départ de données dans une base de données basée sur l'application. Le soft, je travaille sur avaient commencé avec juste un petit ensemble de données de départ, donc la première fois le soft a été exécuté, j'ai simplement tiré dans les données de démarrage à partir d'un fichier plist dans le fond et créé des objets gérés en fonction du contenu et de tous était bon. L'utilisateur ne s'en aperçut et la charge était complète avant ils avaient besoin de faire quelque chose avec les données.

Alors l'ensemble des données a obtenu un peu plus grand et que la solution est devenue trop lente. Alors, j'ai demandé au Twitterverse d'opinions sur la meilleure façon de fournir une grande quantité de données à partir d'une application de données de base. Qu'est-ce que j'espérais trouver était de savoir si vous pourriez inclure un magasin persistant dans votre bundle application et l'utilisation plutôt que de créer de nouveaux magasins persistante la première fois l'application lancée.

La réponse est revenu de beaucoup, beaucoup de personnes que vous pourriez, en effet, la copie d'un magasin existant persistante de votre bundle soft. Vous pouvez même créer le stockage persistant en utilisant un Mac de base de cacao de données d'application aussi longtemps que le fichier utilisé xcdatamodel même que votre application iPhone.

Avant que je continue, je tiens à remercier toutes les personnes qui ont répondu avec des suggestions et des conseils. Un merci spécial à Dan Pasco de la boutique de dev excellente Noir Pixel qui a donné une aide très substantielle. Avec l'aide de la communauté iOS dev, il m'a fallu environ 15 minutes pour que ça marche dans une de mes applications actuelles. Plusieurs personnes ont demandé des détails sur Twitter. 140 caractères ne va pas le couper pour cela, mais voici ce que j'ai fait.

D'abord, j'ai créé un nouveau Mac / Cocoa projet dans Xcode. J'ai utilisé le modèle de cacao demande régulière, en veillant à utiliser des données de base. Plusieurs personnes ont également suggéré que vous pourriez utiliser une application Cocoa document-Based utilisant Core Data qui vous permettrait de sauver le magasin persistant partout que tu voulais. Je crée le projet Xcode dans un sous-répertoire de mon projet principal, et j'ai ajouté le fichier du modèle de données et toutes les classes d'objets gérés à partir de mon projet principal dans le nouveau projet en utilisant des références relatives au projet, en veillant à ne pas copier les fichiers dans le nouveau dossier du projet - je veux utiliser les mêmes fichiers que mon projet originel de sorte que toute modification apportée à celui-ci sont répercutées dans l'autre.

Si mes données de départ était changent fréquemment, je serais probablement faire de ce nouveau projet une dépendance de mon projet principal et ajouter une copie des fichiers construire phase qui va copier le stockage persistant dans le dossier du projet principal de ressources, mais mes données ne change pas très souvent, donc je suis juste de le faire manuellement. On peut certainement automatiser la tâche au sein de Xcode, et j'ai entendu de plusieurs personnes qui l'ont fait.

Dans le projet de nouvelle cacao, la première chose à faire est de modifier la méthode persistentStoreCoordinator du délégué app pour qu'il utilise un magasin persistant avec le même nom que votre application iOS. Ceci est la ligne de code dont vous avez besoin de modifier:

NSURL *url = [NSURL fileURLWithPath: [applicationSupportDirectory stringByAppendingPathComponent: @"My_App_Name.sqlite"]];


Assurez-vous d'ajouter l'extension. Sqlite au nom de fichier. Par défaut, le modèle d'application Cocoa utilise un magasin de données XML et aucune extension de fichier. Le nom du fichier que vous indiquez ici est utilisée exactement, donc si vous voulez une extension de fichier, vous devez le spécifier.

Depuis défaut de cacao du projet d'application d'un magasin basé sur XML persistants, vous devez également modifier le type de magasin de l'App cacao à SQLite. C'est quelques lignes plus tard. Cherchez cette ligne:

if (![persistentStoreCoordinator addPersistentStoreWithType:NSXMLStoreType 
configuration:nil
URL:url
options:nil
error:&error
]
){


Changement d'NSXMLStoreType NSSQLiteStoreType.

En option, vous pouvez aussi changer la méthode applicationSupportDirectory de revenir un autre endroit si vous voulez rendre le stockage persistant plus facile à trouver. Par défaut, il va aller dans les
~/Library/Application Support/[Cocoa App Name]/
qui peut être un peu un glisser pour naviguer.

Ensuite, vous devez faire vos importer des données. Ce code sera intrinsèquement spécifiques à l'application et dépendra de votre modèle de données et les données dont vous avez besoin d'importer. Voici un simple pseudo-méthode pour analyser un fichier texte délimité par des tabulations pour donner une idée à quoi cela pourrait ressembler. Cette méthode crée une NSAutoreleasePool et un contexte pour qu'il puisse être lancé dans un thread si vous le désirez. Vous pouvez également l'appeler directement - il ne dérange en rien.


- (void)loadInitialData
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSManagedObjectContext *context = [[NSManagedObjectContext alloc] init];
[context setPersistentStoreCoordinator:self.persistentStoreCoordinator];


NSString *path = [[NSBundle mainBundle] pathForResource:@"foo" ofType:@"txt"];

char buffer[1000];
FILE* file = fopen([path UTF8String], "r");

while(fgets(buffer, 1000, file) != NULL)
{
NSString* string = [[NSString alloc] initWithUTF8String:buffer];
NSArray *parts = [string componentsSeparatedByString:@"\t"]

MyManagedObjectClass *oneObject = [self methodToCreateObjectFromArray:parts];
[string release];
}

NSLog(@"Done initial load");
fclose(file);
NSError *error;
if (![context save:&error])
NSLog(@"Error saving: %@", error);

[context release];
[pool drain];
}


Vous pouvez ajouter le applicationDidFinishLaunching méthode déléguée: à votre délégué app et de mettre votre code là. Vous n'avez même pas vraiment besoin de vous soucier de combien de temps cela prend - il n'ya pas de processus de surveillance sur le Mac qui tue votre application si elle ne répond pas à des événements après une période de temps. Si vous préférez, vous pouvez avoir votre fonctionnalité d'importation des données de travail dans le fond, bien que depuis l'app ne fait rien d'autre, il n'y a aucun avantage réel, sauf le fait que c'est la «bonne» façon de coder une application.

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
// Do import or launch threads to do import

// So, do this:
[self loadInitialData];

// or this:

[self performSelectorInBackground:@selector(loadInitialData) withObject:nil];

// But not both for the same method probably
}


Maintenant, lancez votre application. Quand c'est fait, l'importation, vous pouvez simplement copier le fichier de stockage persistant dans le projet de votre iOS app Xcode dans le groupe des ressources. Lorsque vous créez votre appli, ce fichier sera automatiquement copié dans votre application bundle. Maintenant, vous avez juste besoin de modifier le délégué app de votre application iOS d'utiliser ce magasin persistante au lieu de créer un nouveau magasin vide persistante la première fois l'application est exécutée.

Pour ce faire, il vous suffit de vérifier l'existence du magasin persistant dans le dossier de votre application / documents, et si elle n'y est pas, vous le copiez le paquet d'application dans le dossier de l'/ Documents avant de créer le magasin persistant. Dans le délégué app, la méthode persistentStoreCoordinator devrait ressembler à ceci:

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator 
{
@synchronized (self)
{
if (persistentStoreCoordinator != nil)
return persistentStoreCoordinator;

NSString *defaultStorePath = [[NSBundle bundleForClass:[self class]] pathForResource:@"My_App_Name" ofType:@"sqlite"];
NSString *storePath = [[self applicationDocumentsDirectory] stringByAppendingPathComponent: @"My_App_Name.sqlite"];

NSError *error;
if (![[NSFileManager defaultManager] fileExistsAtPath:storePath])
{
if ([[NSFileManager defaultManager] copyItemAtPath:defaultStorePath toPath:storePath error:&error])
NSLog(@"Copied starting data to %@", storePath);
else
NSLog(@"Error copying default DB to %@ (%@)", storePath, error);
}


NSURL *storeURL = [NSURL fileURLWithPath:storePath];

persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];

NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:
[NSNumber numberWithBool:YES], NSMigratePersistentStoresAutomaticallyOption,
[NSNumber numberWithBool:YES], NSInferMappingModelAutomaticallyOption, nil
]
;

if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:options error:&error])
{

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}


return persistentStoreCoordinator;
}

}


Et `Voil a! Si vous exécutez l'application pour la première fois sur un périphérique, ou de l'exécuter sur le simulateur après la réinitialisation de contenu et les paramètres, vous devriez commencer avec les données qui ont été chargées dans votre application Cocoa.

La chose drôle au sujet Ancien code ...

La chose drôle au sujet de l'ancien code et le code de la plupart des nouvelles, c'est qu'il ya souvent place à amélioration. Peu de temps après la publication NSString appendToFile: usingEncoding:, J'ai réalisé que j'aurais pu tuer deux oiseaux avec une pierre en ajoutant une méthode catégorie sur NSData puis en appelant cette méthode à partir de la méthode la catégorie NSString. De cette façon je obtenir la fonctionnalité des deux classes sans répéter la logique.

Sans plus tarder:

#import <Foundation/Foundation.h>

@interface NSData(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path;
@end

@implementation NSData(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path
{
NSFileHandle *fh = [NSFileHandle fileHandleForWritingAtPath:path];
if (fh == nil)
return [self writeToFile:path atomically:YES];

[fh truncateFileAtOffset:[fh seekToEndOfFile]];

[fh writeData:self];
[fh closeFile];
return YES;
}

@end

#pragma mark -
@interface NSString(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path usingEncoding:(NSStringEncoding)encoding;
@end

@implementation NSString(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path usingEncoding:(NSStringEncoding)encoding
{
NSData *encoded = [self dataUsingEncoding:encoding];
return [encoded appendToFile:path];
}

@end


NSString appendToFile: usingEncoding:

Assez souvent je regarde dans la documentation d'Apple pour une méthode que je suis sûr existe mais ne se présente pas lorsque je recherche en utilisant la visionneuse de documentation de Xcode. Habituellement, dans ce cas, la méthode existe bel et bien, mais ce n'est pas d'Apple. Neuf fois sur dix, cela signifie que j'ai une méthode de la catégorie que j'ai utilisé tant de fois que j'ai oublié, Apple n'a pas le fournir. L'autre sur dix, c'est juste une indication que je suis croissance lente sénile.

Lorsque cela arrive, je tente d'afficher les méthodes de la catégorie, car je suppose que si j'ai utilisé la méthode suffisante au cours des années que je si elle venait d'Apple, puis d'autres personnes pourraient être en mesure de s'en servir.

Un peu de fonctionnalités que j'ai toujours été surpris, c'est pas dans la classe NSString est la capacité d'ajouter le contenu d'une chaîne sur un fichier existant. Il existe des méthodes pour créer ou remplacer un fichier avec le contenu d'une chaîne, alors pourquoi ne pas ajouter le contenu sur un fichier existant? C'est une tâche assez courante et très utile. Je l'ai utilisé pour créer des journaux d'applications, et pour d'autres situations où j'ai besoin de créer des fichiers volumineux qui ne serait pas pratique pour garder en mémoire. Cela est particulièrement agréable d'avoir sur iOS étant donné le manque de mémoire virtuelle.

Voici la méthode que j'utilise catégorie pour cela. J'ai creusé ce jusqu'à hier d'un ancien projet après avoir cherché pour elle dans la documentation d'Apple. J'ai dû mettre à jour un peu (il était assez vieux pour qu'il utilise les méthodes anciennes cString obsolète.

#import <Foundation/Foundation.h>

@interface NSString(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path usingEncoding:(NSStringEncoding)encoding;
@end


@implementation NSString(MCFileAppend)
- (BOOL)appendToFile:(NSString *)path usingEncoding:(NSStringEncoding)encoding
{
NSFileHandle *fh = [NSFileHandle fileHandleForWritingAtPath:path];
if (fh == nil)
return [self writeToFile:path atomically:YES encoding:encoding error:nil];

[fh truncateFileAtOffset:[fh seekToEndOfFile]];
NSData *encoded = [self dataUsingEncoding:encoding];

if (encoded == nil) return NO;

[fh writeData:encoded];
return YES;
}

@end


lundi 12 mars 2012

Synthétiser par défaut

Donc, à mon post précédent, Je vous ai dit que j'étais excité au sujet de la «synthèse par défaut" fonctionnalité qui est maintenant disponible dans LLVM 1.5. Et je suis très bien ainsi. Mais il s'avère qu'il ya une mise en garde que tempère mon excitation du moment.

Avec ivars synthétisés, nous avons eu un accès direct à la variable sous-jacente de synthèse pour un certain temps maintenant, donc si vous avez créé une classe comme ceci:

#import <UIKit/UIKit.h>

@interface MyViewController : UIViewController
{
}

@property (nonatomic, retain) NSString *foo;
@end


Vous êtes en mesure d'accéder à la variable foo NSString qui sauvegarde la propriété du même nom dans le champ de votre classe. Donc, dans votre méthode dealloc, vous pouvez le faire, pour donner un exemple courant:

- (void)dealloc
{
[foo release], foo = nil;
[super dealloc];
}

Cependant, si vous activez le «synthétiser par défaut» dans LLVM 1.5 et l'utiliser, ce qui signifie que vous n'avez pas vraiment une déclaration synthétiser pour la propriété @ toto, vous perdez cet accès direct aux variables sous-jacentes, vous laissant avec un peu d'une énigme - comment faites-vous votre nettoyage de la mémoire sans déclencher accidentellement une fonctionnalité non désirés, tels que ceux dans un accesseur paresseux ou des manipulateurs plus impliqués.

Plus tôt aujourd'hui, je tweeté une question poser des questions sur la façon correcte de traiter cette situation. Après un peu d'un Qui est le premier-Comme-et-vient avec beaucoup de gens intelligents, il est finalement sorti que cela est un bogue dans LLVM, et non pas une décision de conception intentionnelle. Espérons que cela sera corrigé avant trop longtemps, mais en attendant, la meilleure réponse est probablement juste garder à l'aide de synthétiser @.

Merci à a whole bunch of people on Twitter, many of whom I'm sure I missed!

Moderne ABI & No More @ Synthétiser

Je n'ai pas parlé de l'une de mes préférées de nouvelles fonctionnalités de Xcode 4 et LLVM, parce que je n'étais pas sûr de l'état de la LDN. Toutefois, le chat sortir du sac maintenant, Je me sens comme il est sûr de mentionner. Le simulateur d'iPhone dans Xcode 4 utilise maintenant le moderne ABI (pourtant il est toujours correctement utilise 32 bits des types de données!), Donc nous pouvons utiliser des variables d'instance synthétisée dans nos applications iPhone et utiliser le simulateur. En plus de cela, si vous choisissez d'utiliser LLVM au lieu de GCC, l'un des avantages (nombreux) vous obtiendrez, c'est que la déclaration de synthétiser @ est désormais assumé. Si vous n'avez pas besoin de préciser quoi que ce soit sur la déclaration de synthétiser @ (comme un setter différent ou nom de getter) et votre propriété n'est pas @ dynamique, vous pouvez le justleave off. Cette fonctionnalité n'est pas activée par défaut (encore), mais voir Blog de Pilky Pour obtenir des instructions sur l'activation de cette fonctionnalité.

Moins de code à écrire? Bou-yeah! Comptez sur moi!

Je crois (mais je n'ai pas confirmé cette encore) que vous pouvez écrire du code de cette façon et toujours cibler les versions plus anciennes de retour à 3,0. Si quelqu'un sait par ailleurs, s'il vous plaît faites le moi savoir et je vais passer le mot, cependant.

samedi 10 mars 2012

Dessin d'un affichage HUD dans OpenGL ES

Une chose qui m'a été demandé par un certain nombre de gens est de savoir comment faire un "affichage tête haute" (HUD ou) lorsque vous utilisez OpenGL pour l'affichage en trois dimensions des objets dans une fenêtre en perspective. De nombreux jeux et autres programmes ont besoin de présenter certaines données à l'utilisateur comme si elle était écrite à droite sur l'écran en face du monde en trois dimensions. Mais, si vous avez utilisé glFrustum () pour configurer votre fenêtre qu'il ne ressemblera pas que, depuis n'importe quel dessin fait dans une fenêtre en perspective sera une expérience certaine quantité de distorsion lorsque filtrée à travers la matrice de projection.

La réponse à ce problème est relativement simple et directe. Vous ne laissez pas le dessin HUD passer par la matrice de projection même que les objets en trois dimensions. Sous le capot, la matrice de vue du projet est juste une matrice 4x4 de GLfloats, exactement comme la matrice de vue du modèle que nous utilisons pour transformer des objets dans notre monde virtuel. Et, tout comme la matrice de vue du modèle, nous pouvons apporter des changements à la matrice de projection entre les appels de dessin.

Pour illustrer ce point, je vais prendre l'ancienne icosaèdre projet de la OpenGL ES à partir du sol pour séries et faire un peu de dessin en deux dimensions sur le dessus de l'icosaèdre, exactement de la même façon que vous dessinez un HUD. Pour garder les choses simples, je vais juste faire quelques carrés et un peu de texte, comme ceci:
Screen shot 2010-02-22 at 2.35.14 PM.png

Les trois places et le texte sera dessiné en utilisant une matrice de projection orthographique, alors peu importe la manière dont l'objet derrière elle est transformée, déplacé ou projeté, les trois places et le texte sera rédigé exactement le même sans distorsion ou de mouvement. Vous pouvez utiliser cette technique pour attirer exactement les mêmes score du joueur, la ligne de mire d'un fusil, des contrôles un vaisseau spatial, ou tout autre dessin qui a besoin d'apparaître comme si elle était sur un morceau de verre en face de l'univers virtuel.

Avant de commencer, regardons l'setupView: fonction où nous mettons en place la fenêtre dans l'ancien projet icosaèdre:

-(void)setupView:(GLView*)view
{
GLfloat size;
const GLfloat zNear = 0.1,
zFar = 1000.0,
fieldOfView = 60.0;
size = zNear * tanf(DEGREES_TO_RADIANS(fieldOfView) / 2.0);
CGRect rect = self.view.bounds;
glMatrixMode(GL_PROJECTION);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glFrustumf(-size, size, -size / (rect.size.width / rect.size.height), size /
(rect.size.width / rect.size.height), zNear, zFar);

glViewport(0, 0, rect.size.width, rect.size.height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
colors = [[NSMutableArray alloc] initWithCapacity:20];
for (int i =0; i < 20; i++)
[colors addObject:[UIColor randomColor]];
}

C'est à peu près une tourbière standard perspective viewport configuration qui va permettre à nos objets en trois dimensions pour obtenir plus petits car ils s'éloignent du spectateur. Tout ce que nous tirage au sort sera déformée pour représenter la perspective, que nous ne voulons pas pour nos éléments du HUD. Alors ... Créons un couple de méthodes pratiques pour sortir du mode perspective et en mode orthographique et vice-versa

Tout d'abord, pour passer la projection en mode orthographique, nous allons utiliser cette méthode:

-(void)switchToOrtho 
{
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrthof(0, self.view.bounds.size.width, 0, self.view.bounds.size.height, -5, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

C'est assez simple, mais il faut bien briser la ligne par ligne. La première ligne est important. Nous ne voulons pas le test de profondeur si nous sommes de dessin en deux dimensions parce que nous voulons que tous nos dessin fait sur le même plan, sans profondeur.

Ensuite, nous appelons glMatrixMode () pour rendre la matrice de projection actif. Après cela, nous poussons la matrice de projection existant sur la pile de matrice de sorte que nous pouvons restaurer plus tard. Lorsque ce est appelé, la matrice de projection contient une matrice qui a été généré par notre appel à glFrustum (), et nous devons être en mesure d'y revenir plus tard. Nous avons ensuite la charge de l'identité d'identifier puis mettre en place une projection orthographique où chaque pixel de l'écran équivaut à une unité d'OpenGL, ce qui rendra nos deux dimensions dessin plus facile puisque chaque unité sera égal à un pixel.

Après cela, nous chargeons la matrice identité dans notre matrice de vue modèle si nous commençons à tirer de notre HUD avec une ardoise propre, non affecté par les transformations utilisées précédemment.

En plus d'une méthode pour entrer en mode orthographique, nous avons également besoin d'une méthode pour rétablir notre matrice de projection précédente, celle qui nous avons créé dans setupView:. Depuis que nous avons poussé la matrice de projection existant sur la pile de matrice précédemment, tous nous avons à faire ici est ré-eneable profondeur des tests et la pop de notre matrice de projection vieux de la pile de matrice:

-(void)switchBackToFrustum 
{
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}

Maintenant nous avons la possibilité de basculer entre le mode de perspective et orthographique, nous allons donc faire un peu de dessin. Voici la méthode de dessin du projet icosaèdre avec le code HUD nouveau dessin élaboré en gras. J'ai utilisé la classe Texture2D Apple pour gérer le dessin du texte. J'ai fait cela juste pour la simplicité - c'est loin d'être le moyen le plus efficace pour dessiner le texte dans OpenGL ES. En fait, c'est assez inefficace, mais c'est facile et gratuit. Peut-être je vais me concentrer sur les meilleures façons de dessiner du texte dans une future affectation, mais ce poste est d'environ HUD, pas de texte, afin que nous puissions vivre avec une inefficacité peu.

- (void)drawView:(GLView*)view;
{


static GLfloat rico;
static const GLfloat icosahedronVertices[]= {
0, -0.525731, 0.850651,
0.850651, 0, 0.525731,
0.850651, 0, -0.525731,
-0.850651, 0, -0.525731,
-0.850651, 0, 0.525731,
-0.525731, 0.850651, 0,
0.525731, 0.850651, 0,
0.525731, -0.850651, 0,
-0.525731, -0.850651, 0,
0, -0.525731, -0.850651,
0, 0.525731, -0.850651,
0, 0.525731, 0.850651,
}
;
static const GLubyte icosahedronFaces[] = {
1, 2, 6,
1, 7, 2,
3, 4, 5,
4, 3, 8,
6, 5, 11,
5, 6, 10,
9, 10, 2,
10, 9, 3,
7, 8, 9,
8, 7, 0,
11, 0, 1,
0, 11, 4,
6, 2, 10,
1, 6, 11,
3, 5, 10,
5, 4, 11,
2, 7, 9,
7, 1, 0,
3, 9, 8,
4, 8, 0,
}
;
static const GLubyte icosahedronNumberOfFaces = 60;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Icosahedron
glLoadIdentity();
glEnableClientState(GL_VERTEX_ARRAY);
glTranslatef(0.0f,0.0f,-2.0f);
glRotatef(rico,1.0f,1.0f,1.0f);

glVertexPointer(3, GL_FLOAT, 0, icosahedronVertices);
for(int i = 0; i < icosahedronNumberOfFaces; i += 3)
{
UIColor *oneColor = [colors objectAtIndex:i/3];
[oneColor setOpenGLColor];

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


glDisableClientState(GL_VERTEX_ARRAY);

static NSTimeInterval lastDrawTime;
if (lastDrawTime)
{
NSTimeInterval timeSinceLastDraw = [NSDate timeIntervalSinceReferenceDate] - lastDrawTime;
rico+=50 * timeSinceLastDraw;
}


// ------------------------------------------------
// Draw HUD ---------------------------------------
// ------------------------------------------------
[self switchToOrtho];

static const GLfloat squareVertices[] = {
5.0f, 150.0f,
5.0f, 250.0f,
100.0f, 250.0f,
100.0f, 150.0f
}
;

glLineWidth(3.0);
glColor4f(0.0, 0.0, 1.0, 1.0); // blue
glTranslatef(5.0, 0.0, 0.0);
glVertexPointer(2, GL_FLOAT, 0, squareVertices);
glEnableClientState(GL_VERTEX_ARRAY);

glDrawArrays(GL_LINE_LOOP, 0, 4);
glTranslatef(100.0, 0.0, 0.0);
glColor4f(1.0, 0.0, 0.0, 1.0); // Red
glDrawArrays(GL_LINE_LOOP, 0, 4);
glTranslatef(100.0, 0.0, 0.0);
glColor4f(1.0, 1.0, 0.0, 1.0); // Yellow
glDrawArrays(GL_LINE_LOOP, 0, 4);


glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glColor4f(1.0, 1.0, 1.0, 1.0);
glLoadIdentity();
Texture2D *textTex = [[Texture2D alloc] initWithString:@"Text"
dimensions:CGSizeMake(100., 40.0)
alignment:UITextAlignmentCenter
font:[UIFont boldSystemFontOfSize:36.0]
]
;
[textTex drawAtPoint:CGPointMake(160.0, 440.0) depth:-1];
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);

[self switchBackToFrustum];

lastDrawTime = [NSDate timeIntervalSinceReferenceDate];
}

Nous commençons par appeler notre méthode switchToOrtho. Nous définissons ensuite les sommets d'un carré qui sera établi à l'aide GL_LINE_LOOP et de soumettre ces sommets en utilisant glVertexPointer (). Après cela, nous appelons glDrawArrays () trois fois, en changeant la couleur et faire un transforment traduire entre les appels de telle sorte que chaque carré est dessiné à droite de la précédente et dans une couleur différente.

Après cela, nous utilisons Texture2D de dessiner le mot "texte" sur l'écran. Comme cette classe tire l'essentiel le texte dans un contexte graphique crée ensuite une texture hors de lui, nous avons pour l'activer (et désactiver) un tas de textures options liées.

Après nous sommes tous fait le dessin, que nous appelons la méthode que nous avons créé d'autres, switchBackToFrustum, pour revenir au mode perspective afin que la prochaine fois que notre drawView: méthode est appelée, nous sommes de retour dans trois dimensions de mode.

Et c'est tout ce qu'il ya à dessiner un HUD sur une fenêtre en perspective. Vous pouvez télécharger le projet Xcode ici et de jouer avec elle-même.

jeudi 8 mars 2012

OpenGL ES à partir du sol pour partie 9a: Fondements de l'animation et animation d'images clés

Ce n'est pas l'article que j'ai été à l'origine va poste de n ° 9 de cette série. Cet article va monter en # 10. Avant d'entrer dans OpenGL ES 2.0 et les shaders, cependant, je veux parler de quelque chose de plus fondamental: l'animation.
Note:Vous pouvez trouver le code source qui accompagne cet article here. Une nouvelle version a été téléchargé à l'heure de l'Est 10:14 à celui fixé un problème avec ce pas l'animation (voir les commentaires pour plus de détails).
Maintenant, vous avez déjà vu la forme la plus basique de l'animation dans OpenGL ES. En changeant la rotation, translation, et les transformations d'échelle au fil du temps, nous pouvons objets d'animation. Notre tout premier projet - l'icosaèdre filature - est un exemple de cette forme d'animation, souvent appelé animation simple. Ne laissez pas le nom vous tromper, cependant, vous pouvez faire des animations très complexes en utilisant rien de plus changeant des transformations de matrice au cours du temps.

Mais, comment gérez-vous les animations plus complexes? Dites que vous voulez faire une promenade figure, ou un squish balle comme elle rebondit?

C'est en fait pas si difficile. Il ya deux approches principales à l'animation en OpenGL: animations image clé et squelettique (ou osseuse) des animations basées. Dans cet épisode, nous allons parler des animations image-clé, et dans l'article suivant (9b), nous allons voir à l'animation du squelette.

Interpolation et clés


L'animation est rien de plus que le changement dans la position des sommets au cours du temps. C'est tout. Lorsque vous traduisez, faire pivoter ou redimensionner un objet entier, vous vous déplacez tous les sommets qui composent un objet proportionnellement. Si vous souhaitez animer un objet de manière plus complexe et subtile, vous devez trouver un moyen de déplacer chaque vertex quantités différentes au fil du temps.

Le mécanisme de base utilisé dans les deux types d'animation est de stocker key positions pour chaque vertex dans un objet. En animation par images clés, cela se fait en stockant la position individuelle de chaque vertex pour chaque touche. Pour l'animation du squelette, c'est fait en stockant la position des os virtuel, avec une façon de désigner quel os affectent le mouvement dont les sommets.

Alors, quelles sont les clés? La meilleure façon de les expliquer est de revenir à leur origine, qui est en animation traditionnelle, comme cel le classique (pré-informatique) Disney et Warner Brothers dessins animés. Dans les premiers jours de l'animation, de petites équipes feraient tous les dessins qui composent un court. Mais comme les productions obtenu plus grande, cela est devenu impossible, et ils ont dû commencer à se spécialisant dans des rôles différents. Animateurs les plus expérimentés ont pris sur le rôle des Animateur principal (Parfois appelé animateur clé). Ces animateurs les plus expérimentés ne serait pas dessiner chaque cellule dans une scène, au contraire, ils seraient en tirer les cadres les plus importants. Il s'agit généralement de les extrêmes du mouvement, ou des poses qui a capturé l'essence de la scène. Si elles étaient d'animer un personnage jetant une balle, ils pourraient dessiner, peut-être, l'image où le bras a été le plus en arrière, puis un cadre où le bras est au sommet de l'arc, puis un troisième cadre, où le personnage sorti la balle .

Puis, l'animateur clé serait de passer à une nouvelle scène et un autre animateur a appelé une in-betweener (Parfois appelé bruts dans intervalliste, Car il serait souvent d'emplois d'une autre personne complètement différente pour nettoyer les dessins de intervalliste a) serait alors de savoir combien de temps il y avait entre ces images clés, puis faire tous les dessins intermédiaires. Si la remise a été un lancer d'une seconde, et ils étaient animant moins douze images par seconde, ils auraient à comprendre comment ajouter neuf autres cadres entre les images clés existantes établi par l'animateur principal.

Le concept en trois dimensions keyframe animation est exactement la même. Vous aurez des données de vertex pour les postes clés dans une motion, et vos bruts dans intervalliste sera un algorithme appelé interpolation.

Interpolation est quelques-uns des plus simples de mathématiques que vous allez faire dans les graphiques en trois dimensions. Pour chacune des dimensions cartésiennes (x, y, z), il vous suffit de prendre la différence entre les deux valeurs d'images clés, déterminer combien de temps s'est écoulé animation totale, et de diviser la différence par la partie fractionnaire.

Il serait plus logique si nous faisons un exemple pratique. Disons simplement regarder un sommet. Dans notre première image-clé, nous allons prétendre que c'est à l'origine (0, 0, 0). Pour la deuxième image clé, nous allons supposer que c'est à (5, 5, 5), et la durée entre ces deux images-clés, si cinq secondes (juste pour garder les maths agréable et simple).

Si nous sommes une seconde dans l'animation, nous avons juste à comprendre la différence entre les deux sommets pour chaque axe. Ainsi, dans notre cas, la totalité du déplacement entre les deux images-clés, si cinq unités sur chacun des x, y, et z (cinq moins zéro est égal à cinq). Donc, si nous sommes une seconde dans nos cinq seconde animation, nous sommes 1/5ème de la voie à travers, donc nous ajoutons 1/5ème de cinq à la première image-clé de x, y, et z, pour arriver à une position de (1, 1, 1). Maintenant, les chiffres ne seront pas habituellement que très bien, mais le calcul est exactement le même. Calculez la différence, puis déterminer en fonction du temps écoulé quel pourcentage de la manière à travers cette action, nous sommes, il faut multiplier la différence sur chaque axe par cette fraction, puis ajouter le résultat à la valeur de la première image clé pour cet axe.

C'est la forme la plus simple d'interpolation, appelé interpolation linéaire et c'est très bien pour la plupart des buts. Il existe des algorithmes plus complexes que le poids de l'interpolation basée sur quelle distance dans l'animation que vous êtes. Core Animation, par exemple, offre la possibilité de «facilité à", "ease out», ou «la facilité d'entrée / sortie" lors de la réalisation d'une animation. Peut-être que nous allons couvrir non linéaire d'interpolation dans un futur article, mais pour aujourd'hui, nous allons juste garder les choses simples et de travailler avec une interpolation linéaire. Vous pouvez faire la grande majorité de ce que vous voulez avec cette technique tout en modifiant le nombre d'images clés et la durée entre les deux

Animation d'images clés dans OpenGLES


Regardons un exemple très simple de l'animation dans OpenGL ES. Lorsque traditionnelle dessinée à la main animateurs sont formés, la première chose qu'ils font est d'animer une balle qui rebondit que squishes comme elle rebondit. Il semble que normal pour nous de faire la même chose, donc voici ce que notre application va ressembler:
bouncy.png

Commençons par la création d'une balle dans Blender (Ou tout autre programme 3D que vous voulez utiliser, si vous avez un moyen d'exporter les données de vertex et normale d'une manière utilisable. Dans cet exemple, je vais utiliser mon Blender exporter un script, Qui génère des fichiers d'en-tête avec les données de vertex.

Je commence par la création d'une icosphère à l'origine. Je renommer le maillage à Ball1, Puis-je sauvegarder ce fichier en tant Ball1.blend et à l'exportation Ball1.blend en utilisant mon script d'export. Vous pouvez trouver mon fichier Blender pour cette image clé here.
Screen shot 2009-12-15 at 2.45.21 PM.png

Maintenant, je fais un Enregistrer sous (F2) et enregistrer une copie du fichier que Ball2.blend. Dans cette copie, je renommer le maillage Ball2 de sorte que le script d'export utilise des noms différents pour les structures de données. Puis j'ai frappé 'tab' pour passer en mode édition, appuyez sur 'A' et déplacer et redimensionner les sommets de la balle afin qu'elle soit déplacée vers le bas et est écrasé. Je sauvegarder la balle écrasée et l'exportation Ball2.h. Vous pouvez trouver mon fichier Blender pour la deuxième image clé here.

Screen shot 2009-12-15 at 3.52.42 PM.png


À ce point, j'ai deux fichiers. H, chacun contenant les positions des sommets pour une image clé dans mon animation. Travaillant à partir mon modèle OpenGL ESJe définis d'abord quelques valeurs dans le GLViewControler.h pour m'aider à garder la trace de l'animation:
#define kAnimationDuration  0.3
enum animationDirection {
kAnimationDirectionForward = YES,
kAnimationDirectionBackward = NO
}
;
typedef BOOL AnimationDirection;

Comme je vais rebondir et-vient entre les deux images clés, j'ai besoin de garder trace de savoir si c'est voyager avant ou en arrière. J'ai également définir une valeur de contrôler à quelle vitesse il se déplace entre les deux images-clés.

Puis, en GLViewController.m, Je interpoler entre les deux images-clés à plusieurs reprises, comme tant d'(ne vous inquiétez pas, je vais vous expliquer):
- (void)drawView:(UIView *)theView
{
static NSTimeInterval lastKeyframeTime = 0.0;
if (lastKeyframeTime == 0.0)
lastKeyframeTime = [NSDate timeIntervalSinceReferenceDate];
static AnimationDirection direction = kAnimationDirectionForward;

glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,2.2f,-6.0f);
glRotatef(-90.0, 1.0, 0.0, 0.0); // Blender uses Z-up, not Y-up like OpenGL ES

static VertexData3D ballVertexData[kBall1NumberOfVertices];

glColor4f(0.0, 0.3, 1.0, 1.0);
glEnable(GL_COLOR_MATERIAL);
NSTimeInterval timeSinceLastKeyFrame = [NSDate timeIntervalSinceReferenceDate] - lastKeyframeTime;
if (timeSinceLastKeyFrame > kAnimationDuration) {
direction = !direction;
timeSinceLastKeyFrame = timeSinceLastKeyFrame - kAnimationDuration;
lastKeyframeTime = [NSDate timeIntervalSinceReferenceDate];
}

NSTimeInterval percentDone = timeSinceLastKeyFrame / kAnimationDuration;

VertexData3D *source, *dest;
if (direction == kAnimationDirectionForward)
{
source = (VertexData3D *)Ball1VertexData;
dest = (VertexData3D *)Ball2VertexData;
}

else
{
source = (VertexData3D *)Ball2VertexData;
dest = (VertexData3D *)Ball1VertexData;
}


for (int i = 0; i < kBall1NumberOfVertices; i++)
{
GLfloat diffX = dest[i].vertex.x - source[i].vertex.x;
GLfloat diffY = dest[i].vertex.y - source[i].vertex.y;
GLfloat diffZ = dest[i].vertex.z - source[i].vertex.z;
GLfloat diffNormalX = dest[i].normal.x - source[i].normal.x;
GLfloat diffNormalY = dest[i].normal.y - source[i].normal.y;
GLfloat diffNormalZ = dest[i].normal.z - source[i].normal.z;

ballVertexData[i].vertex.x = source[i].vertex.x + (percentDone * diffX);
ballVertexData[i].vertex.y = source[i].vertex.y + (percentDone * diffY);
ballVertexData[i].vertex.z = source[i].vertex.z + (percentDone * diffZ);
ballVertexData[i].normal.x = source[i].normal.x + (percentDone * diffNormalX);
ballVertexData[i].normal.y = source[i].normal.y + (percentDone * diffNormalY);
ballVertexData[i].normal.z = source[i].normal.z + (percentDone * diffNormalZ);

}


glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(VertexData3D), &Ball2VertexData[0].vertex);
glNormalPointer(GL_FLOAT, sizeof(VertexData3D), &Ball2VertexData[0].normal);
glDrawArrays(GL_TRIANGLES, 0, kBall1NumberOfVertices);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);


}



Tout d'abord, je commence avec une certaine configuration. J'ai créer une variable statique pour garder trace du moment où nous avons touché la dernière image-clé. Ce sera nécessaire pour déterminer combien de temps s'est écoulé. La première fois grâce, nous l'initialiser à l'heure actuelle, nous déclarons une variable pour garder la trace que nous sommes animation avant ou en arrière.

    static NSTimeInterval lastKeyframeTime = 0.0;
if (lastKeyframeTime == 0.0)
lastKeyframeTime = [NSDate timeIntervalSinceReferenceDate];
static AnimationDirection direction = kAnimationDirectionForward;


Après cela, nous ne la normale des choses OpenGL ES. La seule chose à noter ici est que nous faisons tourner -90 ^ 0 sur l'axe des abscisses. Nous sommes la comptabilité pour le fait que l'OpenGL ES utilise un système Y-jusqu'à coordonner et Blender utilise un Z-up. Nous aurions aussi pu tourner dans Blender lieu.

    glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,2.2f,-6.0f);
glRotatef(-90.0, 1.0, 0.0, 0.0); // Blender uses Z-up, not Y-up like OpenGL ES

Ensuite, je déclare un tableau statique pour contenir les données interpolées:
    static VertexData3D ballVertexData[kBall1NumberOfVertices];


Juste pour garder les choses simples, j'ai mis une couleur et les matériaux permettant de couleur. Je ne voulais pas encombrer cet exemple avec texture ou ses matériaux.

    glColor4f(0.0, 0.3, 1.0, 1.0);
glEnable(GL_COLOR_MATERIAL);

Maintenant je calcule combien de temps s'est écoulé depuis la dernière image-clé. Si le temps écoulé est supérieure à la durée de l'animation, nous inverser la direction autour de sorte que nous allons dans l'autre sens.
    NSTimeInterval timeSinceLastKeyFrame = [NSDate timeIntervalSinceReferenceDate] - lastKeyframeTime;
if (timeSinceLastKeyFrame > kAnimationDuration) {
direction = !direction;
timeSinceLastKeyFrame = timeSinceLastKeyFrame - kAnimationDuration;
lastKeyframeTime = [NSDate timeIntervalSinceReferenceDate];
}

NSTimeInterval percentDone = timeSinceLastKeyFrame / kAnimationDuration;


Afin d'accommoder bi-directionnel animation, je déclarer deux pointeurs vers les données source d'images clés et de données de destination keyframe, et le point à chacun de le tableau de données approprié en fonction de la direction que nous sommes actuellement en cours.

    VertexData3D *source, *dest;
if (direction == kAnimationDirectionForward)
{
source = (VertexData3D *)Ball1VertexData;
dest = (VertexData3D *)Ball2VertexData;
}

else
{
source = (VertexData3D *)Ball2VertexData;
dest = (VertexData3D *)Ball1VertexData;
}


Et, enfin, l'interpolation. Voici une application assez générique de cette interpolation linéaire dont nous parlions:
    for (int i = 0; i < kBall1NumberOfVertices; i++) 
{
GLfloat diffX = dest[i].vertex.x - source[i].vertex.x;
GLfloat diffY = dest[i].vertex.y - source[i].vertex.y;
GLfloat diffZ = dest[i].vertex.z - source[i].vertex.z;
GLfloat diffNormalX = dest[i].normal.x - source[i].normal.x;
GLfloat diffNormalY = dest[i].normal.y - source[i].normal.y;
GLfloat diffNormalZ = dest[i].normal.z - source[i].normal.z;

ballVertexData[i].vertex.x = source[i].vertex.x + (percentDone * diffX);
ballVertexData[i].vertex.y = source[i].vertex.y + (percentDone * diffY);
ballVertexData[i].vertex.z = source[i].vertex.z + (percentDone * diffZ);
ballVertexData[i].normal.x = source[i].normal.x + (percentDone * diffNormalX);
ballVertexData[i].normal.y = source[i].normal.y + (percentDone * diffNormalY);
ballVertexData[i].normal.z = source[i].normal.z + (percentDone * diffNormalZ);

}

Ensuite, tout ce qui reste à faire est de faire un travail de nettoyage.
    glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(VertexData3D), &Ball2VertexData[0].vertex);
glNormalPointer(GL_FLOAT, sizeof(VertexData3D), &Ball2VertexData[0].normal);
glDrawArrays(GL_TRIANGLES, 0, kBall1NumberOfVertices);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);

}

Pas si difficile, non? C'est juste la division, la multiplication et l'addition. Par rapport à certaines des choses que nous avons traversé jusqu'ici, ce n'est rien. C'est la technique de base utilisée, par exemple, dans le MD2 format de fichier utilisé par Id dans leurs anciens jeux. Chaque animation utilisée est réalisée en utilisant keyframe animation, tout comme je l'ai fait ici. Les versions ultérieures de formats de support Milkshape autre fichier, mais vous pouvez faire des animations très sophistiquées utilisant des images clés.

Si vous voulez vérifier la boule gonflable, vous pouvez télécharger mes Xcode projet et exécutez-le pour vous-même.

Pas tous d'animation 3D se fait en utilisant des images clés, mais l'interpolation est le mécanisme de base qui permet à tous d'animation complexes. Restez branchés pour le prochain épisode, 9b, où nous utilisons l'interpolation de mettre en œuvre une forme beaucoup plus complexe d'animation appelé animation squelettique.