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
Hérite de : Object
Fournit des méthodes pour certaines opérations géométriques 2D communes.
Description
Fournit un ensemble de fonctions d'aide pour créer des formes géométriques, calculer les intersections entre les formes et traiter diverses autres opérations géométriques en 2D.
Méthodes
Énumérations
enum PolyBooleanOperation: 🔗
PolyBooleanOperation OPERATION_UNION = 0
Crée des régions où au moins un des polygones sujets ou de découpe est rempli.
PolyBooleanOperation OPERATION_DIFFERENCE = 1
Crée des régions où le polygone sujet est rempli sauf la où le polygone de découpe est rempli.
PolyBooleanOperation OPERATION_INTERSECTION = 2
Crée des régions où les polygones sujets et de découpe sont tous les deux remplis.
PolyBooleanOperation OPERATION_XOR = 3
Crée des régions où les polygones sujet ou de découpe sont remplis, mais pas où les deux sont remplis.
enum PolyJoinType: 🔗
PolyJoinType JOIN_SQUARE = 0
Squaring is applied uniformally at all convex edge joins at 1 * delta.
PolyJoinType JOIN_ROUND = 1
Bien que des chemins aplatis ne peuvent jamais parfaitement tracer un arc, ils sont approximés par une série de cordes d'arc.
PolyJoinType JOIN_MITER = 2
There's a necessary limit to mitered joins since offsetting edges that join at very acute angles will produce excessively long and narrow "spikes". For any given edge join, when miter offsetting would exceed that maximum distance, "square" joining is applied.
enum PolyEndType: 🔗
PolyEndType END_POLYGON = 0
Les points d'extrémité sont joints en utilisant la valeur de PolyJoinType et le chemin rempli en un polygone.
PolyEndType END_JOINED = 1
Les points d'extrémité sont joints en utilisant la valeur de PolyJoinType et le chemin rempli en une polyligne.
PolyEndType END_BUTT = 2
Les bouts sont carrés sans être étendus.
PolyEndType END_SQUARE = 3
Les bouts seront carrés et étendus de delta unités.
PolyEndType END_ROUND = 4
Les bouts seront arrondis et étendus de delta unités.
Descriptions des méthodes
Array[Vector2i] bresenham_line(from: Vector2i, to: Vector2i) 🔗
Renvoie le segment de Bresenham entre les points from et to. Un segmenr Bresenham est une série de pixels qui dessine un segment et est toujours de 1-pixel d'épaisseur sur chaque ligne et colonne du dessin (ni plus, ni moins).
Exemple de code pour dessiner une ligne entre deux nœuds Marker2D utilisant une série d'appels à 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) 🔗
Découpe le polygon_a avec le polygon_b et renvoie une tableau de polygones découpés. Cela effectue OPERATION_DIFFERENCE entre les polygones. Renvoie un tableau vide si polygon_b recouvre complètement polygon_a.
Si polygon_b est recouvert complément par polygon_a, renvoie un polygone extérieur (délimitant) et un polygone intérieur (trou) qui peuvent être distingués en appelant is_polygon_clockwise().
Array[PackedVector2Array] clip_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Découpe la polyligne polyline avec le polygone polygon et renvoie un tableau de polylignes découpées. Cela effectue OPERATION_DIFFERENCE entre la polyligne et le polygone. Cette opération peut être pensée comme couper une ligne avec une forme fermée.
PackedVector2Array convex_hull(points: PackedVector2Array) 🔗
Selon un tableau de Vector2s donné, renvoie l'enveloppe convexe en tant que liste de points dans le sens inverse des aiguilles d'une montre. Le dernier point est le même que le premier.
Array[PackedVector2Array] decompose_polygon_in_convex(polygon: PackedVector2Array) 🔗
Décompose le polygon en plusieurs enveloppes convexes et renvoie un tableau de PackedVector2Arrays.
Array[PackedVector2Array] exclude_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Exclut mutuellement la zone commune définie par l'intersection de polygon_a et polygon_b (voir intersect_polygons()) et renvoie un tableau de polygones exclus. Cela interprète OPERATION_XOR entre les polygones. En d'autres termes, renvoie tout sauf la zone commune entre les polygones.
L'opération peut se résulter en un polygone extérieur (bordure) et un polygone intérieur (trou) produits qui pourraient être distingués en appelant is_polygon_clockwise().
Vector2 get_closest_point_to_segment(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Renvoie le point 2D sur le segment 2D (s1, s2) qui est le plus proche du point donné. Le point renvoyé sera toujours dans le segment spécifié.
Vector2 get_closest_point_to_segment_uncapped(point: Vector2, s1: Vector2, s2: Vector2) 🔗
Renvoie le point 2D sur la ligne 2D définie par (s1, s2) qui est le plus proche du point donné. Le point renvoyé peut être à l'intérieur du segment (s1, s2) ou à l'extérieur, c'est-à-dire quelque part sur la ligne s'étendant du segment.
PackedVector2Array get_closest_points_between_segments(p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2) 🔗
À partir de deux segments 2D (p1, q1) et (p2, q2), trouve les deux points sur chaque segment qui sont les plus proches l'un de l'autre. Renvoie un PackedVector2Array qui contient le point sur (p1, q1) ainsi que celui sur (p2, q2).
Array[PackedVector2Array] intersect_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Intersectes polygon_a avec polygon_b et renvoie un tableau des polygones intersectés. Cela effectue entre les polygones OPERATION_INTERSECTION. En d'autres termes, renvoie la zone commune partagée par les polygones. Renvoie un tableau vide si aucune intersection ne se produit.
L'opération peut se résulter en un polygone extérieur (bordure) et un polygone intérieur (trou) produits qui pourraient être distingués en appelant is_polygon_clockwise().
Array[PackedVector2Array] intersect_polyline_with_polygon(polyline: PackedVector2Array, polygon: PackedVector2Array) 🔗
Intersecte la polyligne polyline avec le polygone polygon et renvoie un tableau de polylignes intersectées. Cela se effectue OPERATION_INTERSECTION entre la polyligne et le polygone. Cette opération peut être considérée comme hacher une ligne avec une forme fermée.
bool is_point_in_circle(point: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Renvoie true si point se trouve à l'intérieur du cercle ou s'il est situé exactement sur la limite du cercle, sinon renvoie false.
bool is_point_in_polygon(point: Vector2, polygon: PackedVector2Array) 🔗
Renvoie true si point est à l'intérieur du polygone polygon ou s'il est situé exactement sur la limite de polygone, renvoie sinon false.
bool is_polygon_clockwise(polygon: PackedVector2Array) 🔗
Renvoie true si les sommets du polygone polygon sont triés dans le sens des aiguilles d'une montre, sinon renvoie false.
Note : Suppose un système de coordonnées cartésiennes où +x est la droite et +y est le haut. Si on utilise des coordonnées de l'écran (+y est le bas), le résultat devra être inversé (c.-à-d. un résultat true indiquera le sens inverse des aiguilles d'une montre).
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) 🔗
À partir d'un tableau de Vector2 représentant des tuiles, construit un atlas. Le dictionnaire renvoyé a deux clés : points est un PackedVector2Array qui précise les positions de chaque tuile, et size contient la taille globale de l'atlas entier sous forme d'un Vector2i.
Array[PackedVector2Array] merge_polygons(polygon_a: PackedVector2Array, polygon_b: PackedVector2Array) 🔗
Fusionne (combine) les polygones polygon_a et polygon_b et renvoie un tableau de polygones fusionnés. Cela effectue OPERATION_UNION entre les polygones.
L'opération peut résulter en un polygone extérieur (les bords) et plusieurs polygones internes (les trous) qui pourraient être distingués en appelant is_polygon_clockwise().
Array[PackedVector2Array] offset_polygon(polygon: PackedVector2Array, delta: float, join_type: PolyJoinType = 0) 🔗
Gonfle ou dégonfle le polygone polygon par une quantité de delta unités (pixels). Si delta est positif, le polygone grandit vers l'extérieur. Si delta est négatif, le polygone rétrécit vers l'intérieur. Renvoie une liste de polygones parce que le gonflage/dégonflage peut produire plusieurs polygones distincts. Renvoie un tableau vide si delta est négatif et que la valeur absolue de celui-ci dépasse approximativement les dimensions du rectangle délimitant minimal du polygone.
Les sommets de chaque polygone sont arrondis suivant join_type.
L'opération peut résulter un polygone extérieur (la limite extérieure) et plusieurs polygones intérieurs (représentant les trous) qui peuvent être distingués en appelant is_polygon_clockwise().
Note : Pour translater les sommets du polygone spécifiquement, multipliez les par une Transform2D :
var polygone = PackedVector2Array([Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)])
var decalage = Vector2(50, 50)
polygone = Transform2D(0, decalage) * polygone
print(polygone) # Affiche [(50.0, 50.0), (150.0, 50.0), (150.0, 150.0), (50.0, 150.0)]
var polygone = new Vector2[] { new Vector2(0, 0), new Vector2(100, 0), new Vector2(100, 100), new Vector2(0, 100)};
var decalage = new Vector2(50, 50);
polygone = new Transform2D(0, decalage) * polygone;
GD.Print((Variant)polygone); // Affiche [(50, 50), (150, 50), (150, 150), (50, 150)]
Array[PackedVector2Array] offset_polyline(polyline: PackedVector2Array, delta: float, join_type: PolyJoinType = 0, end_type: PolyEndType = 3) 🔗
Gonfle ou dégonfle la polyline par delta unités (pixels), produisant des polygones. Si delta est positif, la polyligne grandit vers l'extérieur. Renvoie une liste de polygones car le gonflage/dégonflage peut produire plusieurs polygones distincts. Si delta est négatif, renvoie un tableau vide.
Les sommets de chaque polygone sont arrondis suivant join_type.
Chaque point d'extrémité du polygone sera arrondi suivant end_type.
L'opération peut se résulter en un polygone extérieur (bordure) et un polygone intérieur (trou) produits qui pourraient être distingués en appelant is_polygon_clockwise().
bool point_is_inside_triangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2) const 🔗
Renvoie si point est à l'intérieur du triangle défini par les points a, b et c.
float segment_intersects_circle(segment_from: Vector2, segment_to: Vector2, circle_position: Vector2, circle_radius: float) 🔗
Étant donné le segment 2D (segment_from, segment_to), renvoie la position sur le segment (en tant que nombre entre 0 et 1) à laquelle le segment touche le cercle situé à la position circle_position et avec un rayon circle_radius. Si le segment n'intersecte pas le cercle, -1 est renvoyé (c'est aussi le cas si la ligne prolongeant le segment intersecte le cercle, mais pas le segment).
Variant segment_intersects_segment(from_a: Vector2, to_a: Vector2, from_b: Vector2, to_b: Vector2) 🔗
Checks if two line segments intersect, with line a between from_a and to_a and line b between from_b and to_b. If the line segments intersect, the point of intersection is returned as a Vector2. If no intersection takes place, null is returned.
PackedInt32Array triangulate_delaunay(points: PackedVector2Array) 🔗
Triangule la zone spécifiée par un ensemble discret de points de sorte à ce qu'aucun point n'est à l'intérieur des cercles circonscrits de tout triangle résultant. Renvoie un PackedInt32Array où chaque triangle se compose de trois indices de point consécutifs dans points (c.-à-d. le tableau renvoyé aura n * 3 éléments, avec n le nombre de triangles trouvés). Si la triangulation n'a pas réussi, un PackedInt32Array vide est renvoyé.
PackedInt32Array triangulate_polygon(polygon: PackedVector2Array) 🔗
Triangule le polygone spécifié par les points dans polygon. Renvoie un PackedInt32Array où chaque triangle se compose de trois indices de point consécutifs de polygon (c'est-à-dire le tableau renvoyé aura n * 3 éléments, avec n étant le nombre de triangles trouvés). Les triangles de sortie seront toujours dans le sens anti-horaire, et le contour sera inversé si c'est dans le sens horaire. Si la triangulation n'a pas réussi, un PackedInt32Array vide sera renvoyé.