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
Una bounding box 3D allineata agli assi.
Descrizione
Il tipo di Variant integrato AABB rappresenta una bounding box allineata agli assi in uno spazio 3D. È definito dalla sua posizione (position) e dimensioni (size), che sono Vector3. È spesso utilizzato per fare test rapidi di sovrapposizione (vedi intersects()). Nonostante AABB sia allineato agli assi, può essere combinato con Transform3D per rappresentare una bounding box ruotata o inclinata.
Utilizza coordinate in virgola mobile. La controparte 2D a AABB è Rect2. Non esiste una versione di AABB che utilizza coordinate intere.
Nota: I valori negativi per size non sono supportati. Con dimensioni negative, la maggior parte dei metodi AABB non funzionano correttamente. Utilizza abs() per ottenere un AABB equivalente con una dimensione non negativa.
Nota: In un contesto booleano, un AABB è valutato come false se sia position sia size sono zero (pari a Vector3.ZERO). Altrimenti, è sempre valutato come true.
Nota
Ci sono differenze sostanziali quando si usa questa API con C#. Vedi Differenze dell'API C# rispetto a GDScript per maggiori informazioni.
Tutorial
Proprietà
|
||
|
||
|
Costruttori
AABB() |
|
Metodi
abs() const |
|
get_center() const |
|
get_endpoint(idx: int) const |
|
get_longest_axis() const |
|
get_longest_axis_index() const |
|
get_longest_axis_size() const |
|
get_shortest_axis() const |
|
get_shortest_axis_index() const |
|
get_shortest_axis_size() const |
|
get_support(direction: Vector3) const |
|
get_volume() const |
|
has_surface() const |
|
has_volume() const |
|
intersection(with: AABB) const |
|
intersects(with: AABB) const |
|
intersects_plane(plane: Plane) const |
|
intersects_ray(from: Vector3, dir: Vector3) const |
|
intersects_segment(from: Vector3, to: Vector3) const |
|
is_equal_approx(aabb: AABB) const |
|
is_finite() const |
|
Operatori
operator !=(right: AABB) |
|
operator *(right: Transform3D) |
|
operator ==(right: AABB) |
Descrizioni delle proprietà
Vector3 end = Vector3(0, 0, 0) 🔗
Il punto di fine. Questo è di solito lo spigolo in alto a destra e sul retro della bounding box, ed è equivalente a position + size. Impostare questo punto influisce su size.
Vector3 position = Vector3(0, 0, 0) 🔗
Il punto di origine. Questo è di solito lo spigolo in basso a sinistra e in avanti della bounding box.
Vector3 size = Vector3(0, 0, 0) 🔗
La larghezza, l'altezza e la profondità della bounding box a partire da position. Impostare questo valore influisce anche sul punto end.
Nota: Si raccomanda di impostare la larghezza, l'altezza e la profondità a valori non negativi. Questo perché la maggior parte dei metodi in Godot presumono che position sia lo spigolo in basso a sinistra anteriore, e che end sia lo spigolo in alto a destra posteriore. Per ottenere una bounding box con dimensioni non negative, utilizza abs().
Descrizioni dei costruttori
Costruisce un AABB con la sua posizione (position) e dimensioni (size) impostate a Vector3.ZERO.
Costruisce un AABB come copia dell'AABB specificato.
AABB AABB(position: Vector3, size: Vector3)
Costruisce un AABB dalla posizione (position) e dimensioni (size).
Descrizioni dei metodi
Restituisce un AABB equivalente a questa bounding box, con la sua larghezza, altezza e profondità modificate per essere valori non negativi.
var box = AABB(Vector3(5, 0, 5), Vector3(-20, -10, -5))
var absolute = box.abs()
print(absolute.position) # Stampa (-15.0, -10.0, 0.0)
print(absolute.size) # Stampa (20.0, 10.0, 5.0)
var box = new Aabb(new Vector3(5, 0, 5), new Vector3(-20, -10, -5));
var absolute = box.Abs();
GD.Print(absolute.Position); // Stampa (-15, -10, 0)
GD.Print(absolute.Size); // Stampa (20, 10, 5)
Nota: Si consiglia di utilizzare questo metodo quando size è negativo, poiché la maggior parte degli altri metodi in Godot presumono che i componenti di size sono maggiori di 0.
bool encloses(with: AABB) const 🔗
Restituisce true se questa bounding box racchiude completamente la bounding box with. I bordi di entrambe i box sono inclusi.
var a = AABB(Vector3(0, 0, 0), Vector3(4, 4, 4))
var b = AABB(Vector3(1, 1, 1), Vector3(3, 3, 3))
var c = AABB(Vector3(2, 2, 2), Vector3(8, 8, 8))
print(a.encloses(a)) # Stampa true
print(a.encloses(b)) # Stampa true
print(a.encloses(c)) # Stampa false
var a = new Aabb(new Vector3(0, 0, 0), new Vector3(4, 4, 4));
var b = new Aabb(new Vector3(1, 1, 1), new Vector3(3, 3, 3));
var c = new Aabb(new Vector3(2, 2, 2), new Vector3(8, 8, 8));
GD.Print(a.Encloses(a)); // Stampa True
GD.Print(a.Encloses(b)); // Stampa True
GD.Print(a.Encloses(c)); // Stampa False
AABB expand(to_point: Vector3) const 🔗
Restituisce una copia di questa bounding box espansa per allineare i bordi con il punto to_point specificato, se necessario.
var box = AABB(Vector3(0, 0, 0), Vector3(5, 2, 5))
box = box.expand(Vector3(10, 0, 0))
print(box.position) # Stampa (0.0, 0.0, 0.0)
print(box.size) # Stampa (10.0, 2.0, 5.0)
box = box.expand(Vector3(-5, 0, 5))
print(box.position) # Stampa (-5.0, 0.0, 0.0)
print(box.size) # Stampa (15.0, 2.0, 5.0)
var box = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 5));
box = box.Expand(new Vector3(10, 0, 0));
GD.Print(box.Position); // Stampa (0, 0, 0)
GD.Print(box.Size); // Stampa (10, 2, 5)
box = box.Expand(new Vector3(-5, 0, 5));
GD.Print(box.Position); // Stampa (-5, 0, 0)
GD.Print(box.Size); // Stampa (15, 2, 5)
Restituisce il punto centrale della bounding box. Questo è equivalente a position + (size / 2.0).
Vector3 get_endpoint(idx: int) const 🔗
Restituisce la posizione di uno degli 8 vertici che compongono questa bounding box. Con un idx di 0 è la stessa di position, e un idx di 7 è la stessa di end.
Vector3 get_longest_axis() const 🔗
Restituisce l'asse normalizzato più lungo di size di questa bounding box, come Vector3 (Vector3.RIGHT, Vector3.UP o Vector3.BACK).
var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))
print(box.get_longest_axis()) # Stampa (0.0, 0.0, 1.0)
print(box.get_longest_axis_index()) # Stampa 2
print(box.get_longest_axis_size()) # Stampa 8.0
var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));
GD.Print(box.GetLongestAxis()); // Stampa (0, 0, 1)
GD.Print(box.GetLongestAxisIndex()); // Stampa Z
GD.Print(box.GetLongestAxisSize()); // Stampa 8
Vedi anche get_longest_axis_index() e get_longest_axis_size().
int get_longest_axis_index() const 🔗
Restituisce l'indice dell'asse più lungo di questa bounding box (vedi Vector3.AXIS_X, Vector3.AXIS_Y, e Vector3.AXIS_Z).
Per un esempio, vedi get_longest_axis().
float get_longest_axis_size() const 🔗
Restituisce la dimensione più lunga di size di questa bounding box.
Per un esempio, vedi get_longest_axis().
Vector3 get_shortest_axis() const 🔗
Restituisce l'asse normalizzato più corto di size di questa bounding box, come Vector3 (Vector3.RIGHT, Vector3.UP o Vector3.BACK).
var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))
print(box.get_shortest_axis()) # Stampa (1.0, 0.0, 0.0)
print(box.get_shortest_axis_index()) # Stampa 0
print(box.get_shortest_axis_size()) # Stampa 2
var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));
GD.Print(box.GetShortestAxis()); // Stampa (1, 0, 0)
GD.Print(box.GetShortestAxisIndex()); // Stampa X
GD.Print(box.GetShortestAxisSize()); // Stampa 2
Vedi anche get_shortest_axis_index() e get_shortest_axis_size().
int get_shortest_axis_index() const 🔗
Restituisce l'indice dell'asse più corto di questa bounding box (vedi Vector3.AXIS_X, Vector3.AXIS_Y, e Vector3.AXIS_Z).
Per un esempio, vedi get_shortest_axis().
float get_shortest_axis_size() const 🔗
Restituisce la dimensione più corta di size di questa bounding box.
Per un esempio, vedi get_shortest_axis().
Vector3 get_support(direction: Vector3) const 🔗
Restituisce la posizione del vertice di questa bounding box che è il più lontano nella direzione fornita. Questo punto è comunemente noto come punto di supporto negli algoritmi di rilevamento delle collisioni.
Restituisce il volume della bounding box. Questo è equivalente a size.x * size.y * size.z. Vedi anche has_volume().
Restituisce una copia di questa bounding box estesa su tutti i lati dalla quantità fornita (by). Una quantità negativa invece restringe il box.
var a = AABB(Vector3(4, 4, 4), Vector3(8, 8, 8)).grow(4)
print(a.position) # Stampa (0.0, 0.0, 0.0)
print(a.size) # Stampa (16.0, 16.0, 16.0)
var b = AABB(Vector3(0, 0, 0), Vector3(8, 4, 2)).grow(2)
print(b.position) # Stampa (-2.0, -2.0, -2.0)
print(b.size) # Stampa (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); // Stampa (0, 0, 0)
GD.Print(a.Size); // Stampa (16, 16, 16)
var b = new Aabb(new Vector3(0, 0, 0), new Vector3(8, 4, 2)).Grow(2);
GD.Print(b.Position); // Stampa (-2, -2, -2)
GD.Print(b.Size); // Stampa (12, 8, 6)
bool has_point(point: Vector3) const 🔗
Restituisce true se la bounding box contiene il punto point. Per convenzione, i punti esattamente sul lato destro, superiore, e anteriore non sono inclusi.
Nota: Questo metodo non è affidabile per un AABB con un size negativo. Utilizza prima abs() per ottenere una bounding box valida.
Restituisce true se questa bounding box ha una superfice o una lunghezza, ovvero almeno uno dei componenti di size è maggiore di 0. Altrimenti, restituisce false.
Restituisce true se la lunghezza, l'altezza, e la profondità di questa bounding box sono tutti positivi. Vedi anche get_volume().
AABB intersection(with: AABB) const 🔗
Restituisce l'intersezione tra questa bounding box e with. Se i box non si intersecano, restituisce un AABB vuoto. Se i box si intersecano al bordo, restituisce un AABB piatto senza volume (vedi has_surface() e has_volume()).
var box1 = AABB(Vector3(0, 0, 0), Vector3(5, 2, 8))
var box2 = AABB(Vector3(2, 0, 2), Vector3(8, 4, 4))
var intersection = box1.intersection(box2)
print(intersection.position) # Stampa (2.0, 0.0, 2.0)
print(intersection.size) # Stampa (3.0, 2.0, 4.0)
var box1 = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 8));
var box2 = new Aabb(new Vector3(2, 0, 2), new Vector3(8, 4, 4));
var intersection = box1.Intersection(box2);
GD.Print(intersection.Position); // Stampa (2, 0, 2)
GD.Print(intersection.Size); // Stampa (3, 2, 4)
Nota: Se hai solo bisogno di sapere se due bounding box sono intersecanti, utilizza intersects(), invece.
bool intersects(with: AABB) const 🔗
Restituisce true se questa bounding box si sovrappone con quella with. I lati di entrambe le bounding box sono sempre esclusi.
bool intersects_plane(plane: Plane) const 🔗
Restituisce true se questa bounding box è su entrambi i lati del piano plane.
Variant intersects_ray(from: Vector3, dir: Vector3) const 🔗
Restituisce il primo punto in cui questa bounding box e il raggio fornito si intersecano, come Vector3. Se non si verifica alcuna intersezione, restituisce null.
Il raggio comincia da from, guarda verso la direzione dir e si estende verso l'infinito.
Variant intersects_segment(from: Vector3, to: Vector3) const 🔗
Restituisce il primo punto in cui questa bounding box e il segmento fornito si intersecano, come Vector3. Se non si verifica alcuna intersezione, restituisce null.
Il raggio comincia da from, e finisce a to.
bool is_equal_approx(aabb: AABB) const 🔗
Restituisce true se questa bounding box e aabb sono approssimativamente eguali, chiamando Vector3.is_equal_approx() su position e size.
Restituisce true se i valori di questa bounding box sono finiti, chiamando Vector3.is_finite() su position e size.
AABB merge(with: AABB) const 🔗
Restituisce un AABB che racchiude sia questa bounding box sia with intorno ai bordi. Vedi anche encloses().
Descrizioni degli operatori
bool operator !=(right: AABB) 🔗
Restituisce true se position e size di entrambe le bounding box non sono eguali.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
AABB operator *(right: Transform3D) 🔗
Trasforma (moltiplica) inversamente l'AABB dalla matrice di trasformazione Transform3D fornita, presupponendo che la base di trasformazione sia ortonormale (ovvero rotazione/riflessione vanno bene, ma scala/distorsione no).
abb * Transform è equivalente a transform.inverse() * aabb. Vedi Transform3D.inverse().
Per trasformare dall'inverso di una trasformazione affine (ad esempio con scala) transform.affine_inverse() * aabb può essere invece utilizzato. Vedi Transform3D.affine_inverse().
bool operator ==(right: AABB) 🔗
Restituisce true se sia position sia size delle bounding box sono esattamente eguali.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.