Mike Rundle vient de mettre en place un débutant vraiment gentil de tutoriel sur les applications du programme SDK iOS à partir de zéro. Bien que je suis en désaccord avec lui assez violemment pour savoir si vous devez utiliser Interface Builder (non, vraiment, vous devriez l'utiliser), c'est sinon une brillante introduction, l'un des meilleurs que j'ai vu sur le web pour les débutants.
Affichage des articles dont le libellé est tutoriels. Afficher tous les articles
Affichage des articles dont le libellé est tutoriels. Afficher tous les articles
mardi 20 mars 2012
dimanche 18 mars 2012
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.
lundi 12 mars 2012
Vues personnalisées alerte
Il ya quelque temps, j'ai posté un moyen de accepter une entrée de texte en utilisant une vue d'alerte. Le problème avec cette technique est qu'elle s'appuie sur l'une des API privées d'Apple. J'ai eu beaucoup de gens me demandent comment utiliser cette technique sans se faire rejeter dans le processus d'examen. La réponse courte est: vous ne pouvez pas.
Qu'est-ce que vous pouvez faire, cependant, est de créer votre propre classe qui simule le comportement d'UIAlertView. Vous pouvez trouver un exemple d'implémentation de la technique discutée à ce poste par le téléchargement de ce projet. Dans cet exemple simple, nous allons créer une vue d'alerte qui permet à l'utilisateur d'entrer une valeur dans un champ de texte unique. La même technique peut être utilisée pour présenter toute opinion que vous pouvez construire dans Interface Builder. Du point de vue programmation, vous ne serez pas rejeté pour l'aide d'API privée si vous utilisez cette technique, mais sachez que vous pouvez toujours obtenir rejetée pour des violations HIG, alors assurez-vous familiariser avec les HIG.
Il ya plusieurs façons d'imiter le comportement de l'UIAlertView. Une des façons les plus courantes que j'ai vu est tout simplement de la conception d'une vue d'alerte dans le bec du contrôleur estime que les besoins de le présenter. Cela fonctionne, mais c'est un peu salissant et peu près complètement non-réutilisables.
Une meilleure approche est de concevoir l'affichage des alertes que son contrôleur propre point de vue et une paire plume. On peut même le modèle après UIAlertView du feu et oublier l'approche de telle sorte que le code appelant peut ressembler exactement à code pour créer et afficher une UIAlertView. Avant de commencer, nous avons besoin d'un peu de ressources.
Vous avez probablement remarqué que lorsque vous utilisez une vue d'alerte, les gris actifs vue un peu. Je ne sais pas vraiment comment Apple a réalisé cela, mais nous pouvons simuler le comportement en utilisant une image PNG avec un dégradé circulaire qui va de 60% de noir opaque à 40% de noir opaque:

Nous avons également besoin d'une image de fond pour l'affichage des alertes. Voici celle que j'ai piraté dans Pixelmator
Pour vos propres alertes, vous pourriez avoir besoin de redimensionner ou de transformer ceci en une image extensible. Par souci de simplicité, j'ai juste fait la taille je le veux. Nous avons également besoin de boutons. Encore une fois, dans un exemple réel, vous pouvez les transformer en images étirable, mais j'ai juste gardé les choses simples en faisant l'image de la taille que je le voulais:

La prochaine chose que nous avons besoin est un code d'animation. Nous pourrions, bien sûr, créer les instances CAAnimation droit dans notre classe, mais je suis un grand fan de la réutilisation du code à la fois et Objective-C les catégories, ainsi au lieu de faire cela, j'ai créé une catégorie sur UIView qui va gérer l' deux animations nous avons besoin. Une animation «POP dans" une vue et sera utilisé pour montrer l'affichage des alertes, les fondus d'autres dans une vue et sera utilisé pour l'image de fond gris. Les deux animations se produisent dans le même temps de sorte que lorsque l'alerte a parfaitement sauté dans vue, la vue arrière est grisée.
Les timings image-clé du "pop" code d'animation ne sont pas tout à fait un match à 100% pour l'animation d'Apple, donc si quelqu'un veut modifier les valeurs keyframe de faire une meilleure adéquation, je serais heureux de mettre à jour le code avec le bon " «valeurs. Voici la catégorie I créée pour détenir les animations:
UIView-AlertAnimations.h
UIView-AlertAnimations.m
Comme vous pouvez le voir, j'ai fourni deux versions de chaque animation, celui qui accepte un délégué d'animation et un qui ne fonctionne pas. Cela permet au code appelant à mettre un délégué animation ainsi il peut être avisé de choses comme lorsque l'animation se termine. Nous allons utiliser un délégué pour l'un de nos animations, mais nous pourrions aussi bien avoir l'option avec les deux.
La prochaine chose que nous devons faire est de créer l'en-tête contrôleur de vue, la mise en œuvre, et les fichiers nib. Dans mon exemple de code, j'ai nommé le CustomAlertView classe. Il peut sembler étrange que je donne une classe contrôleur de vue d'un nom qui fait sonner comme une vue au lieu de quelque chose comme CustomAlertViewController. Vous pouvez vous sentir libre à la vôtre nom comme vous le souhaitez, mais cette classe contrôleur sera effectivement imiter le comportement de UIAlertView et je voulais le nom pour refléter cela. J'ai débattu avec moi-même sur le nom pour un peu, mais a finalement décidé que CustomAlertView sentait mieux puisque le nom donnerait un indice quant à la façon de l'utiliser. Si elle se sent sale à vous de «mensonge» dans le nom de la classe, puis par tous les moyens, la vôtre nom différemment.
Nous allons avoir besoin de certaines méthodes d'action et de certains points de vente afin que notre contrôleur et fichier nib peuvent interagir. Une sortie sera pour l'image de fond, un autre pour l'affichage des alertes lui-même, et une pour le champ de texte. Cette dernière est nécessaire afin que nous puissions dire au champ de texte à accepter et démissionner statut de Première répondeur. Nous allons utiliser une méthode d'action unique pour les deux boutons sur le qui-vive, et nous allons utiliser la valeur tag du bouton à la différence entre les deux boutons.
Parce que nous mettons en œuvre le feu et oublier, nous avons aussi besoin de définir un protocole contenant les méthodes du délégué peut mettre en œuvre. Depuis l'alerte est conçu pour accepter l'entrée, j'ai fait la méthode du délégué utilisé pour recevoir l'entrée @ nécessaire, mais l'autre méthode (appelée uniquement lorsque annulé) @ optionnel. L'énumération est ici juste pour rendre le code plus lisible quand il s'agit de traiter avec les valeurs balise button.
CustomAlertView.h
Une fois le fichier d'entête est terminé et enregistré, on peut sauter d'Interface Builder et créer notre interface. Je ne vais pas vous guider à travers le processus de construction de l'interface, mais je vais souligner les choses importantes. Voici ce que la vue sera ressemble dans Interface Builder:

Certaines choses importantes:
Une fois l'interface est créé, tout ce qui reste à faire est d'implémenter la classe contrôleur. Voici la mise en œuvre; je vais vous expliquer ce qui se passe en un instant:
CustomAlertView.m
Alors, qu'est-ce qu'on fait ici? Tout d'abord, nous commençons par l'importation de la catégorie avec nos animations affichage des alertes et aussi QuartzCore.h ce qui nous donne accès à tous les types de données utilisés dans les Core Animation.
Ensuite, nous déclarons une extension de classe avec une méthode unique. En mettant cette méthode ici, nous pouvons l'utiliser n'importe où dans notre classe sans avoir les avertissements du compilateur et pourtant nous ne le diffuse pas l'existence de cette méthode pour le monde. C'est, essentiellement, une méthode privée. Dans un langage dynamique comme Objective-C, il n'existe aucune méthode vraiment privé, mais puisque la méthode n'est pas déclarée dans le fichier en-tête, c'est notre façon de dire «ceci est la nôtre, ne pas toucher». Cette méthode, que vous verrez dans un instant, sera appelé après l'alerte a été rejetée pour le retirer de son SuperView. Nous ne voulons pas de l'enlever qu'après l'animation fade-out est terminé, c'est pourquoi nous avons déclaré une méthode distincte.
Après nous synthétisons nos propriétés, la première méthode que nous écrivons est spectacle. C'est la méthode qui est appelée à bien ... afficher l'alerte. J'ai adapté le nom de méthode utilisée dans UIAlertView et fait également un IBAction afin qu'il puisse être déclenchée directement à l'intérieur d'un fichier nib.
Le plus étrange partie de cette méthode est qu'elle conserve réellement soi-même. C'est quelque chose que vous êtes généralement ne vont pas vouloir le faire. Depuis que nous avons mis en œuvre notre vision d'alerte comme un contrôleur de vue au lieu d'une sous-classe UIView comme UIAlertView, nous avons besoin de tricher un peu, car un contrôleur de vue n'est pas retenu par quelque chose par la vertu de son point de vue être dans la hiérarchie d'affichage. Ce n'est pas faux - que nous allons garder notre bookend avec un communiqué (ainsi, en réalité, une autorelease) donc pas de fuite de mémoire, mais il est inhabituel et non quelque chose que vous allez avoir à utiliser dans des endroits très nombreuses . Quand vous retenez l'auto, vous avez besoin de prendre un long regard dur à votre code et vous assurer d'avoir une sacrée bonne raison pour le faire. Dans ce cas, nous le faisons.
Après avoir retenu, on récupère une référence à la fenêtre par l'intermédiaire du délégué de l'application et d'ajouter notre point de vue à la fenêtre, correspondant de son cadre. Ensuite, nous appelons les deux méthodes d'animation nous avons créé précédemment à s'estomper dans l'image avec le dégradé circulaire et "pop" dans la vue d'alerte:
La méthode la prochaine action que nous écrivons est celle qui est appelée par les deux boutons sur le qui-vive. Peu importe quel bouton a été poussé, nous voulons que le champ de texte à démissionner statut de Première répondeur afin que le clavier disparaît, et nous voulons que l'alerte à s'estomper. Nous allons utiliser des animations implicitement cette fois et ensuite utiliser performSelector withObject: afterDelay: pour déclencher notre méthode privée qui va enlever la vue de son SuperView. Après cela, nous vérifions valeur de la balise de l'expéditeur pour voir quelle méthode déléguée à notifier.
Le viewDidUnload et dealloc sont standard tourbière, donc il ne sert à rien d'en discuter. La méthode suivante après celles-ci est notre "privée" méthode. Il ne fait que supprimer l'affichage maintenant invisible alerte de la hiérarchie d'affichage et de autoreleases auto pour que le contrôleur de vue sera publié à la fin de l'itération de la boucle d'exécution actuel. Nous ne voulons pas d'utiliser la libération parce que nous ne voulez vraiment pas l'objet disparaît alors un de ses méthode s'exécute:
Auparavant, lorsque nous avons créé le "pop" l'animation, nous avons spécifié l'auto en tant que délégué. La méthode suivante nous mettons en œuvre est appelée lorsque le "pop" animation complète en vertu de ce fait. Tout ce que nous faisons ici est de s'assurer que le clavier est montré à l'utilisateur et associée à notre champ de texte. Nous faisons tout cela simplement en faisant le champ de texte du premier intervenant:
Enfin, nous mettons en œuvre l'une des méthodes texte du délégué sur le terrain de sorte que lorsque l'utilisateur appuie sur la touche de retour sur le clavier, il rejette le dialogue.
À ce stade, nous avons terminé. Nous pouvons maintenant utiliser cette vue alerte personnalisée exactement de la même façon que nous utilisons UIAlertView:
Comme je l'ai indiqué précédemment, vous pouvez utiliser cette même technique pour présenter tout ce que vous pouvez construire dans Interface Builder, et le résultat sera un objet hautement réutilisables alerte.
Qu'est-ce que vous pouvez faire, cependant, est de créer votre propre classe qui simule le comportement d'UIAlertView. Vous pouvez trouver un exemple d'implémentation de la technique discutée à ce poste par le téléchargement de ce projet. Dans cet exemple simple, nous allons créer une vue d'alerte qui permet à l'utilisateur d'entrer une valeur dans un champ de texte unique. La même technique peut être utilisée pour présenter toute opinion que vous pouvez construire dans Interface Builder. Du point de vue programmation, vous ne serez pas rejeté pour l'aide d'API privée si vous utilisez cette technique, mais sachez que vous pouvez toujours obtenir rejetée pour des violations HIG, alors assurez-vous familiariser avec les HIG.
Il ya plusieurs façons d'imiter le comportement de l'UIAlertView. Une des façons les plus courantes que j'ai vu est tout simplement de la conception d'une vue d'alerte dans le bec du contrôleur estime que les besoins de le présenter. Cela fonctionne, mais c'est un peu salissant et peu près complètement non-réutilisables.
Une meilleure approche est de concevoir l'affichage des alertes que son contrôleur propre point de vue et une paire plume. On peut même le modèle après UIAlertView du feu et oublier l'approche de telle sorte que le code appelant peut ressembler exactement à code pour créer et afficher une UIAlertView. Avant de commencer, nous avons besoin d'un peu de ressources.
Vous avez probablement remarqué que lorsque vous utilisez une vue d'alerte, les gris actifs vue un peu. Je ne sais pas vraiment comment Apple a réalisé cela, mais nous pouvons simuler le comportement en utilisant une image PNG avec un dégradé circulaire qui va de 60% de noir opaque à 40% de noir opaque:

Nous avons également besoin d'une image de fond pour l'affichage des alertes. Voici celle que j'ai piraté dans Pixelmator

Pour vos propres alertes, vous pourriez avoir besoin de redimensionner ou de transformer ceci en une image extensible. Par souci de simplicité, j'ai juste fait la taille je le veux. Nous avons également besoin de boutons. Encore une fois, dans un exemple réel, vous pouvez les transformer en images étirable, mais j'ai juste gardé les choses simples en faisant l'image de la taille que je le voulais:

La prochaine chose que nous avons besoin est un code d'animation. Nous pourrions, bien sûr, créer les instances CAAnimation droit dans notre classe, mais je suis un grand fan de la réutilisation du code à la fois et Objective-C les catégories, ainsi au lieu de faire cela, j'ai créé une catégorie sur UIView qui va gérer l' deux animations nous avons besoin. Une animation «POP dans" une vue et sera utilisé pour montrer l'affichage des alertes, les fondus d'autres dans une vue et sera utilisé pour l'image de fond gris. Les deux animations se produisent dans le même temps de sorte que lorsque l'alerte a parfaitement sauté dans vue, la vue arrière est grisée.
Les timings image-clé du "pop" code d'animation ne sont pas tout à fait un match à 100% pour l'animation d'Apple, donc si quelqu'un veut modifier les valeurs keyframe de faire une meilleure adéquation, je serais heureux de mettre à jour le code avec le bon " «valeurs. Voici la catégorie I créée pour détenir les animations:
UIView-AlertAnimations.h
#import <Foundation/Foundation.h>
@interface UIView(AlertAnimations)
- (void)doPopInAnimation;
- (void)doPopInAnimationWithDelegate:(id)animationDelegate;
- (void)doFadeInAnimation;
- (void)doFadeInAnimationWithDelegate:(id)animationDelegate;
@end
UIView-AlertAnimations.m
#import "UIView-AlertAnimations.h"
#import <QuartzCore/QuartzCore.h>
#define kAnimationDuration 0.2555
@implementation UIView(AlertAnimations)
- (void)doPopInAnimation
{
[self doPopInAnimationWithDelegate:nil];
}
- (void)doPopInAnimationWithDelegate:(id)animationDelegate
{
CALayer *viewLayer = self.layer;
CAKeyframeAnimation* popInAnimation = [CAKeyframeAnimation animationWithKeyPath:@"transform.scale"];
popInAnimation.duration = kAnimationDuration;
popInAnimation.values = [NSArray arrayWithObjects:
[NSNumber numberWithFloat:0.6],
[NSNumber numberWithFloat:1.1],
[NSNumber numberWithFloat:.9],
[NSNumber numberWithFloat:1],
nil];
popInAnimation.keyTimes = [NSArray arrayWithObjects:
[NSNumber numberWithFloat:0.0],
[NSNumber numberWithFloat:0.6],
[NSNumber numberWithFloat:0.8],
[NSNumber numberWithFloat:1.0],
nil];
popInAnimation.delegate = animationDelegate;
[viewLayer addAnimation:popInAnimation forKey:@"transform.scale"];
}
- (void)doFadeInAnimation
{
[self doFadeInAnimationWithDelegate:nil];
}
- (void)doFadeInAnimationWithDelegate:(id)animationDelegate
{
CALayer *viewLayer = self.layer;
CABasicAnimation *fadeInAnimation = [CABasicAnimation animationWithKeyPath:@"opacity"];
fadeInAnimation.fromValue = [NSNumber numberWithFloat:0.0];
fadeInAnimation.toValue = [NSNumber numberWithFloat:1.0];
fadeInAnimation.duration = kAnimationDuration;
fadeInAnimation.delegate = animationDelegate;
[viewLayer addAnimation:fadeInAnimation forKey:@"opacity"];
}
@endComme vous pouvez le voir, j'ai fourni deux versions de chaque animation, celui qui accepte un délégué d'animation et un qui ne fonctionne pas. Cela permet au code appelant à mettre un délégué animation ainsi il peut être avisé de choses comme lorsque l'animation se termine. Nous allons utiliser un délégué pour l'un de nos animations, mais nous pourrions aussi bien avoir l'option avec les deux.
La prochaine chose que nous devons faire est de créer l'en-tête contrôleur de vue, la mise en œuvre, et les fichiers nib. Dans mon exemple de code, j'ai nommé le CustomAlertView classe. Il peut sembler étrange que je donne une classe contrôleur de vue d'un nom qui fait sonner comme une vue au lieu de quelque chose comme CustomAlertViewController. Vous pouvez vous sentir libre à la vôtre nom comme vous le souhaitez, mais cette classe contrôleur sera effectivement imiter le comportement de UIAlertView et je voulais le nom pour refléter cela. J'ai débattu avec moi-même sur le nom pour un peu, mais a finalement décidé que CustomAlertView sentait mieux puisque le nom donnerait un indice quant à la façon de l'utiliser. Si elle se sent sale à vous de «mensonge» dans le nom de la classe, puis par tous les moyens, la vôtre nom différemment.
Nous allons avoir besoin de certaines méthodes d'action et de certains points de vente afin que notre contrôleur et fichier nib peuvent interagir. Une sortie sera pour l'image de fond, un autre pour l'affichage des alertes lui-même, et une pour le champ de texte. Cette dernière est nécessaire afin que nous puissions dire au champ de texte à accepter et démissionner statut de Première répondeur. Nous allons utiliser une méthode d'action unique pour les deux boutons sur le qui-vive, et nous allons utiliser la valeur tag du bouton à la différence entre les deux boutons.
Parce que nous mettons en œuvre le feu et oublier, nous avons aussi besoin de définir un protocole contenant les méthodes du délégué peut mettre en œuvre. Depuis l'alerte est conçu pour accepter l'entrée, j'ai fait la méthode du délégué utilisé pour recevoir l'entrée @ nécessaire, mais l'autre méthode (appelée uniquement lorsque annulé) @ optionnel. L'énumération est ici juste pour rendre le code plus lisible quand il s'agit de traiter avec les valeurs balise button.
CustomAlertView.h
#import <UIKit/UIKit.h>
enum
{
CustomAlertViewButtonTagOk = 1000,
CustomAlertViewButtonTagCancel
};
@class CustomAlertView;
@protocol CustomAlertViewDelegate
@required
- (void) CustomAlertView:(CustomAlertView *)alert wasDismissedWithValue:(NSString *)value;
@optional
- (void) customAlertViewWasCancelled:(CustomAlertView *)alert;
@end
@interface CustomAlertView : UIViewController <UITextFieldDelegate>
{
UIView *alertView;
UIView *backgroundView;
UITextField *inputField;
id<NSObject, CustomAlertViewDelegate> delegate;
}
@property (nonatomic, retain) IBOutlet UIView *alertView;
@property (nonatomic, retain) IBOutlet UIView *backgroundView;
@property (nonatomic, retain) IBOutlet UITextField *inputField;
@property (nonatomic, assign) IBOutlet id<CustomAlertViewDelegate, NSObject> delegate;
- (IBAction)show;
- (IBAction)dismiss:(id)sender;
@end
Une fois le fichier d'entête est terminé et enregistré, on peut sauter d'Interface Builder et créer notre interface. Je ne vais pas vous guider à travers le processus de construction de l'interface, mais je vais souligner les choses importantes. Voici ce que la vue sera ressemble dans Interface Builder:

Certaines choses importantes:
- Le point de vue contenu doit être pas opaque et sa couleur de fond devrait être fixé à un blanc avec une opacité de 0%. L'alpha de la vue devrait être de 1,0. Alpha est héritée par les sous-vues, la couleur de fond n'est pas, donc en le rendant transparent en utilisant la couleur de fond, nous serons en mesure de voir tous les sous-vues. Si nous nous étions fixés alpha à 0.0 au lieu, nous ne serions pas capable de voir l'affichage des alertes;
- La vue arrière est un UIImageView qui est la même taille que l'affichage du contenu. Ses attributs autosize sont définies de sorte qu'il redimensionne avec la vue du contenu et il est connecté à la prise backgroundView. Il doit pas être opaque et son alpha doit être réglé à 1,0. Même si nous sera d'animer l'alpha, nous voulons la plume afin de refléter la valeur finale;
- Tous les éléments d'interface qui composent l'alerte à proprement parler sont tous sous-vues d'une seule instance de UIView, dont la couleur de fond est également mise à blanc avec une opacité de 0% et n'est pas opaque afin qu'il soit invisible. Cette vue est utilisée uniquement pour regrouper les éléments de sorte qu'ils peuvent être animés ensemble et est ce que la prise alertView pointera vers;
- La vue d'alerte n'est pas centré. Dans ce cas, nous voulons qu'il reste centré dans l'espace restant au-dessus du clavier;
- The OK bouton a son tag mis à 1 000 dans l'inspecteur de l'attribut. L' Cancel bouton a son ensemble de balises pour 1001. Ces chiffres correspondent aux valeurs de l'énumération que nous avons créé dans le fichier d'entête
- Fichier de propriétaire est le délégué du champ de texte. Cela permet au contrôleur d'être averti lorsque l'utilisateur appuie sur la touche de retour sur le clavier
Une fois l'interface est créé, tout ce qui reste à faire est d'implémenter la classe contrôleur. Voici la mise en œuvre; je vais vous expliquer ce qui se passe en un instant:
CustomAlertView.m
#import "CustomAlertView.h"
#import "UIView-AlertAnimations.h"
#import <QuartzCore/QuartzCore.h>
@interface CustomAlertView()
- (void)alertDidFadeOut;
@end
@implementation CustomAlertView
@synthesize alertView;
@synthesize backgroundView;
@synthesize inputField;
@synthesize delegate;
#pragma mark -
#pragma mark IBActions
- (IBAction)show
{
// Retaining self is odd, but we do it to make this "fire and forget"
[self retain];
// We need to add it to the window, which we can get from the delegate
id appDelegate = [[UIApplication sharedApplication] delegate];
UIWindow *window = [appDelegate window];
[window addSubview:self.view];
// Make sure the alert covers the whole window
self.view.frame = window.frame;
self.view.center = window.center;
// "Pop in" animation for alert
[alertView doPopInAnimationWithDelegate:self];
// "Fade in" animation for background
[backgroundView doFadeInAnimation];
}
- (IBAction)dismiss:(id)sender
{
[inputField resignFirstResponder];
[UIView beginAnimations:nil context:nil];
self.view.alpha = 0.0;
[UIView commitAnimations];
[self performSelector:@selector(alertDidFadeOut) withObject:nil afterDelay:0.5];
if (sender == self || [sender tag] == CustomAlertViewButtonTagOk)
[delegate CustomAlertView:self wasDismissedWithValue:inputField.text];
else
{
if ([delegate respondsToSelector:@selector(customAlertViewWasCancelled:)])
[delegate customAlertViewWasCancelled:self];
}
}
#pragma mark -
- (void)viewDidUnload
{
[super viewDidUnload];
self.alertView = nil;
self.backgroundView = nil;
self.inputField = nil;
}
- (void)dealloc
{
[alertView release];
[backgroundView release];
[inputField release];
[super dealloc];
}
#pragma mark -
#pragma mark Private Methods
- (void)alertDidFadeOut
{
[self.view removeFromSuperview];
[self autorelease];
}
#pragma mark -
#pragma mark CAAnimation Delegate Methods
- (void)animationDidStop:(CAAnimation *)theAnimation finished:(BOOL)flag
{
[self.inputField becomeFirstResponder];
}
#pragma mark -
#pragma mark Text Field Delegate Methods
- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
[self dismiss:self];
return YES;
}
@end
Alors, qu'est-ce qu'on fait ici? Tout d'abord, nous commençons par l'importation de la catégorie avec nos animations affichage des alertes et aussi QuartzCore.h ce qui nous donne accès à tous les types de données utilisés dans les Core Animation.
#import "CustomAlertView.h"
#import "UIView-AlertAnimations.h"
#import <QuartzCore/QuartzCore.h>Ensuite, nous déclarons une extension de classe avec une méthode unique. En mettant cette méthode ici, nous pouvons l'utiliser n'importe où dans notre classe sans avoir les avertissements du compilateur et pourtant nous ne le diffuse pas l'existence de cette méthode pour le monde. C'est, essentiellement, une méthode privée. Dans un langage dynamique comme Objective-C, il n'existe aucune méthode vraiment privé, mais puisque la méthode n'est pas déclarée dans le fichier en-tête, c'est notre façon de dire «ceci est la nôtre, ne pas toucher». Cette méthode, que vous verrez dans un instant, sera appelé après l'alerte a été rejetée pour le retirer de son SuperView. Nous ne voulons pas de l'enlever qu'après l'animation fade-out est terminé, c'est pourquoi nous avons déclaré une méthode distincte.
@interface CustomAlertView()
- (void)alertDidFadeOut;
@endAprès nous synthétisons nos propriétés, la première méthode que nous écrivons est spectacle. C'est la méthode qui est appelée à bien ... afficher l'alerte. J'ai adapté le nom de méthode utilisée dans UIAlertView et fait également un IBAction afin qu'il puisse être déclenchée directement à l'intérieur d'un fichier nib.
Le plus étrange partie de cette méthode est qu'elle conserve réellement soi-même. C'est quelque chose que vous êtes généralement ne vont pas vouloir le faire. Depuis que nous avons mis en œuvre notre vision d'alerte comme un contrôleur de vue au lieu d'une sous-classe UIView comme UIAlertView, nous avons besoin de tricher un peu, car un contrôleur de vue n'est pas retenu par quelque chose par la vertu de son point de vue être dans la hiérarchie d'affichage. Ce n'est pas faux - que nous allons garder notre bookend avec un communiqué (ainsi, en réalité, une autorelease) donc pas de fuite de mémoire, mais il est inhabituel et non quelque chose que vous allez avoir à utiliser dans des endroits très nombreuses . Quand vous retenez l'auto, vous avez besoin de prendre un long regard dur à votre code et vous assurer d'avoir une sacrée bonne raison pour le faire. Dans ce cas, nous le faisons.
Après avoir retenu, on récupère une référence à la fenêtre par l'intermédiaire du délégué de l'application et d'ajouter notre point de vue à la fenêtre, correspondant de son cadre. Ensuite, nous appelons les deux méthodes d'animation nous avons créé précédemment à s'estomper dans l'image avec le dégradé circulaire et "pop" dans la vue d'alerte:
- (IBAction)show
{
// Retaining self is odd, but we do it to make this "fire and forget"
[self retain];
// We need to add it to the window, which we can get from the delegate
id appDelegate = [[UIApplication sharedApplication] delegate];
UIWindow *window = [appDelegate window];
[window addSubview:self.view];
// Make sure the alert covers the whole window
self.view.frame = window.frame;
self.view.center = window.center;
// "Pop in" animation for alert
[alertView doPopInAnimationWithDelegate:self];
// "Fade in" animation for background
[backgroundView doFadeInAnimation];
}La méthode la prochaine action que nous écrivons est celle qui est appelée par les deux boutons sur le qui-vive. Peu importe quel bouton a été poussé, nous voulons que le champ de texte à démissionner statut de Première répondeur afin que le clavier disparaît, et nous voulons que l'alerte à s'estomper. Nous allons utiliser des animations implicitement cette fois et ensuite utiliser performSelector withObject: afterDelay: pour déclencher notre méthode privée qui va enlever la vue de son SuperView. Après cela, nous vérifions valeur de la balise de l'expéditeur pour voir quelle méthode déléguée à notifier.
- (IBAction)dismiss:(id)sender
{
[inputField resignFirstResponder];
[UIView beginAnimations:nil context:nil];
self.view.alpha = 0.0;
[UIView commitAnimations];
[self performSelector:@selector(alertDidFadeOut) withObject:nil afterDelay:0.5];
if (sender == self || [sender tag] == CustomAlertViewButtonTagOk)
[delegate CustomAlertView:self wasDismissedWithValue:inputField.text];
else
{
if ([delegate respondsToSelector:@selector(customAlertViewWasCancelled:)])
[delegate customAlertViewWasCancelled:self];
}
}Le viewDidUnload et dealloc sont standard tourbière, donc il ne sert à rien d'en discuter. La méthode suivante après celles-ci est notre "privée" méthode. Il ne fait que supprimer l'affichage maintenant invisible alerte de la hiérarchie d'affichage et de autoreleases auto pour que le contrôleur de vue sera publié à la fin de l'itération de la boucle d'exécution actuel. Nous ne voulons pas d'utiliser la libération parce que nous ne voulez vraiment pas l'objet disparaît alors un de ses méthode s'exécute:
- (void)alertDidFadeOut
{
[self.view removeFromSuperview];
[self autorelease];
}Auparavant, lorsque nous avons créé le "pop" l'animation, nous avons spécifié l'auto en tant que délégué. La méthode suivante nous mettons en œuvre est appelée lorsque le "pop" animation complète en vertu de ce fait. Tout ce que nous faisons ici est de s'assurer que le clavier est montré à l'utilisateur et associée à notre champ de texte. Nous faisons tout cela simplement en faisant le champ de texte du premier intervenant:
- (void)animationDidStop:(CAAnimation *)theAnimation finished:(BOOL)flag
{
[self.inputField becomeFirstResponder];
}Enfin, nous mettons en œuvre l'une des méthodes texte du délégué sur le terrain de sorte que lorsque l'utilisateur appuie sur la touche de retour sur le clavier, il rejette le dialogue.
- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
[self dismiss:self];
return YES;
}À ce stade, nous avons terminé. Nous pouvons maintenant utiliser cette vue alerte personnalisée exactement de la même façon que nous utilisons UIAlertView:
CustomAlertView *alert = [[CustomAlertView alloc]init];
alert.delegate = self;
[alert show];
[alert release];Comme je l'ai indiqué précédemment, vous pouvez utiliser cette même technique pour présenter tout ce que vous pouvez construire dans Interface Builder, et le résultat sera un objet hautement réutilisables alerte.
samedi 10 mars 2012
OpenGL ES à partir du sol jusqu'à 9 (entracte): Quaternions
Avant que nous puissions entrer dans le prochain post dans le OpenGL ES à partir du sol pour, Qui couvre animation de squelette, nous avons à faire un petit détour et de parler d'un nouveau type de données que nous allons utiliser, le Quaternion. Nous allons utiliser les quaternions pour stocker la rotation sur les trois axes d'un seul os, ou, en d'autres termes, pour stocker la direction de l'os est pointé. Dans l'animation du squelette, comme vous le verrez dans le prochain épisode, les sommets dans le modèle sont attachés à un ou plusieurs os et déplacer les os ils sont attachés à se déplacer. En utilisant les quaternions, par opposition à stocker les trois Angles d'Euler des trois GLfloats ou un seul Vector3D a deux avantages:
Ne soyez pas effrayés encore décollé. Si vous n'êtes pas profondément versé dans les mathématiques avancées, les quaternions peut faire votre malheur cerveau. Mais, comme je l'ai déjà dit, vous n'avez pas vraiment à Grok Quaternions à les utiliser. Le concept est très semblable à quelque chose que vous avez déjà vu. Si vous vous souvenez, des transformations de matrice impliquent l'utilisation d'une matrice 4x4 pour appliquer les transformations dans un espace tridimensionnel. Quand vient le temps d'utiliser les données transformées, nous simplement ignorer la quatrième valeur. Pensez à la quatrième valeur en un quaternion comme une valeur de travail, il est juste là pour fournir un espace pour les calculs. Commandants de maths, s'il vous plaît ne criez pas à moi - cette simplification permettra de simples mortels vivre en paix avec les quaternions.
Quaternions ont été considérés comme plutôt révolutionnaire à l'époque de la découverte, mais leur apogée était un peu courte durée. Dans le milieu des années 1880, calcul vectoriel a commencé à supplanter la théorie des quaternions en mathématiques, car elle décrit les mêmes phénomènes en utilisant des concepts qui sont plus faciles à comprendre et à décrire.
Malgré le fait que les quaternions est sorti de complexes, les mathématiques théoriques, ils ont des applications pratiques. Une telle application pratique est la représentation des angles de rotation sur les trois axes. Parce que les quaternions représentent les coordonnées cartésiennes (ou trois axes) de rotation en utilisant quatre dimensions, la représentation n'est pas soumise à blocage de cardan, et vous pouvez convertir entre les quaternions et les matrices de rotation, ainsi qu'entre les quaternions et les angles d'Euler, sans perte de fidélité ^ 1. Cela les rend absolument parfait pour stocker des informations rotation autour d'un objet, comme dire ... un os particulier d'un squelette articulé? Au lieu de stocker l'angle sur trois axes, nous stockons un quaternion unique.
Quaternions peuvent être multipliés comme des matrices, et les valeurs stockées dans la rotation quaternions différentes peuvent être combinées en les multipliant. Le résultat d'une multiplication de quaternions est exactement la même que la multiplication de matrice avec deux matrices de rotation, et implique des calculs nettement moins à accomplir, ce qui signifie qu'en plus d'éviter blocage de cardan, nous réduisons le nombre de FLOPS nous effectuons à chaque fois grâce à notre boucle d'application. Non seulement il ya moins d'opérations dans la multiplication des quaternions de multiplication des matrices, mais puisque nous pouvons également représenter les trois axes en utilisant un quaternion unique, nous pouvons faire multiplications généralement quaternion moins multiplications matrice. Si nous devions stocker rotation dans un Vector3D ou de l'aide de trois GLfloats, nous ont souvent à faire trois multiplications matrice - une pour chaque axe. En conséquence, les quaternions stockage peut conduire à une amélioration substantielle des performances individuelles plus stocker les angles de rotation.
Eh bien, pouah! Si vous voulez vraiment comprendre ce qui se passe ici, il va exiger une compréhension de calcul matriciel, Théorème de la rotation d'EulerEt les concepts de eigenvalues and trace, Pour ne pas mentionner une compréhension approfondie de la façon dont les rotations sont représentés dans des matrices. Lorsque vous avez terminé votre doctorat en mathématiques, vous pouvez revenir et l'expliquer au reste de la USL. Vous pouvez trouver l'algorithme utilisé dans cette fonction énoncés dans le pseudocode Matrice FAQ.

Source: Wikipedia
Vous savez où il ya une rotule? Dans votre épaule. La clavicule et l'épine de l'omoplate forme un berceau pour la saillie en forme de boule au sommet de l'humérus. Eh bien, c'est très pratique. Tenez-vous devant un miroir, tenez votre am-dessus de votre tête, puis en gardant votre bras droit, le faire descendre jusqu'à ce qu'il soit à vos côtés. Votre main ne bouge pas en ligne droite, ça. Votre main se déplace sur un arc et se déplace plus vite que votre coude et votre épaule et les chances sont de votre main ne bouge pas à une vitesse constante. C'est le mouvement de base nous voulons simuler quand nous animent des angles de rotation.
SLERPs et NLERPs sont les deux approches les plus courantes. SLERPs sont plus précis et donner une meilleure simulation de la réalité, mais ils sont plus lents et plus intensive du processeur. NLERPs sont beaucoup plus rapides parce qu'ils sont essentiellement les mêmes d'interpolation linéaire, nous avons déjà utilisé, seulement normalisé après avoir fait l'interpolation, ce qui vous aurait été capable de deviner le nom de «interpolation linéaire normalisé».
Utilisez SLERPs quand réalistes animation regarder est plus importante que la vitesse, NLERPs autrement. Les deux méthodes prennent exactement les mêmes paramètres, afin de commutation entre les deux ne devraient pas être une grosse affaire, de sorte que vous pouvez expérimenter pour voir si SLERPs valent le coût de traitement supplémentaire.
Voici la simple mise en œuvre NLERP:
Maintenant, la mise en œuvre SLERP est un peu plus complexe et nécessite la capacité à calculer un produit scalaire sur un quaternion, qui se fait exactement le même que le calcul du produit scalaire d'un vecteur:
1 Parce que nos programmes utilisent des variables à virgule flottante, nous allons réellement voir de légers changements dans les données en raison du phénomène connu sous le nom perte de signification. Ce n'est pas parce que nous sommes en utilisant les quaternions. C'est parce que nous utilisons des variables à virgule flottante.
- Les quaternions sont pas soumis à blocage de cardan. Angles d'Euler sont donc quaternions va permettre à nos squelettes 3D pour avoir gamme complète de mouvement.
- Combinant de multiples rotations en utilisant les quaternions nécessite des calculs nettement moins que de faire pivoter la matrice des transformations pour chaque angle d'Euler
Discovery
Mathématiquement parlant, les quaternions sont une extension des nombres complexes et ont été découverts par Sir William Rowan Hamilton en 1843. Techniquement parlant, les quaternions forment un «quatre dimensions l'algèbre de division normée au cours de la nombres réels». Zoiks! Plus simplement, un quaternion utilise une quatrième dimension pour permettre le calcul de triples pour les trois coordonnées cartésiennes en fournissant chaque axe avec trois autres valeurs. Okay, peut-être que ce n'était pas si simple que cela, était-ce?Ne soyez pas effrayés encore décollé. Si vous n'êtes pas profondément versé dans les mathématiques avancées, les quaternions peut faire votre malheur cerveau. Mais, comme je l'ai déjà dit, vous n'avez pas vraiment à Grok Quaternions à les utiliser. Le concept est très semblable à quelque chose que vous avez déjà vu. Si vous vous souvenez, des transformations de matrice impliquent l'utilisation d'une matrice 4x4 pour appliquer les transformations dans un espace tridimensionnel. Quand vient le temps d'utiliser les données transformées, nous simplement ignorer la quatrième valeur. Pensez à la quatrième valeur en un quaternion comme une valeur de travail, il est juste là pour fournir un espace pour les calculs. Commandants de maths, s'il vous plaît ne criez pas à moi - cette simplification permettra de simples mortels vivre en paix avec les quaternions.
Quaternions ont été considérés comme plutôt révolutionnaire à l'époque de la découverte, mais leur apogée était un peu courte durée. Dans le milieu des années 1880, calcul vectoriel a commencé à supplanter la théorie des quaternions en mathématiques, car elle décrit les mêmes phénomènes en utilisant des concepts qui sont plus faciles à comprendre et à décrire.
Not Quite Dead Yet!
Au 20e siècle, cependant, les quaternions retour en grâce. Comme nous l'avons discuté dans Partie 7, Il ya un phénomène appelé blocage de cardan qui peuvent survenir lorsque vous faites des transformations de rotation individuellement sur chaque axe, qui a pour effet indésirable d'arrêt de la rotation sur l'un des trois axes.Malgré le fait que les quaternions est sorti de complexes, les mathématiques théoriques, ils ont des applications pratiques. Une telle application pratique est la représentation des angles de rotation sur les trois axes. Parce que les quaternions représentent les coordonnées cartésiennes (ou trois axes) de rotation en utilisant quatre dimensions, la représentation n'est pas soumise à blocage de cardan, et vous pouvez convertir entre les quaternions et les matrices de rotation, ainsi qu'entre les quaternions et les angles d'Euler, sans perte de fidélité ^ 1. Cela les rend absolument parfait pour stocker des informations rotation autour d'un objet, comme dire ... un os particulier d'un squelette articulé? Au lieu de stocker l'angle sur trois axes, nous stockons un quaternion unique.
Quaternions peuvent être multipliés comme des matrices, et les valeurs stockées dans la rotation quaternions différentes peuvent être combinées en les multipliant. Le résultat d'une multiplication de quaternions est exactement la même que la multiplication de matrice avec deux matrices de rotation, et implique des calculs nettement moins à accomplir, ce qui signifie qu'en plus d'éviter blocage de cardan, nous réduisons le nombre de FLOPS nous effectuons à chaque fois grâce à notre boucle d'application. Non seulement il ya moins d'opérations dans la multiplication des quaternions de multiplication des matrices, mais puisque nous pouvons également représenter les trois axes en utilisant un quaternion unique, nous pouvons faire multiplications généralement quaternion moins multiplications matrice. Si nous devions stocker rotation dans un Vector3D ou de l'aide de trois GLfloats, nous ont souvent à faire trois multiplications matrice - une pour chaque axe. En conséquence, les quaternions stockage peut conduire à une amélioration substantielle des performances individuelles plus stocker les angles de rotation.
La structure Quaternion
Du point de vue des données, un quaternion est rien de plus qu'un Vector3D avec un supplément de GLfloat, Généralement dénommé w. Donc, pour nos fins, un quaternion ressemblera à ceci:typedef struct {
GLfloat x;
GLfloat y;
GLfloat z;
GLfloat w;
} Quaternion3D;Normaliser un quaternion
Assez facile. Maintenant, tout comme Vector3Ds, puisque les quaternions représentent une direction dans l'espace, les valeurs de distance réelle n'ont pas d'importance, et il est fréquent de les normaliser à 1,0 avant et / ou après avoir fait d'autres calculs. Nous pouvons accomplir cela comme ceci:static inline void Quaternion3DNormalize(Quaternion3D *quaternion)
{
GLfloat magnitude;
magnitude = sqrtf((quaternion->x * quaternion->x) +
(quaternion->y * quaternion->y) +
(quaternion->z * quaternion->z) +
(quaternion->w * quaternion->w));
quaternion->x /= magnitude;
quaternion->y /= magnitude;
quaternion->z /= magnitude;
quaternion->w /= magnitude;
}Créer un quaternion à partir d'une matrice de rotation
Quaternions ne pas nous faire de bon si nous n'avons pas aucun moyen de convertir les quaternions à et de notre autres objets utilisés pour représenter les angles de rotation. Regardons d'abord à créer un quaternion à partir d'une matrice de rotation. Voici ce que la fonction de faire cela ressemble:static inline Quaternion3D Quaternion3DMakeWithMatrix3D(Matrix3D matrix)
{
Quaternion3D quat;
GLfloat trace, s;
trace = matrix[0] + matrix[5] + matrix[10];
if (trace > 0.0f)
{
s = sqrtf(trace + 1.0f);
quat.w = s * 0.5f;
s = 0.5f / s;
quat.x = (matrix[9] - matrix[6]) * s;
quat.y = (matrix[2] - matrix[8]) * s;
quat.z = (matrix[4] - matrix[1]) * s;
}
else
{
NSInteger biggest;
enum {A,E,I};
if (matrix[0] > matrix[5])
if (matrix[10] > matrix[0])
biggest = I;
else
biggest = A;
else
if (matrix[10] > matrix[0])
biggest = I;
else
biggest = E;
switch (biggest)
{
case A:
s = sqrtf(matrix[0] - (matrix[5] + matrix[10]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.x = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[9] - matrix[6]) * s;
quat.y = (matrix[1] + matrix[4]) * s;
quat.z = (matrix[2] + matrix[8]) * s;
break;
}
s = sqrtf(matrix[10] - (matrix[0] + matrix[5]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.z = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[4] - matrix[1]) * s;
quat.x = (matrix[8] + matrix[2]) * s;
quat.y = (matrix[9] + matrix[6]) * s;
break;
}
s = sqrtf(matrix[5] - (matrix[10] + matrix[0]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.y = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[2] - matrix[8]) * s;
quat.z = (matrix[6] + matrix[9]) * s;
quat.x = (matrix[4] + matrix[1]) * s;
break;
}
break;
case E:
s = sqrtf(matrix[5] - (matrix[10] + matrix[0]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.y = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[2] - matrix[8]) * s;
quat.z = (matrix[6] + matrix[9]) * s;
quat.x = (matrix[4] + matrix[1]) * s;
break;
}
s = sqrtf(matrix[10] - (matrix[0] + matrix[5]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.z = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[4] - matrix[1]) * s;
quat.x = (matrix[8] + matrix[2]) * s;
quat.y = (matrix[9] + matrix[6]) * s;
break;
}
s = sqrtf(matrix[0] - (matrix[5] + matrix[10]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.x = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[9] - matrix[6]) * s;
quat.y = (matrix[1] + matrix[4]) * s;
quat.z = (matrix[2] + matrix[8]) * s;
break;
}
break;
case I:
s = sqrtf(matrix[10] - (matrix[0] + matrix[5]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.z = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[4] - matrix[1]) * s;
quat.x = (matrix[8] + matrix[2]) * s;
quat.y = (matrix[9] + matrix[6]) * s;
break;
}
s = sqrtf(matrix[0] - (matrix[5] + matrix[10]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.x = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[9] - matrix[6]) * s;
quat.y = (matrix[1] + matrix[4]) * s;
quat.z = (matrix[2] + matrix[8]) * s;
break;
}
s = sqrtf(matrix[5] - (matrix[10] + matrix[0]) + 1.0f);
if (s > QUATERNION_TRACE_ZERO_TOLERANCE)
{
quat.y = s * 0.5f;
s = 0.5f / s;
quat.w = (matrix[2] - matrix[8]) * s;
quat.z = (matrix[6] + matrix[9]) * s;
quat.x = (matrix[4] + matrix[1]) * s;
break;
}
break;
default:
break;
}
}
return quat;
}Eh bien, pouah! Si vous voulez vraiment comprendre ce qui se passe ici, il va exiger une compréhension de calcul matriciel, Théorème de la rotation d'EulerEt les concepts de eigenvalues and trace, Pour ne pas mentionner une compréhension approfondie de la façon dont les rotations sont représentés dans des matrices. Lorsque vous avez terminé votre doctorat en mathématiques, vous pouvez revenir et l'expliquer au reste de la USL. Vous pouvez trouver l'algorithme utilisé dans cette fonction énoncés dans le pseudocode Matrice FAQ.
Création d'une matrice de rotation à partir d'un quaternion
Dans l'autre sens est en réalité un peu plus facile. Encore une fois, l'algorithme de base provient de la Matrice FAQ, Si je devais le passer à la ligne-major de la commande:static inline void Matrix3DSetUsingQuaternion3D(Matrix3D matrix, Quaternion3D quat)
{
matrix[0] = (1.0f - (2.0f * ((quat.y * quat.y) + (quat.z * quat.z))));
matrix[1] = (2.0f * ((quat.x * quat.y) - (quat.z * quat.w)));
matrix[2] = (2.0f * ((quat.x * quat.z) + (quat.y * quat.w)));
matrix[3] = 0.0f;
matrix[4] = (2.0f * ((quat.x * quat.y) + (quat.z * quat.w)));
matrix[5] = (1.0f - (2.0f * ((quat.x * quat.x) + (quat.z * quat.z))));
matrix[6] = (2.0f * ((quat.y * quat.z) - (quat.x * quat.w)));
matrix[7] = 0.0f;
matrix[8] = (2.0f * ((quat.x * quat.z) - (quat.y * quat.w)));
matrix[9] = (2.0f * ((quat.y * quat.z) + (quat.x * quat.w)));
matrix[10] = (1.0f - (2.0f * ((quat.x * quat.x) + (quat.y * quat.y))));
matrix[11] = 0.0f;
matrix[12] = 0.0f;
matrix[13] = 0.0f;
matrix[14] = 0.0f;
matrix[15] = 1.0f;
}Conversion d'un angle et l'axe de rotation en un quaternion
Another conversion nous pouvons faire avec les quaternions est de faire tourner sur un axe arbitraire représenté par une Vector3D. Ceci peut être extrêmement utile dans l'animation du squelette et il est assez difficile à mettre en œuvre l'aide de matrices. Pour créer un quaternion basée sur un angle et l'axe de rotation, nous faisons ceci:static inline Quaternion3D Quaternion3DMakeWithAxisAndAngle(Vector3D axis, GLfloat angle)
{
Quaternion3D quat;
GLfloat sinAngle;
angle *= 0.5f;
Vector3DNormalize(&axis);
sinAngle = sinf(angle);
quat.x = (axis.x * sinAngle);
quat.y = (axis.y * sinAngle);
quat.z = (axis.z * sinAngle);
quat.w = cos(angle);
return quat;
}Extraction d'un angle et l'axe de rotation à partir d'un quaternion
Nous pouvons également aller dans l'autre. Nous pouvons prendre la rotation représentée dans un quaternion et extraire l'angle de rotation et de degrés d'elle, Comme ceci:static inline void Quaternion3DExtractAxisAndAngle(Quaternion3D quat, Vector3D *axis, GLfloat *angle)
{
GLfloat s;
Quaternion3DNormalize(&quat);
s = sqrtf(1.0f - (quat.w * quat.w));
if (fabs(s) < 0.0005f) s = 1.0f;
if (axis != NULL)
{
axis->x = (quat.x / s);
axis->y = (quat.y / s);
axis->z = (quat.z / s);
}
if (angle != NULL)
*angle = (acosf(quat.w) * 2.0f);
}Multiplication de quaternions
Pour combiner les rotations à partir de deux différents Quaternion3Ds, nous avons juste besoin de les multiplier ensemble. Here we go:static inline void Quaternion3DMultiply(Quaternion3D *quat1, Quaternion3D *quat2)
{
Vector3D v1, v2, cp;
float angle;
v1.x = quat1->x;
v1.y = quat1->y;
v1.z = quat1->z;
v2.x = quat2->x;
v2.y = quat2->y;
v2.z = quat2->z;
angle = (quat1->w * quat2->w) - Vector3DDotProduct(v1, v2);
cp = Vector3DCrossProduct(v1, v2);
v1.x *= quat2->w;
v1.y *= quat2->w;
v1.z *= quat2->w;
v2.x *= quat1->w;
v2.y *= quat1->w;
v2.z *= quat1->w;
quat1->x = v1.x + v2.x + cp.x;
quat1->y = v1.y + v2.y + cp.y;
quat1->z = v1.z + v2.z + cp.z;
quat1->w = angle;
}Inverser un quaternion
Nous pouvons faire une spacial radier de tout quaternion en les conjuguant. Conjuguer un quaternion signifie simplement que nous inverser le cours des trois composantes du quaternion qui représente le vecteur (x, y et z). Dans cette application, nous avons également normaliser le quaternion dans le cadre du calcul plutôt que comme une étape distincte:static inline void Quaternion3DInvert(Quaternion3D *quat)
{
GLfloat length = 1.0f / ((quat->x * quat->x) +
(quat->y * quat->y) +
(quat->z * quat->z) +
(quat->w * quat->w));
quat->x *= -length;
quat->y *= -length;
quat->z *= -length;
quat->w *= length;
}Créer un quaternion d'Angles d'Euler
J'ai mis en garde contre les angles d'Euler pour la rotation, mais il ya des moments où vous aurez à convertir des angles d'Euler en un quaternion, Comme lors de l'acceptation d'entrée d'un utilisateur. Pour ce faire, nous devons créer Vector3Ds pour représenter chacun des axes d'Euler, de créer des quaternions en utilisant les vecteurs et le passé dans les valeurs, puis utilisez la multiplication des quaternions de combiner les quaternions résultant.static inline Quaternion3D Quaternion3DMakeWithEulerAngles(GLfloat x, GLfloat y, GLfloat z)
{
Vector3D vx = Vector3DMake(1.f, 0.f, 0.f);
Vector3D vy = Vector3DMake(0.f, 1.f, 0.f);
Vector3D vz = Vector3DMake(0.f, 0.f, 1.f);
Quaternion3D qx = Quaternion3DMakeWithAxisAndAngle(vx, x);
Quaternion3D qy = Quaternion3DMakeWithAxisAndAngle(vy, y);
Quaternion3D qz = Quaternion3DMakeWithAxisAndAngle(vz, z);
Quaternion3DMultiply(&qx, &qy );
Quaternion3DMultiply(&qx, &qz );
return qx;
}SLERPs et NLERPS
Enfin, la pièce de résistance: SLERPs et NLERPS. SLERP est un raccourci pour Interpolation linéaire sphérique and NLERPS for normalisée interpolation linéaire. Rappelez-vous comment nous avons fait algébriques interpolation linéaire en Partie 9a pour calculer l'emplacement correct pour chaque vertex basé sur combien de temps s'était écoulé? Eh bien, ces mêmes calculs ne vont pas nécessairement de nous donner les résultats que nous voulons quand interpolation quaternions. Imaginez une rotule:
Vous savez où il ya une rotule? Dans votre épaule. La clavicule et l'épine de l'omoplate forme un berceau pour la saillie en forme de boule au sommet de l'humérus. Eh bien, c'est très pratique. Tenez-vous devant un miroir, tenez votre am-dessus de votre tête, puis en gardant votre bras droit, le faire descendre jusqu'à ce qu'il soit à vos côtés. Votre main ne bouge pas en ligne droite, ça. Votre main se déplace sur un arc et se déplace plus vite que votre coude et votre épaule et les chances sont de votre main ne bouge pas à une vitesse constante. C'est le mouvement de base nous voulons simuler quand nous animent des angles de rotation.
SLERPs et NLERPs sont les deux approches les plus courantes. SLERPs sont plus précis et donner une meilleure simulation de la réalité, mais ils sont plus lents et plus intensive du processeur. NLERPs sont beaucoup plus rapides parce qu'ils sont essentiellement les mêmes d'interpolation linéaire, nous avons déjà utilisé, seulement normalisé après avoir fait l'interpolation, ce qui vous aurait été capable de deviner le nom de «interpolation linéaire normalisé».
Utilisez SLERPs quand réalistes animation regarder est plus importante que la vitesse, NLERPs autrement. Les deux méthodes prennent exactement les mêmes paramètres, afin de commutation entre les deux ne devraient pas être une grosse affaire, de sorte que vous pouvez expérimenter pour voir si SLERPs valent le coût de traitement supplémentaire.
Voici la simple mise en œuvre NLERP:
static inline Quaternion3D Quaternion3DMakeWithNLERP(Quaternion3D *start, Quaternion3D *finish, GLclampf progress)
{
Quaternion3D ret;
GLfloat inverseProgress = 1.0f - progress;
ret.x = (start->x * inverseProgress) + (finish->x * progress);
ret.y = (start->y * inverseProgress) + (finish->y * progress);
ret.z = (start->z * inverseProgress) + (finish->z * progress);
ret.w = (start->w * inverseProgress) + (finish->w * progress);
Quaternion3DNormalize(&ret);
return ret;
}Maintenant, la mise en œuvre SLERP est un peu plus complexe et nécessite la capacité à calculer un produit scalaire sur un quaternion, qui se fait exactement le même que le calcul du produit scalaire d'un vecteur:
static inline Quaternion3D Quaternion3DMakeWithSLERP(Quaternion3D *start, Quaternion3D *finish, GLclampf progress)
{
GLfloat startWeight, finishWeight, difference;
Quaternion3D ret;
difference = ((start->x * finish->x) + (start->y * finish->y) + (start->z * finish->z) + (start->w * finish->w));
if ((1.f - fabs(difference)) > .01f)
{
GLfloat theta, oneOverSinTheta;
theta = acosf(fabsf(difference));
oneOverSinTheta = (1.f / sinf(theta));
startWeight = (sinf(theta * (1.f - progress)) * oneOverSinTheta);
finishWeight = (sinf(theta * progress) * oneOverSinTheta);
if (difference < 0.f)
startWeight = -startWeight;
} else
{
startWeight = (1.f - progress);
finishWeight = progress;
}
ret.x = (start->x * startWeight) + (finish->x * finishWeight);
ret.y = (start->y * startWeight) + (finish->y * finishWeight);
ret.z = (start->z * startWeight) + (finish->z * finishWeight);
ret.w = (start->w * startWeight) + (finish->w * finishWeight);
Quaternion3DNormalize(&ret);
return ret;
}
Finish Line
Bon, maintenant que nous sommes armés et dangereux et prêt à faire une animation squelettique. Je vais vous répondre revenir ici la prochaine fois pour elle. J'ai mis à jour le Xcode modèle de projet avec ces nouvelles fonctions et des types de données.1 Parce que nos programmes utilisent des variables à virgule flottante, nous allons réellement voir de légers changements dans les données en raison du phénomène connu sous le nom perte de signification. Ce n'est pas parce que nous sommes en utilisant les quaternions. C'est parce que nous utilisons des variables à virgule flottante.
OpenGL ES à partir de zéro: Table des matières
Cette annonce va agir comme une table des matières à mon OpenGL From the Ground Up série de tutoriel. Comme je ajouter de nouvelles publications, je les ajouterai ici:
- Concepts de base. Lire aussi Alphabet Soup
- Un regard simple dessin
- Fenêtres en perspective
- Let There Be Light. Ce chapitre est complété par une version alternative de le code final
- Vivre dans un monde matérialiste
- Textures et Texture Mapping
- Transformations et matrices
- Entrelacement par vertex données
- Principes d'animation et Animation Keyframe then Quaternions
- OpenGL ES Modèle pour Xcode
- NeHe OpenGL Leçon 02 Porté sur iPhone
- NeHe OpenGL Leçon 03 Porté sur iPhone
- NeHe OpenGL Leçon 04 Porté sur iPhone
- NeHe OpenGL Leçon 05 Porté sur iPhone
- Préparatifs NeHe OpenGL Leçon 06
- NeHe OpenGL Leçon 06 Porté sur iPhone (sorte de)
- Sphères de procédure dans OpenGL ES
- Wavin 'dans la brise
- Un générateur de particules OpenGL ES
- Une OpenGL ES Wavefront OBJ Loader fichier
- Vitesse avec une prise
- Faire OpenGL ES Screenshots
- Le code source pour le gulLookAt manquants () la fonction
- Le code source pour le gluPerspective manquants () la fonction
Cellules Voir tableau Redux
Il ya assez longtemps, j'ai posté au sujet Méthode recommandée par Apple de faire usage des cellules de tableau dans Interface Builder. Le code de ce poste a été disponible pendant 9 mois et aujourd'hui, pour la première fois, quelqu'un m'a fait remarquer que le projet ci-jointe ne pas réutiliser les cellules dequeued parce que j'ai oublié de taper l'identifiant de la cellule dans Interface Builder.
Quelle est la faiblesse de l'approche recommandée Apple. C'est un véritable talon d'Achille. C'est vraiment, vraiment facile d'oublier cette étape, et le code fonctionne parfaitement bien si vous ne l'oubliez, vous êtes juste de manger la mémoire et les performances deviennent plus pauvres que vous devriez. Sauf si vous le profil de vos applications ou de test avec des ensembles de données très volumineux, vous pourriez très bien expédier votre app de ce genre et même pas s'en rendre compte. Vous ne voulez jamais à vos clients de découvrir ces choses avant vous.
Maintenant, je ne savais même pas que j'avais fait cette erreur jusqu'à aujourd'hui, mais j'ai su que c'était un problème potentiel pour un certain temps, ce qui explique pourquoi, dans mon contrat de travail, j'ai commencé à utiliser une version modifiée du technique. Mon erreur précédemment donne-moi maintenant une bonne excuse pour après cette modification.
Surtout, c'est la même technique que j'ai discuté avant, seulement je commence par définir une constante pour l'identifiant. En fait, j'ai créer un fichier en-tête dans mes projets Xcode ConstantsAndMacros.h dans mon projet, qui je ajouter à mon fichier d'entête pré-compilés. Cela signifie que toutes les constantes et les macros j'ai mis dans ConstantsAndMacros.h sera disponible pour tous mes fichiers de code source dans mon projet sans avoir à les importer manuellement. Pour un projet simple, ce fichier pourrait ressembler à ceci:
Une fois que j'ai ce fichier, je l'ajouter au fichier. Pch dans le Autres sources folder:
Maintenant que constante est disponible vaste projet ^ 2. Ensuite, dans mon sous-classe UITableViewCell, je substituer la méthode reuseIdentifier et ajouter une méthode de classe avec le même nom, comme ceci:
En faisant cela, le système va ignorer tout identifiant j'ai mis dans Interface Builder, ou tout autre valeur que j'ai mis dans le code en utilisant les setBundleIdentifier: méthode mutateur. Pour les instances de cette classe particulière, il sera toujours utiliser le même identifiant. En créant la méthode de classe, j'ai accès à cet identifiant, même si je ne dispose pas encore d'une instance de la classe.
Pour toutes les autres étapes de l'aide personnalisée de cellules de tableau chargé à partir d'une plume, le processus est le même que le didacticiel précédent et il fonctionne très bien. Voici un exemple de tableView: cellForRowAtIndexPath: méthode utilisant cette technique:
Notez le NSLog () déclaration? Je peux ouvrir ma cellule de tableau dans Interface Builder et mettre tout identifiant que je veux, ou un ensemble pas d'identifiant à tous, et il sera toujours ré-utiliser des cellules de tableau. Exécuter l'application, et peu importe ce que vous faites dans Interface Builder, vous ne verrez une poignée de lignes chargées à partir du fichier nib. Après le chargement initial, il va tout simplement continuer de réutiliser les instances même cellule à plusieurs reprises. Ce qui est loin moins fragiles que d'avoir à s'assurer que l'identifiant de l'IB et celui de votre match de code.
Il pourrait y avoir des moments où vous ne voulez pas l'installer comme ça - quand vous avez besoin d'avoir plusieurs identifiants pour la classe d'affichage d'une même table, mais ces situations seront extrêmement rares. Dans la plupart des situations pratiques où vous êtes sous-classes UITableViewCell, vous voulez un identifiant unique pour toutes les instances de cette classe. Ce que vous ne voulez normalement est la fragilité d'avoir à vous assurer de la valeur dans votre code correspond à celle de IB exactement, surtout étant donné qu'il n'y a aucun signe évident que vous avez oublié de le faire.
1 Cette macro journaux juste le nom de la méthode de la fonction qu'il est placé dans lorsque cette méthode est appelée. Je l'utilise chaque fois que je bouchonner une méthode pour s'assurer IBAction mes connexions sont toutes faites correctement, d'où le nom, mais c'est utile pour le débogage ainsi.
2 Si vous utilisez uniquement une cellule de tableau dans un seul contrôleur, vous n'avez probablement pas le voulez ici. En général, j'essaie de créer des cellules de tableau pour être suffisamment générique pour être utilisé dans plus d'un contrôleur. Parfois, ce n'est pas possible ou pratique, et dans ces cas, # define votre identifiant dans l'en-tête du contrôleur de table tenu à la place.
Vous pouvez trouver un projet de mise en œuvre de l'échantillon ici/
Quelle est la faiblesse de l'approche recommandée Apple. C'est un véritable talon d'Achille. C'est vraiment, vraiment facile d'oublier cette étape, et le code fonctionne parfaitement bien si vous ne l'oubliez, vous êtes juste de manger la mémoire et les performances deviennent plus pauvres que vous devriez. Sauf si vous le profil de vos applications ou de test avec des ensembles de données très volumineux, vous pourriez très bien expédier votre app de ce genre et même pas s'en rendre compte. Vous ne voulez jamais à vos clients de découvrir ces choses avant vous.
Maintenant, je ne savais même pas que j'avais fait cette erreur jusqu'à aujourd'hui, mais j'ai su que c'était un problème potentiel pour un certain temps, ce qui explique pourquoi, dans mon contrat de travail, j'ai commencé à utiliser une version modifiée du technique. Mon erreur précédemment donne-moi maintenant une bonne excuse pour après cette modification.
Surtout, c'est la même technique que j'ai discuté avant, seulement je commence par définir une constante pour l'identifiant. En fait, j'ai créer un fichier en-tête dans mes projets Xcode ConstantsAndMacros.h dans mon projet, qui je ajouter à mon fichier d'entête pré-compilés. Cela signifie que toutes les constantes et les macros j'ai mis dans ConstantsAndMacros.h sera disponible pour tous mes fichiers de code source dans mon projet sans avoir à les importer manuellement. Pour un projet simple, ce fichier pourrait ressembler à ceci:
#define TABLE_CELL_IDENTIFIER @"Table Cell Identifier"
#define NSStubLog() NSLog(@"%s", __PRETTY_FUNCTION__)^1
Une fois que j'ai ce fichier, je l'ajouter au fichier. Pch dans le Autres sources folder:
#ifdef __OBJC__
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import "ConstantsAndMacros.h"
#endif
Maintenant que constante est disponible vaste projet ^ 2. Ensuite, dans mon sous-classe UITableViewCell, je substituer la méthode reuseIdentifier et ajouter une méthode de classe avec le même nom, comme ceci:
+ (NSString *)reuseIdentifier
{
return (NSString *)TABLE_CELL_IDENTIFIER;
}
- (NSString *)reuseIdentifier
{
return [[self class] reuseIdentifier];
}En faisant cela, le système va ignorer tout identifiant j'ai mis dans Interface Builder, ou tout autre valeur que j'ai mis dans le code en utilisant les setBundleIdentifier: méthode mutateur. Pour les instances de cette classe particulière, il sera toujours utiliser le même identifiant. En créant la méthode de classe, j'ai accès à cet identifiant, même si je ne dispose pas encore d'une instance de la classe.
Pour toutes les autres étapes de l'aide personnalisée de cellules de tableau chargé à partir d'une plume, le processus est le même que le didacticiel précédent et il fonctionne très bien. Voici un exemple de tableView: cellForRowAtIndexPath: méthode utilisant cette technique:
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
TestCell *cell = (TestCell *)[tableView dequeueReusableCellWithIdentifier:[TestCell reuseIdentifier]];
if (cell == nil)
{
NSLog(@"Loading new cell");
[[NSBundle mainBundle] loadNibNamed:@"TestCell" owner:self options:nil];
cell = loadCell;
self.loadCell = nil;
}
cell.cellLabel.text = [NSString stringWithFormat:@"Row %d", [indexPath row]];
return cell;
}Notez le NSLog () déclaration? Je peux ouvrir ma cellule de tableau dans Interface Builder et mettre tout identifiant que je veux, ou un ensemble pas d'identifiant à tous, et il sera toujours ré-utiliser des cellules de tableau. Exécuter l'application, et peu importe ce que vous faites dans Interface Builder, vous ne verrez une poignée de lignes chargées à partir du fichier nib. Après le chargement initial, il va tout simplement continuer de réutiliser les instances même cellule à plusieurs reprises. Ce qui est loin moins fragiles que d'avoir à s'assurer que l'identifiant de l'IB et celui de votre match de code.
Il pourrait y avoir des moments où vous ne voulez pas l'installer comme ça - quand vous avez besoin d'avoir plusieurs identifiants pour la classe d'affichage d'une même table, mais ces situations seront extrêmement rares. Dans la plupart des situations pratiques où vous êtes sous-classes UITableViewCell, vous voulez un identifiant unique pour toutes les instances de cette classe. Ce que vous ne voulez normalement est la fragilité d'avoir à vous assurer de la valeur dans votre code correspond à celle de IB exactement, surtout étant donné qu'il n'y a aucun signe évident que vous avez oublié de le faire.
1 Cette macro journaux juste le nom de la méthode de la fonction qu'il est placé dans lorsque cette méthode est appelée. Je l'utilise chaque fois que je bouchonner une méthode pour s'assurer IBAction mes connexions sont toutes faites correctement, d'où le nom, mais c'est utile pour le débogage ainsi.
2 Si vous utilisez uniquement une cellule de tableau dans un seul contrôleur, vous n'avez probablement pas le voulez ici. En général, j'essaie de créer des cellules de tableau pour être suffisamment générique pour être utilisé dans plus d'un contrôleur. Parfois, ce n'est pas possible ou pratique, et dans ces cas, # define votre identifiant dans l'en-tête du contrôleur de table tenu à la place.
Vous pouvez trouver un projet de mise en œuvre de l'échantillon ici/
Libellés :
Interface Builder,
tutoriels,
UITableView,
Vues tableau
samedi 18 février 2012
Qu'est-ce, apprends-moi?
Oui, croyez-le ou non, il semble que je vais enseigner.
J'ai accepté d'être l'instructeur pour un jour de trois Boot Camp Atelier iPhone NYC qui fonctionne à partir d'août 14-16. Les prochains ateliers (à la fois à New York et autres lieux) sont une possibilité si je n'ai pas inciter à une émeute ou faire un travail vraiment horrible d'enseignement celui-ci.
Je suis en fait très excitée sur cette opération. Le programme Boot Camp iPhone est un excellent programme et je suis impatient d'être une partie de celui-ci. L'encre est encore fraîche sur la face (je ne suis même pas mentionnés en tant qu'instructeur sur leur page web encore), donc je n'ai pas beaucoup de détails en ce moment, mais je peux vous dire que cet atelier est particulièrement destiné aux nouveaux iPhone les développeurs qui ont quelques connaissances en programmation de base (ou, essentiellement, les mêmes personnes que notre livre est destiné aux). Donc, si vous vivez dans ou près de la région métropolitaine de New York et êtes intéressé à devenir un développeur iPhone, je serais ravi de vous avoir dans mon atelier.
Si tout se passe bien, je suis l'espoir de les convaincre d'offrir un atelier plus avancé ou peut-être même un atelier d'OpenGL / Gaming dans le futur. Faites moi savoir si vous êtes intéressé à l'autre de ces sujets et, si oui, où vous habitez.
A propos de la seule autre chose que je sais à ce stade est que je serai peaufiner le programme qui est sur leur site un peu mettre à jour pour 3.0 et pour correspondre à mon style d'enseignement. Autre que cela, les détails seront à venir une fois que je les connais.
J'ai accepté d'être l'instructeur pour un jour de trois Boot Camp Atelier iPhone NYC qui fonctionne à partir d'août 14-16. Les prochains ateliers (à la fois à New York et autres lieux) sont une possibilité si je n'ai pas inciter à une émeute ou faire un travail vraiment horrible d'enseignement celui-ci.
Je suis en fait très excitée sur cette opération. Le programme Boot Camp iPhone est un excellent programme et je suis impatient d'être une partie de celui-ci. L'encre est encore fraîche sur la face (je ne suis même pas mentionnés en tant qu'instructeur sur leur page web encore), donc je n'ai pas beaucoup de détails en ce moment, mais je peux vous dire que cet atelier est particulièrement destiné aux nouveaux iPhone les développeurs qui ont quelques connaissances en programmation de base (ou, essentiellement, les mêmes personnes que notre livre est destiné aux). Donc, si vous vivez dans ou près de la région métropolitaine de New York et êtes intéressé à devenir un développeur iPhone, je serais ravi de vous avoir dans mon atelier.
Si tout se passe bien, je suis l'espoir de les convaincre d'offrir un atelier plus avancé ou peut-être même un atelier d'OpenGL / Gaming dans le futur. Faites moi savoir si vous êtes intéressé à l'autre de ces sujets et, si oui, où vous habitez.
A propos de la seule autre chose que je sais à ce stade est que je serai peaufiner le programme qui est sur leur site un peu mettre à jour pour 3.0 et pour correspondre à mon style d'enseignement. Autre que cela, les détails seront à venir une fois que je les connais.
Libellés :
Cocoa Touch,
Enseigner,
SDK iPhone,
tutoriels
vendredi 17 février 2012
Partie 6
Juste un avertissement rapide. Pour le week-end des dernières années, mon rituel week-end a été d'écrire un épisode de la OpenGL ES From the Ground Up tutoriels. Le sixième épisode ne sera probablement pas sortir ce week-end, cependant.
Je suis en attente sur mon projet d'écriture en cours, ainsi que mes filles sont dans quatre spectacles de danse ce week-end, et j'ai des parents à venir en ville. La chance que je serai capable de se faufiler hors tension et hors Geek écrire sur OpenGL ES sont minces à aucun. Mais n'ayez crainte, plus versements seront à venir.
Je suis en attente sur mon projet d'écriture en cours, ainsi que mes filles sont dans quatre spectacles de danse ce week-end, et j'ai des parents à venir en ville. La chance que je serai capable de se faufiler hors tension et hors Geek écrire sur OpenGL ES sont minces à aucun. Mais n'ayez crainte, plus versements seront à venir.
mercredi 15 février 2012
OpenGL ES à partir de zéro, la partie 5: Vivre dans un monde matérialiste
Bon, dans le dernier versement, Nous avons parlé des lumières, la façon de les mettre en place et quels sont les attributs qu'ils ont. Nous avons également parlé des trois composantes de la lumière, diffuse, ambient, Et specular. Si vous n'êtes pas entièrement clair sur celles-ci, vous pourriez vouloir examiner, comme ces composants sont utilisés massivement dans la définition des matériaux.

L'image Source Wikimedia Commons, modifié comme autorisé par la licence.
Comme point de départ pour cette tranche, nous allons utiliser le Sphère de procédure projet de cette annonce. Nous sommes le passage à une sphère plutôt que de continuer avec l'icosaèdre que nous avons utilisé jusqu'à présent en raison d'une sphère est la forme idéale pour montrer comment les différentes composantes de lumières et de matières interagissent les uns avec les autres.
Alors, parlons de quelle couleur est. C'est probablement une révision pour toute personne qui a passé l'école d'art de qualité, mais nous allons le faire quand même. Pourquoi les choses ont la couleur dans le monde réel? Quelles sont les causes?
Lumière que nous pouvons voir est appelé le spectre de lumière visible. Nous percevons des couleurs différentes en fonction de la longueur d'onde de cette lumière. À une extrémité du spectre visible, nous avons la plus haute fréquence, longueur d'onde inférieure violets et bleus, et à l'autre bout, nous avons la plus basse fréquence, les oranges et les rouges de longueur d'onde plus élevée:

Les ondes électromagnétiques qui se situent en dehors de cette gamme - à la fois supérieure et inférieure - ne sont pas "lumière visible", mais il est la distinction OFAN quelque chose d'artificiel puisque la seule différence est la longueur d'onde, la fréquence et la capacité de l'œil humain de le percevoir. Toutefois, cette capacité à percevoir les ondes électromagnétiques, c'est tout, donc nous aussi loin que OpenGL est concernée, le spectre visible est tout ce que nous préoccupent.
Maintenant, «lumière blanche» contient des quantités égales de toutes les longueurs d'onde. En d'autres termes, la lumière blanche est blanc car il contient tous (ou au moins la plupart) des fréquences de la lumière visible. Si vous avez déjà expérimenté avec un prisme, vous avez vu cet effet dans l'action:

Le prisme réfracte la lumière blanche pour que la lumière aux longueurs d'onde différentes est séparé. C'est aussi le processus par lequel les arcs sont créés et ZOMG poneys! Non, pas vraiment sur les poneys, mais c'est vrai sur les arcs en ciel.
Maintenant, si vous regardez un objet, et il apparaît en bleu, ce qui se passe est que l'objet absorbe la plupart de l'extrémité inférieure de la gamme visible. L'objet absorbe rouge, orange, jaune clair et vert. Selon la teinte de bleu, il peut également être absorber violet et du bleu.
Mais la plupart des longueurs d'onde bleues sont réfléchie vers l'œil. Parce que certains de la lumière visible a été absorbée, la lumière étant de refléter à votre oeil n'est plus blanc parce qu'il ne contient plus de toutes les longueurs d'onde du spectre visible.
Assez simple, non? Voyons comment cela s'applique à OpenGL.
Pour définir une couleur d'un matériau en OpenGL ES, nous définissons comment ce matériau réfléchit la lumière, tout comme la manière dont les choses fonctionnent dans le monde réel. Si un matériau est mis en place pour réfléchir la lumière rouge, puis il apparaîtra en rouge lorsque figurant sous réguliers, la lumière blanche.
En OpenGL (du moins quand lors de l'utilisation ombrage lisse et lumières) matériaux n'ont pas seulement une seule couleur. Nous avons la possibilité de spécifier exactement comment le matériel reflète chacune des trois composantes de lumières OpenGL (ambiante, diffuse et spéculaire) séparément. De plus, nous avons la capacité de spécifier le matériau de emissive la propriété, dont nous parlerons un peu plus tard.
Pour créer un matériau en OpenGL, nous faisons un ou plusieurs appels soit glMaterialf () ou glMaterialfv (). De la même façon que nous avons spécifié des lumières dans le dernier versement, nous avons souvent à faire des appels multiples à ces fonctions pour définir pleinement le matériel, car chaque attribut ou d'un composant doit être spécifié individuellement en faisant un appel séparé. Tout composant ou d'un attribut qui n'est pas spécifié par défaut à zéro ou, dans le cas des couleurs, le noir.
Le premier paramètre passé à deux glMaterialf () ou glMaterialfv () est toujours un GL_ENUM qui spécifie si le matériau affecte le front, le dos, ou les deux faces avant et arrière de polygones. Il ya en fait inutile d'avoir ce premier argument en OpenGL ES autres que pour la compatibilité avec OpenGL ES, car il n'ya qu'une seule option valable: GL_FRONT_AND_BACK, qui indique simplement que les matériaux sont utilisés pour tout polygone qui est dessiné. Si vous vous souvenez de partie 1, Les triangles ont un avant et un arrière qui est déterminée par leur enroulement (pour les sommets sont tirées). Par défaut, seule la face d'un triangle est dessiné en OpenGL, mais il est possible de faire OpenGL dessiner le dos, ou même pour dessiner uniquement le dos, et OpenGL régulière serait vous permettent de spécifier des matériaux différents pour avant et arrière en passant soit GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK. Mais, OpenGL ES ne supporte aucune autre option que GL_FRONT_AND_BACK, alors juste passer que toujours, 'kay?
Le second paramètre à glMaterialf () ou glMaterialfv () est une GL_ENUM qui identifie quel composant ou d'un attribut de la matière que vous définissez. Ce sont les mêmes valeurs nous passâmes dans glLightfv (), comme GL_AMBIENT, avec quelques nouveaux, vous verrez dans un instant.
La valeur finale est soit un GL_FLOAT, ou un pointeur vers un tableau de GL_FLOATs qui contient la valeur réelle de l'attribut ou d'un composant.
Les composants les plus imoprtant d'un matériau qui doivent être mis en sont les composantes ambiantes et diffuses, car ils définissent comment un matériau reflète l'essentiel de la lumière étant brillé sur elle. Le projet de code que nous utilisons aujourd'hui a défini la lumière blanche, un peu comme la lumière produite par le soleil, ou une ampoule en ce qu'elle a toutes les longueurs d'onde de la lumière ou des couleurs représentées également. Si notre lumière ne sont pas blancs, l'apparition de notre sphère serait différente. La lumière bleue se reflétant sur un matériau rouge, par exemple, produisent une teinte violette. Pour simplifier, nous allons travailler uniquement avec la lumière blanche et vous pouvez vous sentir libre d'essayer de changer les couleurs de la lumière sur votre propre pour voir comment les lumières et les matériaux interagissent. Pour la plupart, ils interagissent dans OpenGL ES comme ils le feraient dans la vraie vie.
Voici ce que le projet ressemble quand il est lancé, avant d'ajouter tous les matériaux:

Comme vous pouvez le voir, nous avons quelques lumière ambiante et de lumière beaucoup plus diffus.
Quand on parle de matériaux en OpenGL, nous avons besoin de parler des composantes ambiantes et diffuses dans le même temps, parce que ces deux travaillent ensemble pour définir la couleur perçue de l'objet. Rappelez-vous, la lumière diffuse est la partie supérieure de la sphère dans toute première image de cette annonce (le plus lumineux jaune), et la température ambiante est la plus sombre partie jaune sur le dessous. Comment le matériel reflète ces deux éléments détermineront quelle couleur que vous percevez l'objet à l'être. Maintenant, la photo ci-dessus aurait pu être réalisé dans plus d'un titre. Probablement, la sphère jaune reflète les propriétés ambiantes et diffuses dans la même proportion, mais la scène a moins de lumière ambiante définie.
Probablement 90% du temps ou plus, vous pourrez spécifier les paramètres ambiants et diffus d'un matériau exactement les mêmes. En faisant cela, elle devient la quantité d'diffuse et ambiante qui détermine l'ombrage et l'apparence de l'objet. Il est, en fait, un moyen de spécifier les composantes diffuses et ambiantes d'un matériau à la fois avec un seul appel à glMaterialfv (). Voici comment nous pourrions déclarer notre matériel à une nuance de bleu:
Tout comme avec glColor4f (), la fixation d'un matériau dicte la façon dont tout est tirée jusqu'à une autre matière est spécifiée. Si le code est placé avant-dessus de notre code de dessin, et nous courons maintenant le projet, nous allons voir que notre sphère est devenue une seule nuance de bleu. Le dessous est encore plus sombre car notre lumière ambiante n'est pas aussi fort que notre lumière diffuse:

Il peut y avoir des moments où vous voulez plus de contrôle et que vous voulez spécifier la manière dont le matériel reflète la lumière diffuse et ambiante séparément. Par exemple, nous pourrions faire ce qui suit pour créer un matériau qui reflète le bleu de la lumière ambiante, mais le rouge de la lumière diffuse:
Si nous courons cela, nous obtenons une apparence très différente:

Dans ce cas, il semble que nous sommes une lumière colorée sur la sphère, même si nous ne sommes pas. La raison pour laquelle il semble que le chemin est que nous sommes reflétant la lumière directionnelle différemment que la lumière ambiante.
Dans la plupart des cas, si vous voulez donner l'apparence de lumières colorées, puis créer des lumières colorées et de spécifier les couleurs de votre matériel à l'aide GL_AMBIENT_AND_DIFFUSE. Mais, il ya des moments où vous voudrez peut-être de les séparer pour créer des effets spéciaux ou de falsifier un cas isolé, lumière de tache de couleur, sans encourir les frais généraux d'une lumière supplémentaire. Rappelez-vous: Chaque lumière vous ajoutez augmente les calculs qui doivent être effectuées à chaque seconde, donc ce n'est pas une mauvaise idée de tricher parfois.
Vous pouvez également spécifier la manière dont votre lumière se reflète la composante spéculaire de lumières de la scène séparément les composantes diffuses et ambiantes. Cela vous donne la possibilité de contrôler comment lumineux le spéculaire "hot spot" est. Un paramètre séparé, appelé GL_SHININESS travaille avec composante spéculaire du matériau pour définir la taille du spot spéculaire chaud. Si vous ne spécifiez une valeur GL_SPECULAR pour votre matériel, vous devez également définir sa brillance. Le supérieur de la brillance, plus la réflexion spéculaire, donc la valeur par défaut de 0,0 a tendance à complètement submerger la composante diffuse et regarde généralement mauvais.
Revenons à notre sphère bleue, et ajouter une tache spéculaire chaud pour elle.
Nous avons utilisé un DIM blanc pour notre valeur spéculaire. Cela peut sembler faible, mais la façon spéculaire est calculée, un peu semble aller un long chemin. La qualité de la composante spéculaire de la lumière est multipliée par composante spéculaire du matériau, et la lumière qui en résulte est concentrée dans la région dicté par la brillance de la matière. Voici ce que la sphère ressemble avec le code ci-dessus:

Nous avons maintenant une petite zone circulaire sur la sphère qui reflète davantage de lumière. Nous pouvons faire de cette brillante place en augmentant soit la composante spéculaire de notre lumière ou des lumières, ou en augmentant la shininesst de notre matériel. Nous pouvons également changer la taille de la lumière en modifiant légèrement la brillance. Les plus brillants du matériel, le plus concentré de la lumière spéculaire. Si nous changeons la brillance de 25,0 à 50,0, par exemple, nous obtenons une place beaucoup plus serré chaud, qui donne l'apparence d'une surface plus poli.

Voici un petit avertissement, cependant. Une partie de la raison pour laquelle je suis passé à sphères pour cette annonce, et la raison pour laquelle j'ai utilisé un décompte relativement élevé vertex pour cette sphère, c'est parce que les reflets spéculaires sur le low-poly objets ne semblent pas très bonnes. Regardez ce qui arrive si je réduis le nombre de sommets dans notre sphère à un nombre plus convivial de jeu:

Les reflets spéculaires ont tendance à rendre les bords triangle de se démarquer, et souligne souvent spéculaire juste ne semble pas bon pour le low-poly objets comme ceux que vous devriez utiliser dans un match. En OpenGL régulière, il ya quelque chose appelé un shader qui peut être utilisé pour réaliser de bons résultats avec les modèles low-poly, mais la version d'OpenGL ES sur l'iPhone ne dispose pas de shaders. La seule façon vous pouvez généralement faire des low-poly objets bien paraître dans les jeux est en oubliant totalement la composante spéculaire et l'utilisation de texture mapping, quelque chose que nous allons examiner à partir de la tranche suivante.
Il ya un dernier attribut important des matériaux que nous avons besoin de regarder, et cela s'appelle l'émission (ou parfois la émissive) composant. En fixant la composante d'émission, nous rendre le matériel ressemble il émet la lumière de la couleur, nous spécifions. Maintenant, ce n'est pas vraiment la lumière électroluminescente. Les objets proches, par exemple, ne sera pas affectée par la lumière émissive d'un autre objet. Si vous voulez faire un objet comme une ampoule qui brille réellement sur d'autres objets, vous devez combiner la composante d'émission avec une lumière réelle au même endroit que l'objet en raison (et cela va vous sembler redondante redondant), mais en OpenGL ES, les lumières ne fait émettre de la lumière. Mais, la composante d'émission peuvent être utilisés pour donner aux objets une lueur agréable.
Nous pourrions, par exemple, ajouter une belle glowiness vert à notre sphère bleue, en ajoutant ce code:
Cela nous donnerait un résultat qui ressemble à ceci:

La composante d'émission affecte la totalité du matériel, donc la valeur spécifiée pour GL_EMISSION est multipliée par tout type de lumière qui tombe sur un endroit précis sur l'objet. Notez que même les mettre en évidence spéculaire dans l'image ci-dessus a pris un peu d'un reflet bleu-vert plutôt que d'être un blanc pur. C'est subtil dans les spots lumineux, et le plus notable dans la zone inférieure, où seule la lumière ambiante est trop forte, mais elle affecte tout.
Eh bien, j'ai pensé longuement et sérieusement à une sorte de madone de référence ou au moins une référence en musique 80, pour la conclusion ici pour attacher ensemble avec le titre du détachement, mais j'ai été totalement incapable de trouver quoi que ce soit, même à distance d'esprit, donc je vais devoir tout laisser ici.
Dans le prochain épisode, nous allons examiner mappage de texture, ce qui peut être utilisé aussi bien pour les deux dimensions des sprites et aussi pour donner des objets tridimensionnels des surfaces plus complexes que les matériaux permettent.

Comme point de départ pour cette tranche, nous allons utiliser le Sphère de procédure projet de cette annonce. Nous sommes le passage à une sphère plutôt que de continuer avec l'icosaèdre que nous avons utilisé jusqu'à présent en raison d'une sphère est la forme idéale pour montrer comment les différentes composantes de lumières et de matières interagissent les uns avec les autres.
Quelle est la couleur
Alors, parlons de quelle couleur est. C'est probablement une révision pour toute personne qui a passé l'école d'art de qualité, mais nous allons le faire quand même. Pourquoi les choses ont la couleur dans le monde réel? Quelles sont les causes?
Lumière que nous pouvons voir est appelé le spectre de lumière visible. Nous percevons des couleurs différentes en fonction de la longueur d'onde de cette lumière. À une extrémité du spectre visible, nous avons la plus haute fréquence, longueur d'onde inférieure violets et bleus, et à l'autre bout, nous avons la plus basse fréquence, les oranges et les rouges de longueur d'onde plus élevée:

Les ondes électromagnétiques qui se situent en dehors de cette gamme - à la fois supérieure et inférieure - ne sont pas "lumière visible", mais il est la distinction OFAN quelque chose d'artificiel puisque la seule différence est la longueur d'onde, la fréquence et la capacité de l'œil humain de le percevoir. Toutefois, cette capacité à percevoir les ondes électromagnétiques, c'est tout, donc nous aussi loin que OpenGL est concernée, le spectre visible est tout ce que nous préoccupent.
Maintenant, «lumière blanche» contient des quantités égales de toutes les longueurs d'onde. En d'autres termes, la lumière blanche est blanc car il contient tous (ou au moins la plupart) des fréquences de la lumière visible. Si vous avez déjà expérimenté avec un prisme, vous avez vu cet effet dans l'action:

Le prisme réfracte la lumière blanche pour que la lumière aux longueurs d'onde différentes est séparé. C'est aussi le processus par lequel les arcs sont créés et ZOMG poneys! Non, pas vraiment sur les poneys, mais c'est vrai sur les arcs en ciel.
Maintenant, si vous regardez un objet, et il apparaît en bleu, ce qui se passe est que l'objet absorbe la plupart de l'extrémité inférieure de la gamme visible. L'objet absorbe rouge, orange, jaune clair et vert. Selon la teinte de bleu, il peut également être absorber violet et du bleu.
Mais la plupart des longueurs d'onde bleues sont réfléchie vers l'œil. Parce que certains de la lumière visible a été absorbée, la lumière étant de refléter à votre oeil n'est plus blanc parce qu'il ne contient plus de toutes les longueurs d'onde du spectre visible.
Assez simple, non? Voyons comment cela s'applique à OpenGL.
Matériaux OpenGL
Pour définir une couleur d'un matériau en OpenGL ES, nous définissons comment ce matériau réfléchit la lumière, tout comme la manière dont les choses fonctionnent dans le monde réel. Si un matériau est mis en place pour réfléchir la lumière rouge, puis il apparaîtra en rouge lorsque figurant sous réguliers, la lumière blanche.
En OpenGL (du moins quand lors de l'utilisation ombrage lisse et lumières) matériaux n'ont pas seulement une seule couleur. Nous avons la possibilité de spécifier exactement comment le matériel reflète chacune des trois composantes de lumières OpenGL (ambiante, diffuse et spéculaire) séparément. De plus, nous avons la capacité de spécifier le matériau de emissive la propriété, dont nous parlerons un peu plus tard.
Spécification d'un matériau
Pour créer un matériau en OpenGL, nous faisons un ou plusieurs appels soit glMaterialf () ou glMaterialfv (). De la même façon que nous avons spécifié des lumières dans le dernier versement, nous avons souvent à faire des appels multiples à ces fonctions pour définir pleinement le matériel, car chaque attribut ou d'un composant doit être spécifié individuellement en faisant un appel séparé. Tout composant ou d'un attribut qui n'est pas spécifié par défaut à zéro ou, dans le cas des couleurs, le noir.
Le premier paramètre passé à deux glMaterialf () ou glMaterialfv () est toujours un GL_ENUM qui spécifie si le matériau affecte le front, le dos, ou les deux faces avant et arrière de polygones. Il ya en fait inutile d'avoir ce premier argument en OpenGL ES autres que pour la compatibilité avec OpenGL ES, car il n'ya qu'une seule option valable: GL_FRONT_AND_BACK, qui indique simplement que les matériaux sont utilisés pour tout polygone qui est dessiné. Si vous vous souvenez de partie 1, Les triangles ont un avant et un arrière qui est déterminée par leur enroulement (pour les sommets sont tirées). Par défaut, seule la face d'un triangle est dessiné en OpenGL, mais il est possible de faire OpenGL dessiner le dos, ou même pour dessiner uniquement le dos, et OpenGL régulière serait vous permettent de spécifier des matériaux différents pour avant et arrière en passant soit GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK. Mais, OpenGL ES ne supporte aucune autre option que GL_FRONT_AND_BACK, alors juste passer que toujours, 'kay?
Le second paramètre à glMaterialf () ou glMaterialfv () est une GL_ENUM qui identifie quel composant ou d'un attribut de la matière que vous définissez. Ce sont les mêmes valeurs nous passâmes dans glLightfv (), comme GL_AMBIENT, avec quelques nouveaux, vous verrez dans un instant.
La valeur finale est soit un GL_FLOAT, ou un pointeur vers un tableau de GL_FLOATs qui contient la valeur réelle de l'attribut ou d'un composant.
Les composants les plus imoprtant d'un matériau qui doivent être mis en sont les composantes ambiantes et diffuses, car ils définissent comment un matériau reflète l'essentiel de la lumière étant brillé sur elle. Le projet de code que nous utilisons aujourd'hui a défini la lumière blanche, un peu comme la lumière produite par le soleil, ou une ampoule en ce qu'elle a toutes les longueurs d'onde de la lumière ou des couleurs représentées également. Si notre lumière ne sont pas blancs, l'apparition de notre sphère serait différente. La lumière bleue se reflétant sur un matériau rouge, par exemple, produisent une teinte violette. Pour simplifier, nous allons travailler uniquement avec la lumière blanche et vous pouvez vous sentir libre d'essayer de changer les couleurs de la lumière sur votre propre pour voir comment les lumières et les matériaux interagissent. Pour la plupart, ils interagissent dans OpenGL ES comme ils le feraient dans la vraie vie.
Voici ce que le projet ressemble quand il est lancé, avant d'ajouter tous les matériaux:

Comme vous pouvez le voir, nous avons quelques lumière ambiante et de lumière beaucoup plus diffus.
Ambient et Diffuse
Quand on parle de matériaux en OpenGL, nous avons besoin de parler des composantes ambiantes et diffuses dans le même temps, parce que ces deux travaillent ensemble pour définir la couleur perçue de l'objet. Rappelez-vous, la lumière diffuse est la partie supérieure de la sphère dans toute première image de cette annonce (le plus lumineux jaune), et la température ambiante est la plus sombre partie jaune sur le dessous. Comment le matériel reflète ces deux éléments détermineront quelle couleur que vous percevez l'objet à l'être. Maintenant, la photo ci-dessus aurait pu être réalisé dans plus d'un titre. Probablement, la sphère jaune reflète les propriétés ambiantes et diffuses dans la même proportion, mais la scène a moins de lumière ambiante définie.
Probablement 90% du temps ou plus, vous pourrez spécifier les paramètres ambiants et diffus d'un matériau exactement les mêmes. En faisant cela, elle devient la quantité d'diffuse et ambiante qui détermine l'ombrage et l'apparence de l'objet. Il est, en fait, un moyen de spécifier les composantes diffuses et ambiantes d'un matériau à la fois avec un seul appel à glMaterialfv (). Voici comment nous pourrions déclarer notre matériel à une nuance de bleu:
GLfloat ambientAndDiffuse[] = {0.0, 0.1, 0.9, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, ambientAndDiffuse);Tout comme avec glColor4f (), la fixation d'un matériau dicte la façon dont tout est tirée jusqu'à une autre matière est spécifiée. Si le code est placé avant-dessus de notre code de dessin, et nous courons maintenant le projet, nous allons voir que notre sphère est devenue une seule nuance de bleu. Le dessous est encore plus sombre car notre lumière ambiante n'est pas aussi fort que notre lumière diffuse:

Il peut y avoir des moments où vous voulez plus de contrôle et que vous voulez spécifier la manière dont le matériel reflète la lumière diffuse et ambiante séparément. Par exemple, nous pourrions faire ce qui suit pour créer un matériau qui reflète le bleu de la lumière ambiante, mais le rouge de la lumière diffuse:
GLfloat ambient[] = {0.0, 0.1, 0.9, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
GLfloat diffuse[] = {0.9, 0.0, 0.1, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);Si nous courons cela, nous obtenons une apparence très différente:

Dans ce cas, il semble que nous sommes une lumière colorée sur la sphère, même si nous ne sommes pas. La raison pour laquelle il semble que le chemin est que nous sommes reflétant la lumière directionnelle différemment que la lumière ambiante.
Dans la plupart des cas, si vous voulez donner l'apparence de lumières colorées, puis créer des lumières colorées et de spécifier les couleurs de votre matériel à l'aide GL_AMBIENT_AND_DIFFUSE. Mais, il ya des moments où vous voudrez peut-être de les séparer pour créer des effets spéciaux ou de falsifier un cas isolé, lumière de tache de couleur, sans encourir les frais généraux d'une lumière supplémentaire. Rappelez-vous: Chaque lumière vous ajoutez augmente les calculs qui doivent être effectuées à chaque seconde, donc ce n'est pas une mauvaise idée de tricher parfois.
Spéculaire et la brillance
Vous pouvez également spécifier la manière dont votre lumière se reflète la composante spéculaire de lumières de la scène séparément les composantes diffuses et ambiantes. Cela vous donne la possibilité de contrôler comment lumineux le spéculaire "hot spot" est. Un paramètre séparé, appelé GL_SHININESS travaille avec composante spéculaire du matériau pour définir la taille du spot spéculaire chaud. Si vous ne spécifiez une valeur GL_SPECULAR pour votre matériel, vous devez également définir sa brillance. Le supérieur de la brillance, plus la réflexion spéculaire, donc la valeur par défaut de 0,0 a tendance à complètement submerger la composante diffuse et regarde généralement mauvais.
Revenons à notre sphère bleue, et ajouter une tache spéculaire chaud pour elle.
GLfloat ambientAndDiffuse[] = {0.0, 0.1, 0.9, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, ambientAndDiffuse);
GLfloat specular[] = {0.3, 0.3, 0.3, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 25.0);Nous avons utilisé un DIM blanc pour notre valeur spéculaire. Cela peut sembler faible, mais la façon spéculaire est calculée, un peu semble aller un long chemin. La qualité de la composante spéculaire de la lumière est multipliée par composante spéculaire du matériau, et la lumière qui en résulte est concentrée dans la région dicté par la brillance de la matière. Voici ce que la sphère ressemble avec le code ci-dessus:

Nous avons maintenant une petite zone circulaire sur la sphère qui reflète davantage de lumière. Nous pouvons faire de cette brillante place en augmentant soit la composante spéculaire de notre lumière ou des lumières, ou en augmentant la shininesst de notre matériel. Nous pouvons également changer la taille de la lumière en modifiant légèrement la brillance. Les plus brillants du matériel, le plus concentré de la lumière spéculaire. Si nous changeons la brillance de 25,0 à 50,0, par exemple, nous obtenons une place beaucoup plus serré chaud, qui donne l'apparence d'une surface plus poli.

Voici un petit avertissement, cependant. Une partie de la raison pour laquelle je suis passé à sphères pour cette annonce, et la raison pour laquelle j'ai utilisé un décompte relativement élevé vertex pour cette sphère, c'est parce que les reflets spéculaires sur le low-poly objets ne semblent pas très bonnes. Regardez ce qui arrive si je réduis le nombre de sommets dans notre sphère à un nombre plus convivial de jeu:

Les reflets spéculaires ont tendance à rendre les bords triangle de se démarquer, et souligne souvent spéculaire juste ne semble pas bon pour le low-poly objets comme ceux que vous devriez utiliser dans un match. En OpenGL régulière, il ya quelque chose appelé un shader qui peut être utilisé pour réaliser de bons résultats avec les modèles low-poly, mais la version d'OpenGL ES sur l'iPhone ne dispose pas de shaders. La seule façon vous pouvez généralement faire des low-poly objets bien paraître dans les jeux est en oubliant totalement la composante spéculaire et l'utilisation de texture mapping, quelque chose que nous allons examiner à partir de la tranche suivante.
Emission
Il ya un dernier attribut important des matériaux que nous avons besoin de regarder, et cela s'appelle l'émission (ou parfois la émissive) composant. En fixant la composante d'émission, nous rendre le matériel ressemble il émet la lumière de la couleur, nous spécifions. Maintenant, ce n'est pas vraiment la lumière électroluminescente. Les objets proches, par exemple, ne sera pas affectée par la lumière émissive d'un autre objet. Si vous voulez faire un objet comme une ampoule qui brille réellement sur d'autres objets, vous devez combiner la composante d'émission avec une lumière réelle au même endroit que l'objet en raison (et cela va vous sembler redondante redondant), mais en OpenGL ES, les lumières ne fait émettre de la lumière. Mais, la composante d'émission peuvent être utilisés pour donner aux objets une lueur agréable.
Nous pourrions, par exemple, ajouter une belle glowiness vert à notre sphère bleue, en ajoutant ce code:
GLfloat emission[] = {0.0, 0.4, 0.0, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);Cela nous donnerait un résultat qui ressemble à ceci:

La composante d'émission affecte la totalité du matériel, donc la valeur spécifiée pour GL_EMISSION est multipliée par tout type de lumière qui tombe sur un endroit précis sur l'objet. Notez que même les mettre en évidence spéculaire dans l'image ci-dessus a pris un peu d'un reflet bleu-vert plutôt que d'être un blanc pur. C'est subtil dans les spots lumineux, et le plus notable dans la zone inférieure, où seule la lumière ambiante est trop forte, mais elle affecte tout.
C'est tout ce qu'elle a écrit
Eh bien, j'ai pensé longuement et sérieusement à une sorte de madone de référence ou au moins une référence en musique 80, pour la conclusion ici pour attacher ensemble avec le titre du détachement, mais j'ai été totalement incapable de trouver quoi que ce soit, même à distance d'esprit, donc je vais devoir tout laisser ici.
Dans le prochain épisode, nous allons examiner mappage de texture, ce qui peut être utilisé aussi bien pour les deux dimensions des sprites et aussi pour donner des objets tridimensionnels des surfaces plus complexes que les matériaux permettent.
Inscription à :
Articles (Atom)