Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

AABB

Une boîte délimitante 3D alignée sur les axes.

Description

Le type Variant intégré AABB représente une boîte délimitante alignée sur les axes dans un espace 3D. Elle est définie par sa position et sa taille size, qui sont des Vector3. Elle est fréquemment utilisée pour les tests de chevauchement rapide (voir intersects()). Bien que AABB elle-même soit alignée sur les axes, elle peut être combinée avec Transform3D pour représenter une boîte englobante tournée ou cisaillée.

Elle utilise des coordonnées flottantes. La contrepartie 2D de AABB est Rect2. Il n'y a pas de version de AABB qui utilise des coordonnées entières.

Note : ** Les valeurs négatives pour :ref:`size<class_AABB_property_size>` ne sont pas supportées. Avec une taille négative, la plupart des méthodes de **AABB ne fonctionnent pas correctement. Utilisez abs() pour obtenir une AABB équivalente avec une taille non négative.

Note : Dans un contexte booléen, une AABB évalue à false si position et size valent tous les deux zéro (égaux à Vector3.ZERO). Sinon, elle évalue toujours à true.

Note

Il y a des différences notables dans l'utilisation de cette API en C#. Voir Différences de l'API C# par rapport à GDScript pour plus d'informations.

Tutoriels

Propriétés

Vector3	end	`Vector3(0, 0, 0)`
Vector3	position	`Vector3(0, 0, 0)`
Vector3	size	`Vector3(0, 0, 0)`

Constructeurs

AABB	AABB()
AABB	AABB(from: AABB)
AABB	AABB(position: Vector3, size: Vector3)

Méthodes

AABB	abs() const
bool	encloses(with: AABB) const
AABB	expand(to_point: Vector3) const
Vector3	get_center() const
Vector3	get_endpoint(idx: int) const
Vector3	get_longest_axis() const
int	get_longest_axis_index() const
float	get_longest_axis_size() const
Vector3	get_shortest_axis() const
int	get_shortest_axis_index() const
float	get_shortest_axis_size() const
Vector3	get_support(direction: Vector3) const
float	get_volume() const
AABB	grow(by: float) const
bool	has_point(point: Vector3) const
bool	has_surface() const
bool	has_volume() const
AABB	intersection(with: AABB) const
bool	intersects(with: AABB) const
bool	intersects_plane(plane: Plane) const
Variant	intersects_ray(from: Vector3, dir: Vector3) const
Variant	intersects_segment(from: Vector3, to: Vector3) const
bool	is_equal_approx(aabb: AABB) const
bool	is_finite() const
AABB	merge(with: AABB) const

Opérateurs

bool	operator !=(right: AABB)
AABB	operator *(right: Transform3D)
bool	operator ==(right: AABB)

Descriptions des propriétés

Vector3 end = Vector3(0, 0, 0) 🔗

Le point de fin. Il s'agit généralement du coin en haut à droite et en arrière de la boîte délimitante , et est équivalent à position + size. Définir ce point affecte la taille size.

Vector3 position = Vector3(0, 0, 0) 🔗

Le point d'origine. Il s'agit généralement du coin en bas à gauche et à l'avant de la boîte délimitante.

Vector3 size = Vector3(0, 0, 0) 🔗

La largeur, la hauteur et la profondeur de la boîte délimitante à partir de la position. Définir cette valeur affecte aussi le point de fin end.

Note : Il est recommandé de fixer la largeur, la hauteur et la profondeur à des valeurs non négatives. C'est parce que la plupart des méthodes de Godot supposent que la position est le coin inférieur gauche-avant, et le point de fin end est le coin supérieur droit-arrière. Pour obtenir une boîte délimitante équivalente avec une taille non négative, utilisez abs().

Descriptions des constructeurs

AABB AABB() 🔗

Construit une AABB avec sa position et sa taille size définies à Vector3.ZERO.

AABB AABB(from: AABB)

Construit une AABB en tant que copie de la AABB donnée.

AABB AABB(position: Vector3, size: Vector3)

Construit une AABB avec sa position et sa taille size.

Descriptions des méthodes

AABB abs() const 🔗

Renvoie une AABB équivalente à cette boîte délimitante, avec sa largeur, sa hauteur et sa profondeur modifiées pour être des valeurs non-négatives.

var box = AABB(Vector3(5, 0, 5), Vector3(-20, -10, -5))
var absolu = box.abs()
print(absolu.position) # Affiche (-15.0, -10.0, 0.0)
print(absolu.size)          # Affiche (20.0, 10.0, 5.0)

var box = new Aabb(new Vector3(5, 0, 5), new Vector3(-20, -10, -5));
var absolu = box.Abs();
GD.Print(absolu.Position); // Affiche (-15.0, -10.0, 0.0)
GD.Print(absolu.Size); // Affiche (20.0, 10.0, 5.0)

Note : Il est recommandé d'utiliser cette méthode lorsque size est négatif, car la plupart des autres méthodes de Godot supposent que les composants de size sont supérieurs à 0.

bool encloses(with: AABB) const 🔗

Renvoie true si cette boîte délimitante encadre complètement la boîte with. Les bords des deux boîtes sont inclus.

var a = AABB(Vector3(0, 0, 0), Vector3(4, 4, 4))
var b = AABB(Vector3(1, 1, 1), Vector3(3, 3, 3))
c = AABB(Vector3(2, 2, 2), Vector3(8, 8, 8))

print(a.encloses(a)) # Affiche true
print(a.encloses(b)) # Affiche true
print(a.encloses(c)) # Affiche false

var a = new Aabb(new Vector3(0, 0, 0), new Vector3(4, 4, 4));
var b = new Aabb(nouveau Vector3(1, 1, 1), new Vector3(3, 3, 3));
c = new Aabb(nouveau Vector3(2, 2, 2), new Vector3(8, 8, 8));

GD.Print(a.Encloses(a)); // Affiche True
GD.Print(a.Encloses(b)); // Affiche True
GD.Print(a.Encloses(c)); // Affiche False

AABB expand(to_point: Vector3) const 🔗

Renvoie une copie de cette boîte délimitante élargie pour aligner les bords avec le point to_point donné, si nécessaire.

var boite = AABB(Vector3(0, 0, 0), Vector3(5, 2, 5))

boite = boite.expand(Vector3(10, 0, 0))
print(boite.position) # Affiche (0.0, 0.0, 0.0)
print(boite.size) # Affiche (10, 2,0, 5.0)

boite = boite.expand(Vector3(-5, 0, 5))
print(-5.0, 0.0, 0.0)
print(boite.size) # Affiche (15,0, 2.0, 5.0)

var boite = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 5));

boite = boite.Expand(new Vector3(10, 0, 0));
GD.Print(boite.Position); // Prints (0, 0, 0)
GD.Print(boite.Size); // Prints (10, 2, 5)

boite= boite.Expand(new Vector3(-5, 0, 5));
GD.Print(boite.Position); // Affiche (-5, 0, 0)
GD.Print(boite.Size); // Affiche (15, 2, 5)

Vector3 get_center() const 🔗

Renvoie le point central de la boîte délimitante. Cela revient à position + (size / 2.0).

Vector3 get_endpoint(idx: int) const 🔗

Renvoie la position de l'un des 8 sommets qui composent cette boîte délimitante. Avec un index idx de 0, cela revient à position, et un idx de 7 revient à end.

Vector3 get_longest_axis() const 🔗

Renvoie l'axe normalisé le plus long du size de la boîte délimitante, en tant que Vector3 (Vector3.RIGHT, Vector3.UP, ou Vector3.BACK).

var boite = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))

print(boite.get_longest_axis())       # Affiche (0.0, 0.0, 1.0)
print(boite.get_longest_axis_index()) # Affiche 2
print(boite.get_longest_axis_size())  # Affiche 8.0

var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));

GD.Print(box.GetLongestAxis());      // Affiche (0, 0, 1)
GD.Print(box.GetLongestAxisIndex()); // Affiche Z
GD.Print(box.GetLongestAxisSize());  // Affiche 8

Voir aussi get_longest_axis_index() et get_longest_axis_size().

int get_longest_axis_index() const 🔗

Renvoie l'index de l'axe le plus long de la taille size de cette boîte (voir Vector3.AXIS_X, Vector3.AXIS_Y, et Vector3.AXIS_Z).

Pour un exemple, voir get_longest_axis().

float get_longest_axis_size() const 🔗

Renvoie la dimension la plus longue de la taille size de cette boîte délimitante.

Pour un exemple, voir get_longest_axis().

Vector3 get_shortest_axis() const 🔗

Renvoie l'axe normalisé le plus court de la taille size de cette boîte de délimitation, en tant que Vector3 (Vector3.RIGHT, Vector3.UP, ou Vector3.BACK).

var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))

print(box.get_shortest_axis())       # Affiche (1.0, 0.0, 1.0)
print(box.get_shortest_axis_index()) # Affiche 0
print(box.get_shortest_axis_size())  # Affiche 2.0

var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));

GD.Print(box.GetShortestAxis());      // Affiche (1, 0, 0)
GD.Print(box.GetShortestAxisIndex()); // Affiche X
GD.Print(box.GetShortestAxisSize());  // Affiche 2

Voir aussi get_shortest_axis_index() et get_shortest_axis_size().

int get_shortest_axis_index() const 🔗

Renvoie l'index de l'axe le plus court de la taille size de cette boîte (voir Vector3.AXIS_X, Vector3.AXIS_Y, et Vector3.AXIS_Z).

Pour un exemple, voir get_shortest_axis().

float get_shortest_axis_size() const 🔗

Renvoie la dimension la plus courte de la taille size de cette boîte délimitante.

Pour un exemple, voir get_shortest_axis().

Vector3 get_support(direction: Vector3) const 🔗

Renvoie la position du sommet de cette boîte délimitante qui est le plus éloigné dans la direction donnée. Ce point est communément connu comme le point de support dans les algorithmes de détection de collision.

float get_volume() const 🔗

Renvoie le volume de la boîte délimitante. Cela revient à size.x * size.y * size.z. Voir aussi has_volume().

AABB grow(by: float) const 🔗

Renvoie une copie de cette boîte délimitante étendue sur tous les côtés par la quantité by donnée. Une quantité négative rétrécit la boîte à la place.

var a = AABB(Vector3(4, 4, 4), Vector3(8, 8, 8)).grow(4)
print(a.position) # Affiche (0.0, 0.0, 0.0)
print(a.size)     # Affiche (16.0, 16.0, 16.0)

var b = AABB(Vector3(0, 0, 0), Vector3(8, 4, 2)).grow(2)
print(b.position) # Affiche (-2.0, -2.0, -2.0)
print(b.size)     # Affiche (12.0, 8.0, 6.0)

var a = new Aabb(new Vector3(4, 4, 4), new Vector3(8, 8, 8)).Grow(4);
GD.Print(a.Position); // Affiche (0, 0, 0)
GD.Print(a.Size); // Affiche (16, 16, 16)

var b = new Aabb(new Vector3(0, 0, 0), new Vector3(8, 4, 2)).Grow(2);
GD.Print(b.Position); // Affiche (-2, -2, -2)
GD.Print(b.Size); // Affiche (12, 8, 6)

bool has_point(point: Vector3) const 🔗

Renvoie true si la boîte délimitante contient le point donné. Par convention, les points exactement sur la droite, le dessus et les côtés avant ne sont pas inclus.

Note : Cette méthode n'est pas fiable pour les AABB avec une taille size négative. Utilisez abs() d'abord pour obtenir une boîte délimitante valide.

bool has_surface() const 🔗

Renvoie true si cette boîte délimitante a une surface ou une longueur, c'est-à-dire qu'au moins une composante de size est supérieure à 0. Sinon, renvoie false.

bool has_volume() const 🔗

Renvoie true si la largeur, la hauteur et la profondeur de cette boîte délimitante sont toutes positives. Voir aussi get_volume().

AABB intersection(with: AABB) const 🔗

Renvoie l'intersection entre cette boîte délimitante et with. Si les boîtes ne s'intersectent pas, renvoie une AABB vide. Si les boîtes se croisent sur le bord, renvoie une AABB plate sans volume (voir has_surface() et has_volume()).

var boite1 = AABB(Vector3(0, 0, 0), Vector3(5, 2, 8))
var boite2 = AABB(Vector3(2, 0, 2), Vector3(8, 4, 4))

var intersection = boite1.intersection(boite2)
print(intersection.position) # Affiche (2.0, 0.0, 2.0)
print(intersection.size)     # Affiche (3.0, 2.0, 4.0)

var boite1 = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 8));
var boite 2= new Aabb(new Vector3(2, 0, 2), new Vector3(8, 4, 4));

var intersection = boite1.Intersection(boite2);
GD.Print(intersection.Position); // Affiche (2, 0, 2)
GD.Print(intersection.Size);     // Affiche(3, 2, 4)

Note : Si vous avez besoin de savoir uniquement si deux boîtes délimitantes s'intersectent, utilisez intersects() à la place.

bool intersects(with: AABB) const 🔗

Renvoie true si cette boîte délimitante chevauche la boîte with. Les bords des deux boîtes sont toujours exclus.

bool intersects_plane(plane: Plane) const 🔗

Renvoie true si cette boîte délimitante est des deux côtés du plan plane donné.

Variant intersects_ray(from: Vector3, dir: Vector3) const 🔗

Renvoie le premier point où cette boîte délimitante et le rayon donné s'intersectent, en tant que Vector3. Si aucune intersection ne se produit, renvoie null.

Le rayon commence à from, a comme direction dir et s'étend vers l'infini.

Variant intersects_segment(from: Vector3, to: Vector3) const 🔗

Renvoie le premier point où cette boîte délimitante et le segment donné s'intersectent, en tant que Vector3. Si aucune intersection ne se produit, renvoie null.

Le segment commence au point from et se termine au point to.

bool is_equal_approx(aabb: AABB) const 🔗

Renvoie true si cette boîte délimitante et aabb sont approximativement égaux, en appelant Vector3.is_equal_approx() sur la position et la taille size.

bool is_finite() const 🔗

Renvoie true si les valeurs de cette boîte délimitante sont finies, en appelant Vector3.is_finite() sur position et size.

AABB merge(with: AABB) const 🔗

Renvoie une AABB qui contient à la fois cette boîte délimitante et with autour des bords. Voir aussi encloses().

Descriptions des opérateurs

bool operator !=(right: AABB) 🔗

Renvoie true si la position ou la taille size des deux boîtes de délimitation ne sont pas égales.

Note : À cause des erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() à la place, qui est plus fiable.

AABB operator *(right: Transform3D) 🔗

Transforme (multiplie) de manière inverse la AABB par la matrice de transformation Transform3D donnée, avec la supposition que la base de la transformation est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).

aabb * transform est équivalent à transform.inverse() * aabb. Voir Transform3D.inverse().

Pour transformer par l'inverse d'une transformation affine (par ex. avec une mise à l'échelle), transform.affine_inverse() * rect peut être utilisé à la place. Voir Transform3D.affine_inverse().

bool operator ==(right: AABB) 🔗

Renvoie true si position et size des boîtes délimitantes sont tous les deux exactement égaux, respectivement.

Note : En raison d'erreurs de précision flottante, envisagez d'utiliser is_equal_approx() à la place, qui est plus fiable.