Geometry2D
Hereda: Object
Proporciona métodos para algunas operaciones geométricas 2D comunes.
Descripción
Proporciona un conjunto de funciones de ayuda para crear formas geométricas, calcular intersecciones entre formas y procesar varias otras operaciones geométricas en 2D.
Métodos
Enumeraciones
enum PolyBooleanOperation: 🔗
PolyBooleanOperation OPERATION_UNION = 0
Crear regiones en las que se llenen los polígonos del sujeto o del recorte (o ambos).
PolyBooleanOperation OPERATION_DIFFERENCE = 1
Crea regiones en las que se rellenen los polígonos del sujeto, excepto cuando se rellenen los polígonos de clips.
PolyBooleanOperation OPERATION_INTERSECTION = 2
Crea regiones en las que se llenen tanto los polígonos del sujeto como los del recorte.
PolyBooleanOperation OPERATION_XOR = 3
Crea regiones en las que se llenen los polígonos del sujeto o del recorte pero no en las que se llenen ambos.
enum PolyJoinType: 🔗
PolyJoinType JOIN_SQUARE = 0
La cuadratura se aplica uniformemente en todas las uniones de bordes convexos en 1 * delta.
PolyJoinType JOIN_ROUND = 1
Mientras que los caminos aplanados nunca pueden trazar perfectamente un arco, son aproximados por una serie de acordes de arco.
PolyJoinType JOIN_MITER = 2
Hay un límite necesario para las uniones a inglete, ya que los bordes desplazados que se unen en ángulos muy agudos producirán "picos" excesivamente largos y estrechos. Para cualquier unión de borde, cuando la compensación de inglete exceda esa distancia máxima, se aplica la unión "cuadrada".
enum PolyEndType: 🔗
PolyEndType END_POLYGON = 0
Los puntos finales se unen usando el valor PolyJoinType y el camino llenado como un polígono.
PolyEndType END_JOINED = 1
Los puntos finales se unen usando el valor PolyJoinType y el camino llenado como una polilínea.
PolyEndType END_BUTT = 2
Los puntos finales son cuadrados sin extensión.
PolyEndType END_SQUARE = 3
Los puntos finales se cuadran y se amplían con unidades delta.
PolyEndType END_ROUND = 4
Los puntos finales se redondean y se amplían con unidades delta.
Descripciones de Métodos
Array[Vector2i] bresenham_line(from: Vector2i, to: Vector2i) 🔗
Devuelve la línea de Bresenham entre los puntos from y to. Una línea de Bresenham es una serie de píxeles que dibuja una línea y siempre tiene 1 píxel de grosor en cada fila y columna del dibujo (nunca más, nunca menos).
Código de ejemplo para dibujar una línea entre dos nodos Marker2D usando una serie de llamadas 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) 🔗
Recorta polygon_a contra polygon_b y devuelve un array de polígonos recortados. Esto realiza OPERATION_DIFFERENCE entre los polígonos. Devuelve un array vacío si polygon_b se superpone completamente a polygon_a.
Si polygon_b está encerrado por polygon_a, devuelve un polígono exterior (límite) y un polígono interior (agujero) que se pueden distinguir llamando a is_polygon_clockwise().
Array[PackedVector2Array] clip_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Recorta polyline contra polygon y devuelve un array de polilíneas recortadas. Esto realiza OPERATION_DIFFERENCE entre la polilínea y el polígono. Esta operación se puede considerar como cortar una línea con una forma cerrada.
PackedVector2Array convex_hull(points: PackedVector2Array) 🔗
Dado un conjunto de Vector2, devuelve el casco convexo como una lista de puntos en orden antihorario. El último punto es el mismo que el primero.
Array[PackedVector2Array] decompose_polygon_in_convex(polygon: PackedVector2Array) 🔗
Descompone el polygon en múltiples envolventes convexas y devuelve un array de PackedVector2Array.
Array[PackedVector2Array] exclude_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Excluye mutuamente el área común definida por la intersección de polygon_a y polygon_b (véase intersect_polygons()) y devuelve un array de polígonos excluidos. Esto realiza OPERATION_XOR entre polígonos. En otras palabras, devuelve todo excepto el área común entre los polígonos.
La operación puede dar como resultado un polígono exterior (límite) y un polígono interior (agujero) producidos que pueden distinguirse llamando a is_polygon_clockwise().
Vector2 get_closest_point_to_segment(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Devuelve el punto 2D en el segmento 2D (s1, s2) que está más cerca de point. El punto devuelto siempre estará dentro del segmento especificado.
Vector2 get_closest_point_to_segment_uncapped(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Devuelve el punto 2D en la línea 2D definida por (s1, s2) que está más cerca de point. El punto devuelto puede estar dentro del segmento (s1, s2) o fuera de él, es decir, en algún lugar de la línea que se extiende desde el segmento.
PackedVector2Array get_closest_points_between_segments(p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2) 🔗
Dados los dos segmentos 2D (p1, q1) y (p2, q2), encuentra esos dos puntos en los dos segmentos que están más cerca uno del otro. Devuelve un PackedVector2Array que contiene este punto en (p1, q1) así como el punto acompañante en (p2, q2).
Array[PackedVector2Array] intersect_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Interseca polygon_a con polygon_b y devuelve un array de polígonos intersecados. Esto realiza OPERATION_INTERSECTION entre los polígonos. En otras palabras, devuelve el área común compartida por los polígonos. Devuelve un array vacío si no se produce ninguna intersección.
La operación puede dar como resultado un polígono exterior (límite) y un polígono interior (agujero) producidos que se podrían distinguir llamando a is_polygon_clockwise().
Array[PackedVector2Array] intersect_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Interseca polyline con polygon y devuelve un array de polilíneas intersecadas. Esto realiza OPERATION_INTERSECTION entre la polilínea y el polígono. Esta operación puede ser pensada como cortar una línea con una forma cerrada.
bool is_point_in_circle(point: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Devuelve true si point está dentro del círculo o si está situado exactamente en el límite del círculo; de lo contrario, devuelve false.
bool is_point_in_polygon(point: Vector2, polygon: PackedVector2Array) 🔗
Devuelve true si point está dentro de polygon o si está situado exactamente en el límite del polígono; de lo contrario, devuelve false.
bool is_polygon_clockwise(polygon: PackedVector2Array) 🔗
Devuelve true si los vértices de polygon están ordenados en el sentido de las agujas del reloj, de lo contrario devuelve false.
Nota: Asume un sistema de coordenadas cartesianas donde +x está a la derecha y +y está arriba. Si usas coordenadas de pantalla (+y está abajo), el resultado tendrá que ser invertido (es decir, un resultado true indicará el sentido contrario a las agujas del reloj).
Variant line_intersects_line(from_a: Vector2, dir_a: Vector2, from_b: Vector2, dir_b: Vector2) 🔗
Devuelve el punto de intersección entre las dos líneas (from_a, dir_a) y (from_b, dir_b). Devuelve un Vector2, o null si las líneas son paralelas.
from y dir no son puntos finales de un segmento de línea o rayo, sino la pendiente (dir) y un punto conocido (from) en esa línea.
var from_a = Vector2.ZERO
var dir_a = Vector2.RIGHT
var from_b = Vector2.DOWN
# Devuelve Vector2(1, 0)
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(1, -1))
# Devuelve Vector2(-1, 0)
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(-1, -1))
# Devuelve 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;
// Devuelve new Vector2(1, 0)
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(1, -1));
// Devuelve new Vector2(-1, 0)
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(-1, -1));
// Devuelve null
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, Vector2.Right);
Dictionary make_atlas(sizes: PackedVector2Array) 🔗
Dado un array de Vector2s que representan tiles, construye un atlas. El diccionario devuelto tiene dos claves: points es un PackedVector2Array que especifica las posiciones de cada tile, size contiene el tamaño total del atlas como Vector2i.
Array[PackedVector2Array] merge_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Fusiona (combina) polygon_a y polygon_b y devuelve un array de polígonos fusionados. Esto realiza OPERATION_UNION entre los polígonos.
La operación puede dar como resultado un polígono exterior (límite) y múltiples polígonos interiores (agujeros) producidos que podrían distinguirse llamando a is_polygon_clockwise().
Array[PackedVector2Array] offset_polygon(polygon: PackedVector2Array, delta: float, join_type: PolyJoinType = 0) 🔗
Inflates or deflates polygon by delta units (pixels). If delta is positive, makes the polygon grow outward. If delta is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if delta is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon.
Each polygon's vertices will be rounded as determined by join_type.
The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling is_polygon_clockwise().
Note: To translate the polygon's vertices specifically, multiply them to a 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) # Prints [(50.0, 50.0), (150.0, 50.0), (150.0, 150.0), (50.0, 150.0)]
Vector2[] polygon = [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); // Prints [(50, 50), (150, 50), (150, 150), (50, 150)]
Array[PackedVector2Array] offset_polyline(polyline: PackedVector2Array, delta: float, join_type: PolyJoinType = 0, end_type: PolyEndType = 3) 🔗
Inflates or deflates polyline by delta units (pixels), producing polygons. If delta is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If delta is negative, returns an empty array.
Each polygon's vertices will be rounded as determined by join_type.
Each polygon's endpoints will be rounded as determined by end_type.
The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling is_polygon_clockwise().
bool point_is_inside_triangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2) const 🔗
Devuelve si point está dentro del triángulo especificado por a, b y c.
float segment_intersects_circle(segment_from: Vector2, segment_to: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Dado el segmento 2D (segment_from, segment_to), devuelve la posición en el segmento (como un número entre 0 y 1) en la que el segmento golpea el círculo que se encuentra en la posición circle_position y tiene un radio circle_radius. Si el segmento no interseca el círculo, se devuelve -1 (este también es el caso si la línea que extiende el segmento intersecara el círculo, pero el segmento no).
Variant segment_intersects_segment(from_a: Vector2, to_a: Vector2, from_b: Vector2, to_b: Vector2) 🔗
Comprueba si los dos segmentos (from_a, to_a) y (from_b, to_b) se intersecan. Si es así, devuelve el punto de intersección como Vector2. Si no hay intersección, devuelve null.
PackedInt32Array triangulate_delaunay(points: PackedVector2Array) 🔗
Triangula el área especificada por un conjunto discreto de points de tal manera que ningún punto está dentro del circuncírculo de cualquier triángulo resultante. Devuelve un PackedInt32Array donde cada triángulo consiste en tres índices de puntos consecutivos en points (es decir, el array devuelto tendrá n * 3 elementos, siendo n el número de triángulos encontrados). Si la triangulación no tiene éxito, se devuelve un PackedInt32Array vacío.
PackedInt32Array triangulate_polygon(polygon: PackedVector2Array) 🔗
Triangula el polígono especificado por los puntos en polygon. Devuelve un PackedInt32Array donde cada triángulo consiste en tres índices de puntos consecutivos en polygon (es decir, el array devuelto tendrá n * 3 elementos, siendo n el número de triángulos encontrados). Los triángulos de salida siempre estarán en sentido antihorario, y el contorno se invertirá si está en el sentido de las agujas del reloj. Si la triangulación no tiene éxito, se devuelve un PackedInt32Array vacío.