Techniques d'intégration multimédia
Mathf est le nom de la classe dans Unity qui offre diverses méthodes mathématiques utiles. Cette classe contient des fonctions pour faire des calculs de trigonométrie, de valeurs exponentielles, d'arrondissement, par exemple, en plus de quelques constantes utiles (dont le nombre Pi).
Quelques exemples d'utilisation de Mathf:
float a=Mathf.Cos(0.5f); // le cosinus de 0.5
float b=Mathf.Round(1.5f); // la valeur arrondie de 1.5 (c'est à dire 2)
float c=Mathf.PI*angle; // un angle, multiplié par le nombre PI (3.1416...)
Remarque!
La classe Mathf est une classe aux méthodes et propriétés statiques. En conséquence, on utilise le nom de la classe pour préfixer l'appel des fonctions (ex: Mathf.Floor() ) ou l'accès aux propriétés (ex: Mathf.PI). On ne peut pas créer d'instance d'une classe statique: vous ne verrez donc jamais une instruction comme: oMath=new Mathf().
Attention!
Dans la documentation officielle de C# de MicroSoft, vous allez certainement rencontrer des références à la classe Math. Cette classe joue un rôle semblable à Mathf en Unity, mais pour le développement C# ailleurs que dans Unity: Dans Unity, c'est Mathf qui est utilisée.
Voici quelques unes des méthodes les plus utilisées de la classe Mathf dans Unity.
Méthode | Description | Exemples |
---|---|---|
Abs(float n) | retourne la valeur absolue du nombre n | float j=Mathf.Abs(-12.2f); // j==12.2f |
Atan2(float y,float x) | retourne un angle en radians correspondant à n | float j=Mathf.Atan2(0.5f); // j==0.463647609... |
Ceil(float n) | retourne la valeur entière supérieure le plus près ou égal à n sous forme d'un float | float j=Mathf.Ceil(1.1f); float k=Mathf.Ceil(1.9f); // j==2f, k==2f |
CeilToInt(float n) | retourne la valeur entière supérieure le plus près ou égal à n sous forme d'un int | int j=Mathf.CeilToInt(1.1f); int k=Mathf.CeilToInt(1.9f); // j==2, k==2 |
Clamp(float n,float min, float max) | retourne la valeur min si n est plus petit que min et la valeur max si n est plus grand que max. Sinon, la fonction retourne simplement n. | float i=Mathf.Clamp(6.1f,2f,9f); float j=Mathf.Clamp(1.5f,2f,9f); float k=Mathf.Clamp(10f,2f,9f); // i==6.1f, j==2f, k==9f |
Clamp01(float n) | Comme la fonction Clamp, mais le min/max est préréglé à 0f et 1f. | float i=Mathf.Clamp01(0.5f); float j=Mathf.Clamp01(-2f); float k=Mathf.Clamp01(1.3f); // i==0.5f, j==0f, k==1f |
Cos(float n) | retourne le cosinus d'un angle exprimé en radians | float j=Mathf.Cos(0.9f); // j==0.6216099682... |
DeltaAngle(float n1, float n2) | retourne l'angle le plus petit entre 2 angles donné (en degrés) | float j= Mathf.DeltaAngle(1080f,90f); // j==90f |
Floor(float n) | retourne la valeur entière (mais en float) inférieure le plus près ou égale à n | float j=Mathf.Floor(1.1f); float k=Mathf.Floor(1.9f); // j==1f, k==1f |
FloorToInt(float n) | retourne la valeur entière (en int) inférieure le plus près ou égale à n | int j=Mathf.Floor(1.1f); int k=Mathf.Floor(1.9f); // j==1, k==1 |
Lerp(float a,float b,float c) | retourne un nombre interpolé entre les valeurs a et b selon la valeur c qui représente un ratio de 0f à 1f | float j=Mathf.Lerp(0f,6f,0.5f); float k=Mathf.Lerp(2f,15f,0.9f); // j==3f, k==13.7f |
LerpAngle(float a,float b,float c) | fonctionne comme la méthode Lerp() mais la valeur retournée est interpolée de façon à représenter correctement une rotation sur 360 degrés. | float j= Mathf.LerpAngle(-15f,582f,0.5f); // j==76.5f |
Log(float n, float p) | retourne le logarithme en base p d'un nombre n | float j=Mathf.Log(6f,2f); // j==2.584963f |
Max(float n1,float n2,...) | retourne le plus grand des nombres passés en paramètres | float
j=Mathf.Max(5f,2f,7f); // j==7f |
Min(float n1,float n2,...) | retourne le plus petit des nombres passés en paramètres | float
j=Mathf.Min(5f,2f,7f); // j==2f |
MoveTowards(float n,float t,float d) | retourne un nombre plus près de la valeur cible t d'une valeur d. La valeur retournée ne peut dépasser t. | float j=MoveTowards(5f,10f,2f); float k=MoveTowards(5f,10f,8f); // j==7f (5f + 2f...) // k==10f (5f + 8f > 10f...) |
MoveTowardsAngle(float n,float t,float d) | fonctionne comme la méthode MoveTowards() mais la valeur retournée est interpolée de façon à représenter correctement une rotation sur 360 degrés. | float n=270f; float t=45f; float j=Mathf.MoveTowardsAngle(a,t,2f); // j==272f |
PinPong(float n1, float n2) | retourne une valeur basée sur n1 qui fait des aller retours entre 0f et n2. | float i=Mathf.PingPong(1.5f, 2f); float j=Mathf.PingPong(2.1f, 2f); float k=Mathf.PingPong(3.4f, 2f); // i==1.5f // j==1.9f // k==0.5999999f |
Pow(float n, float p) | élève un nombre n à une puissance p | float
j=Mathf.Pow(2f,5f); // j==32f |
Repeat(float n, float max) | retourne une valeur telle que n ne dépasse pas max. Cette fonction produit le même effet que l'opérateur modulo, mais sur des float. | float
j=Mathf.Repeat(3f,2.5f) float k=Mathf.Repeat(5f,2.5f) // j==0.5f, k==0f |
Round(float n) | retourne la valeur entière la plus proche du nombre n (sous forme de float) | float j=Mathf.Round(1.4f) float k=Mathf.Round(1.5f) // j==1f, k==2f |
RoundToInt(float n) | retourne la valeur entière la plus proche du nombre n (sous forme de int) | int j=Mathf.RoundToInt(1.4f) int k=Mathf.RoundToInt(1.5f) // j==1, k==2 |
Sin(float n) | retourne le sinus d'un angle en radians | float j=Mathf.Sin(0.9f) //j==0.783326909... |
SmoothDamp(paramètres nombreux...) | retourne une valeur interpolée selon des paramètres donnés de façon à changer une valeur dans le temps | Voir la documentation de Unity pour des exemples |
SmoothDampAngle(paramètres nombreux...) | fonctionne comme la méthode SmoothDamp() mais la valeur retournée est interpolée de façon à représenter correctement une rotation sur 360 degrés. | Voir la documentation de Unity pour des exemples |
SmoothStep(float a,float b,float c) | Fonctionne comme Lerp() mais l'interpolation accélère au début et ralentit à la fin, produisant des valeurs pouvant créer des transitions naturelles (accélérations, fondus, etc) | Voir la documentation de Unity pour des exemples |
Sqrt(float n) | retourne racine carrée d'un nombre n | float j=Mathf.Sqrt(9f) // j==3f |
La classe Mathf comporte plus de méthodes que cette liste (entre autres, plusieurs méthodes pour faire des calculs trigonométriques ou des interpolations de valeurs). Consultez la documentation sur le site de Unity pour une liste complète des méthodes disponibles dans Mathf.
Voici les constantes les plus utilisées de la classe Mathf dans Unity.
Constante | Description |
---|---|
Deg2Rad | Pour convertir des degrés en radians ( vaut: Mathf.PI/180) |
Epsilon | Le plus petit float différent de zéro |
Infinity | Représentation de l'infini positif |
NegativeInfinity | Représentation de l'infini négatif |
PI | La valeur de pi, approx: 3.14159f |
Rad2Deg | Pour convertir des radians en degrés ( vaut: 180/Mathf.PI) |
Plusieurs fonctions trigonométriques, par exemple Sin() et Cos(), utilisent en paramètres des valeurs exprimées en radians. Certaines fonctions, comme Atan2() par exemple, retournent comme résultat un angle exprimé en radians. Il devient dont souvent nécessaire de convertir des radians en degrés, ou l'inverse. Unity propose 2 constantes qui permettent de convertir les radians en degrés et vice versa.
// cette fonction retourne la valeur en radians
// d'un angle donné en degrés
private float ToRad(float angleEnDegres)
{
return angleEnDegres * Mathf.Deg2Rad; // Deg2Rad vaut Mathf.PI/180;
}
// cette fonction retourne la valeur en degrés
// d'un angle donné en radians
private float ToDeg(float angleEnRadians)
{
return angleEnRadians * Mathf.Rad2Deg; // Rad2Deg vaut 180/Mathf.PI;
}
d'où...
1 radian = 180 / Pi degrés
1 degré = Pi / 180 radians