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...
Geometry2D
Eredita: Object
Fornisce metodi per alcune operazioni geometriche 2D comuni.
Descrizione
Fornisce una serie di funzioni di supporto per creare forme geometriche, calcolare intersezioni tra forme ed elaborare varie altre operazioni geometriche in 2D.
Metodi
Enumerazioni
enum PolyBooleanOperation: 🔗
PolyBooleanOperation OPERATION_UNION = 0
Crea regioni in cui sono riempiti i poligoni del soggetto o del ritaglio (o entrambi).
PolyBooleanOperation OPERATION_DIFFERENCE = 1
Crea regioni in cui i poligoni del soggetto sono riempiti, ad eccezione delle aree in cui sono riempiti i poligoni di ritaglio.
PolyBooleanOperation OPERATION_INTERSECTION = 2
Crea regioni in cui sono riempiti sia i poligoni del soggetto sia quelli del ritaglio.
PolyBooleanOperation OPERATION_XOR = 3
Crea regioni in cui sono riempiti i poligoni del soggetto o del ritaglio, ma non dove sono riempiti entrambi.
enum PolyJoinType: 🔗
PolyJoinType JOIN_SQUARE = 0
La quadratura si applica uniformemente a tutte le unioni di spigoli convessi in 1 * delta.
PolyJoinType JOIN_ROUND = 1
Sebbene i percorsi appiattiti non possano mai tracciare perfettamente un arco, sono approssimati da una serie di corde d'arco.
PolyJoinType JOIN_MITER = 2
Esiste un limite necessario alle unioni squadrate, in quanto lo scostamento degli spigoli che si uniscono ad angoli molto acuti produrrà "punte" eccessivamente lunghe e strette. Per qualsiasi unione di spigoli, quando lo scostamento squadrato supererebbe quella distanza massima, si applica l'unione "quadrata".
enum PolyEndType: 🔗
PolyEndType END_POLYGON = 0
Le estremità si uniscono utilizzando il valore PolyJoinType e il percorso viene riempito come un poligono.
PolyEndType END_JOINED = 1
Le estremità si uniscono utilizzando il valore PolyJoinType e il percorso viene riempito come una polilinea.
PolyEndType END_BUTT = 2
Le estremità vengono quadrate senza essere allungate.
PolyEndType END_SQUARE = 3
Le estremità saranno quadrate e allungate di delta unità.
PolyEndType END_ROUND = 4
Le estremità saranno arrotondate e allungate di delta unità.
Descrizioni dei metodi
Array[Vector2i] bresenham_line(from: Vector2i, to: Vector2i) 🔗
Restituisce la linea di Bresenham tra i punti from e to. Una linea di Bresenham è una serie di pixel che disegna una linea ed è sempre spessa 1 pixel su ogni riga e colonna del disegno (mai di più, mai di meno).
Codice di esempio per disegnare una linea tra due nodi Marker2D utilizzando una serie di chiamate a CanvasItem.draw_rect():
func _draw():
for pixel in Geometry2D.bresenham_line($MarkerA.position, $MarkerB.position):
draw_rect(Rect2(pixel, Vector2.ONE), Color.WHITE)
Array[PackedVector2Array] clip_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Ritaglia polygon_a rispetto a polygon_b e restituisce un array di poligoni ritagliati. Questo esegue OPERATION_DIFFERENCE tra i poligoni. Restituisce un array vuoto se polygon_b si sovrappone completamente a polygon_a.
Se polygon_b è racchiuso da polygon_a, restituisce un poligono esterno (confine) e un poligono interno (buco) che si potrebbero distinguere chiamando is_polygon_clockwise().
Array[PackedVector2Array] clip_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Ritaglia polyline rispetto a polygon e restituisce un array di polilinee ritagliate. Questo esegue OPERATION_DIFFERENCE tra la polilinea e il poligono. Questa operazione può essere pensata come il taglio di una linea con una forma chiusa.
PackedVector2Array convex_hull(points: PackedVector2Array) 🔗
Fornito un array di Vector2, restituisce l'hull convesso come una lista di punti in ordine antiorario. L'ultimo punto è uguale al primo.
Array[PackedVector2Array] decompose_polygon_in_convex(polygon: PackedVector2Array) 🔗
Decompone il poligono polygon in più hull convessi e restituisce un array di PackedVector2Array.
Array[PackedVector2Array] exclude_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Esclude reciprocamente l'area comune definita dall'intersezione di polygon_a e polygon_b (vedi intersect_polygons()) e restituisce un array di poligoni esclusi. Questo esegue OPERATION_XOR tra i poligoni. In altre parole, restituisce tutto tranne l'area comune tra i poligoni.
L'operazione potrebbe produrre un poligono esterno (confine) e un poligono interno (buco) che si possono distinguere chiamando is_polygon_clockwise().
Vector2 get_closest_point_to_segment(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Restituisce il punto 2D sul segmento 2D (s1, s2) che è più vicino a point. Il punto restituito sarà sempre all'interno del segmento specificato.
Vector2 get_closest_point_to_segment_uncapped(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Restituisce il punto 2D sulla linea 2D definita da (s1, s2) che è più vicino a point. Il punto restituito può essere all'interno del segmento (s1, s2) o all'esterno di esso, ovvero da qualche parte sulla linea che si estende dal segmento.
PackedVector2Array get_closest_points_between_segments(p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2) 🔗
Forniti i due segmenti 2D (p1, q1) e (p2, q2), trova quei due punti sui due segmenti più vicini tra loro. Restituisce un PackedVector2Array che contiene questo punto su (p1, q1) e il punto corrispondente su (p2, q2).
Array[PackedVector2Array] intersect_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Interseca polygon_a con polygon_b e restituisce un array di poligoni intersecati. Questo esegue OPERATION_INTERSECTION tra i poligoni. In altre parole, restituisce l'area comune condivisa dai poligoni. Restituisce un array vuoto se non si verifica alcuna intersezione.
L'operazione potrebbe produrre un poligono esterno (confine) e un poligono interno (buco) che si possono distinguere chiamando is_polygon_clockwise().
Array[PackedVector2Array] intersect_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Interseca polyline con polygon e restituisce un array di polilinee intersecate. Questo esegue OPERATION_INTERSECTION tra la polilinea e il poligono. Questa operazione può essere pensata come il taglio di una linea con una forma chiusa.
bool is_point_in_circle(point: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Restituisce true se il punto point è all'interno del cerchio o se si trova esattamente sul confine del cerchio, altrimenti restituisce false.
bool is_point_in_polygon(point: Vector2, polygon: PackedVector2Array) 🔗
Restituisce true se il punto point è all'interno del poligono (polygon) o se è locato esattamente sul bordo del poligono, altrimenti restituisce false.
bool is_polygon_clockwise(polygon: PackedVector2Array) 🔗
Restituisce true se i vertici di polygon sono ordinati in senso orario, altrimenti restituisce false.
Nota: Suppone un sistema di coordinate cartesiane in cui +x punta a destra e +y punta in alto. Se si utilizzano le coordinate dello schermo (+y è verso il basso), il risultato dovrà essere capovolto (vale a dire che un risultato true indicherà il senso antiorario).
Variant line_intersects_line(from_a: Vector2, dir_a: Vector2, from_b: Vector2, dir_b: Vector2) 🔗
Returns the point of intersection between the two lines (from_a, dir_a) and (from_b, dir_b). Returns a Vector2, or null if the lines are parallel.
from and dir are not endpoints of a line segment or ray but the slope (dir) and a known point (from) on that line. To get the intersection between two line segments, use segment_intersects_segment().
var from_a = Vector2.ZERO
var dir_a = Vector2.RIGHT
var from_b = Vector2.DOWN
# Returns Vector2(1, 0)
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(1, -1))
# Returns Vector2(-1, 0)
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(-1, -1))
# Returns null
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2.RIGHT)
var fromA = Vector2.Zero;
var dirA = Vector2.Right;
var fromB = Vector2.Down;
// Returns new Vector2(1, 0)
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(1, -1));
// Returns new Vector2(-1, 0)
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(-1, -1));
// Returns null
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, Vector2.Right);
Dictionary make_atlas(sizes: PackedVector2Array) 🔗
Fornito un array di Vector2 che rappresentano tile, crea un atlante. Il dizionario restituito ha due chiavi: points è un PackedVector2Array che specifica le posizioni di ogni tile, size contiene le dimensioni complessive dell'intero atlante come Vector2i.
Array[PackedVector2Array] merge_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Unisce (combina) polygon_a e polygon_b e restituisce un array di poligoni uniti. Questo esegue OPERATION_UNION tra i poligoni.
L'operazione potrebbe produrre un poligono esterno (confine) e molteplici poligoni interni (buchi) che si possono distinguere chiamando is_polygon_clockwise().
Array[PackedVector2Array] offset_polygon(polygon: PackedVector2Array, delta: float, join_type: PolyJoinType = 0) 🔗
Gonfia o sgonfia il poligono polygon di delta unità (pixel). Se delta è positivo, fa crescere il poligono verso l'esterno. Se delta è negativo, rimpicciolisce il poligono verso l'interno. Restituisce un array di poligoni perché il gonfiaggio/sgonfiaggio potrebbe produrre più poligoni discreti. Restituisce un array vuoto se delta è negativo e il suo valore assoluto supera approssimativamente le dimensioni minime del rettangolo di delimitazione del poligono.
I vertici di ogni poligono saranno arrotondati come determinato da join_type.
L'operazione potrebbe produrre un poligono esterno (confine) e un poligono interno (buco) che si possono distinguere chiamando is_polygon_clockwise().
Nota: Per traslare in modo specifico i vertici del poligono, moltiplicali per un Transform2D:
var polygon = PackedVector2Array([Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)])
var offset = Vector2(50, 50)
polygon = Transform2D(0, offset) * polygon
print(polygon) # Stampa [(50.0, 50.0), (150.0, 50.0), (150.0, 150.0), (50.0, 150.0)]
var polygon = new Vector2[] { new Vector2(0, 0), new Vector2(100, 0), new Vector2(100, 100), new Vector2(0, 100) };
var offset = new Vector2(50, 50);
polygon = new Transform2D(0, offset) * polygon;
GD.Print((Variant)polygon); // Stampa [(50, 50), (150, 50), (150, 150), (50, 150)]
Array[PackedVector2Array] offset_polyline(polyline: PackedVector2Array, delta: float, join_type: PolyJoinType = 0, end_type: PolyEndType = 3) 🔗
Gonfia o sgonfia la polilinea polyline di delta unità (pixel), producendo poligoni. Se delta è positivo, fa crescere la polilinea verso l'esterno. Restituisce un array di poligoni perché il gonfiaggio/sgonfiaggio potrebbe produrre più poligoni discreti. Se delta è negativo, restituisce un array vuoto.
I vertici di ogni poligono saranno arrotondati come definito da join_type.
I punti finali di ogni poligono saranno arrotondati come definito da end_type.
L'operazione potrebbe produrre un poligono esterno (confine) e un poligono interno (buco) che si possono distinguere chiamando is_polygon_clockwise().
bool point_is_inside_triangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2) const 🔗
Restituisce se il punto point si trova all'interno del triangolo specificato da a, b e c.
float segment_intersects_circle(segment_from: Vector2, segment_to: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Dato il segmento 2D (segment_from, segment_to), restituisce la posizione sul segmento (come numero compreso tra 0 e 1) in cui il segmento tocca il cerchio che si trova nella posizione circle_position e ha raggio circle_radius. Se il segmento non interseca il cerchio, viene restituito -1 (questo vale anche se la linea che estende il segmento interseca il cerchio, ma il segmento no).
Variant segment_intersects_segment(from_a: Vector2, to_a: Vector2, from_b: Vector2, to_b: Vector2) 🔗
Verifica se due segmenti di linea si intersecano, con la linea a tra from_a e to_a e la linea b tra from_b e to_b. Se i segmenti si intersecano, il punto di intersezione è restituito come Vector2. Se non c'è alcuna intersezione, è restituito null.
PackedInt32Array triangulate_delaunay(points: PackedVector2Array) 🔗
Triangola l'area specificata da una serie discreta di punti (points) in modo che nessun punto sia all'interno del cerchio circoscritto di alcun triangolo risultante. Restituisce un PackedInt32Array in cui ogni triangolo è composto da tre indici di punti consecutivi in points (ad esempio, l'array restituito avrà n * 3 elementi, con n come numero di triangoli trovati). Se la triangolazione non è riuscita, viene restituito un PackedInt32Array vuoto.
PackedInt32Array triangulate_polygon(polygon: PackedVector2Array) 🔗
Triangola il poligono specificato dai punti in polygon. Restituisce un PackedInt32Array in cui ogni triangolo è composto da tre indici di punti consecutivi in polygon (ad esempio, l'array restituito avrà n * 3 elementi, con n come numero di triangoli trovati). I triangoli risultanti saranno sempre in senso antiorario e il contorno verrà invertito se è in senso orario. Se la triangolazione non è riuscita, viene restituito un PackedInt32Array vuoto.