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...

NavigationPolygon

Sperimentale: This class may be changed or removed in future versions.

Eredita: Resource < RefCounted < Object

Una mesh di navigazione 2D che descrive una superficie attraversabile per la ricerca del percorso.

Descrizione

Una mesh di navigazione può essere creata sia preparandola con l'aiuto di NavigationServer2D, sia aggiungendo manualmente i vertici e gli array di indici dei poligoni convessi

Per preparare una mesh di navigazione è necessario aggiungere almeno un contorno che definisce i limiti esterni dell'area preparata.

var new_navigation_mesh = NavigationPolygon.new()
var bounding_outline = PackedVector2Array([Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)])
new_navigation_mesh.add_outline(bounding_outline)
NavigationServer2D.bake_from_source_geometry_data(new_navigation_mesh, NavigationMeshSourceGeometryData2D.new());
$NavigationRegion2D.navigation_polygon = new_navigation_mesh

var newNavigationMesh = new NavigationPolygon();
Vector2[] boundingOutline = [new Vector2(0, 0), new Vector2(0, 50), new Vector2(50, 50), new Vector2(50, 0)];
newNavigationMesh.AddOutline(boundingOutline);
NavigationServer2D.BakeFromSourceGeometryData(newNavigationMesh, new NavigationMeshSourceGeometryData2D());
GetNode<NavigationRegion2D>("NavigationRegion2D").NavigationPolygon = newNavigationMesh;

Aggiungere manualmente i vertici e gli indici dei poligoni.

var new_navigation_mesh = NavigationPolygon.new()
var new_vertices = PackedVector2Array([Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)])
new_navigation_mesh.vertices = new_vertices
var new_polygon_indices = PackedInt32Array([0, 1, 2, 3])
new_navigation_mesh.add_polygon(new_polygon_indices)
$NavigationRegion2D.navigation_polygon = new_navigation_mesh

var newNavigationMesh = new NavigationPolygon();
Vector2[] newVertices = [new Vector2(0, 0), new Vector2(0, 50), new Vector2(50, 50), new Vector2(50, 0)];
newNavigationMesh.Vertices = newVertices;
int[] newPolygonIndices = [0, 1, 2, 3];
newNavigationMesh.AddPolygon(newPolygonIndices);
GetNode<NavigationRegion2D>("NavigationRegion2D").NavigationPolygon = newNavigationMesh;

Tutorial

Proprietà

float	agent_radius	`10.0`
Rect2	baking_rect	`Rect2(0, 0, 0, 0)`
Vector2	baking_rect_offset	`Vector2(0, 0)`
float	border_size	`0.0`
float	cell_size	`1.0`
int	parsed_collision_mask	`4294967295`
ParsedGeometryType	parsed_geometry_type	`2`
SamplePartitionType	sample_partition_type	`0`
StringName	source_geometry_group_name	`&"navigation_polygon_source_geometry_group"`
SourceGeometryMode	source_geometry_mode	`0`

Metodi

void	add_outline(outline: PackedVector2Array)
void	add_outline_at_index(outline: PackedVector2Array, index: int)
void	add_polygon(polygon: PackedInt32Array)
void	clear()
void	clear_outlines()
void	clear_polygons()
NavigationMesh	get_navigation_mesh()
PackedVector2Array	get_outline(idx: int) const
int	get_outline_count() const
bool	get_parsed_collision_mask_value(layer_number: int) const
PackedInt32Array	get_polygon(idx: int)
int	get_polygon_count() const
PackedVector2Array	get_vertices() const
void	make_polygons_from_outlines()
void	remove_outline(idx: int)
void	set_outline(idx: int, outline: PackedVector2Array)
void	set_parsed_collision_mask_value(layer_number: int, value: bool)
void	set_vertices(vertices: PackedVector2Array)

Enumerazioni

enum SamplePartitionType: 🔗

SamplePartitionType SAMPLE_PARTITION_CONVEX_PARTITION = 0

Convex partitioning that results in a navigation mesh with convex polygons.

SamplePartitionType SAMPLE_PARTITION_TRIANGULATE = 1

Triangulation partitioning that results in a navigation mesh with triangle polygons.

SamplePartitionType SAMPLE_PARTITION_MAX = 2

Rappresenta la dimensione dell'enumerazione SamplePartitionType.

enum ParsedGeometryType: 🔗

ParsedGeometryType PARSED_GEOMETRY_MESH_INSTANCES = 0

Analizza le istanze di mesh come geometria di ostruzione.

Ciò include i nodi Polygon2D, MeshInstance2D, MultiMeshInstance2D e TileMap. Le mesh sono analizzate solo quando utilizzano un formato di superficie con vertici 2D.

ParsedGeometryType PARSED_GEOMETRY_STATIC_COLLIDERS = 1

Analizza i collisori StaticBody2D e TileMap come geometria di ostruzione. Il collisore deve trovarsi in uno qualsiasi degli strati specificati da parsed_collision_mask.

ParsedGeometryType PARSED_GEOMETRY_BOTH = 2

Sia PARSED_GEOMETRY_MESH_INSTANCES che PARSED_GEOMETRY_STATIC_COLLIDERS.

ParsedGeometryType PARSED_GEOMETRY_MAX = 3

Rappresenta la dimensione dell'enumerazione ParsedGeometryType.

enum SourceGeometryMode: 🔗

SourceGeometryMode SOURCE_GEOMETRY_ROOT_NODE_CHILDREN = 0

Scansiona ricorsivamente i nodi figlio del nodo radice per trovare la geometria.

SourceGeometryMode SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN = 1

Scansiona ricorsivamente i nodi in un gruppo e dei loro nodi figlio per la geometria. Il gruppo è specificato da source_geometry_group_name.

SourceGeometryMode SOURCE_GEOMETRY_GROUPS_EXPLICIT = 2

Utilizza i nodi in un gruppo per la geometria. Il gruppo è specificato da source_geometry_group_name.

SourceGeometryMode SOURCE_GEOMETRY_MAX = 3

Rappresenta la dimensione dell'enumerazione SourceGeometryMode.

Descrizioni delle proprietà

float agent_radius = 10.0 🔗

void set_agent_radius(value: float)
float get_agent_radius()

La distanza per erodere/restringere la superficie percorribile durante la preparazione della mesh di navigazione.

Nota: Il raggio deve essere uguale o superiore a 0.0. Se il raggio è 0.0, non sarà possibile correggere sovrapposizioni non valide tra contorni e altri errori di precisione durante il processo di preparazione. Di conseguenza, alcuni ostacoli potrebbero essere esclusi erroneamente dalla mesh di navigazione finale o potrebbero eliminare i poligoni della mesh di navigazione.

Rect2 baking_rect = Rect2(0, 0, 0, 0) 🔗

void set_baking_rect(value: Rect2)
Rect2 get_baking_rect()

Se il Rect2 di preparazione ha un'area, la preparazione della mesh di navigazione sarà limitata all'area che esso racchiude.

Vector2 baking_rect_offset = Vector2(0, 0) 🔗

void set_baking_rect_offset(value: Vector2)
Vector2 get_baking_rect_offset()

Lo scostamento di posizione applicato al Rect2 di baking_rect.

float border_size = 0.0 🔗

void set_border_size(value: float)
float get_border_size()

La dimensione del bordo non navigabile attorno all'area di delimitazione della preparazione definita dal Rect2 baking_rect.

Insieme a baking_rect, la dimensione del bordo può essere utilizzata per preparare mesh di navigazione allineate ai tasselli senza che i bordi dei tasselli siano ridotti da agent_radius.

float cell_size = 1.0 🔗

void set_cell_size(value: float)
float get_cell_size()

La dimensione della cella utilizzata per rasterizzare i vertici della mesh di navigazione. Deve corrispondere alla dimensione della cella sulla mappa di navigazione.

int parsed_collision_mask = 4294967295 🔗

void set_parsed_collision_mask(value: int)
int get_parsed_collision_mask()

Gli strati di fisica da scansionare per i collisori statici.

Utilizzato solo quando parsed_geometry_type è PARSED_GEOMETRY_STATIC_COLLIDERS o PARSED_GEOMETRY_BOTH.

ParsedGeometryType parsed_geometry_type = 2 🔗

void set_parsed_geometry_type(value: ParsedGeometryType)
ParsedGeometryType get_parsed_geometry_type()

Determina quale tipo di nodi sarà interpretato come geometria.

SamplePartitionType sample_partition_type = 0 🔗

void set_sample_partition_type(value: SamplePartitionType)
SamplePartitionType get_sample_partition_type()

Algoritmo di partizionamento per la creazione dei poligoni della mesh di navigazione.

StringName source_geometry_group_name = &"navigation_polygon_source_geometry_group" 🔗

void set_source_geometry_group_name(value: StringName)
StringName get_source_geometry_group_name()

Il nome del gruppo di nodi che devono essere analizzati per preparare la geometria sorgente.

Utilizzato solo quando source_geometry_mode è SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN o SOURCE_GEOMETRY_GROUPS_EXPLICIT.

SourceGeometryMode source_geometry_mode = 0 🔗

void set_source_geometry_mode(value: SourceGeometryMode)
SourceGeometryMode get_source_geometry_mode()

La sorgente della geometria utilizzata durante la preparazione.

Descrizioni dei metodi

void add_outline(outline: PackedVector2Array) 🔗

Accoda un PackedVector2Array contenente i vertici di un contorno all'array interno che contiene tutti i contorni.

void add_outline_at_index(outline: PackedVector2Array, index: int) 🔗

Aggiunge un PackedVector2Array che contiene i vertici di un contorno all'array interno che contiene tutti i contorni in una posizione fissa.

void add_polygon(polygon: PackedInt32Array) 🔗

Aggiunge un poligono utilizzando gli indici dei vertici ottenuti chiamando get_vertices().

void clear() 🔗

Svuota gli array interni per i vertici e gli indici dei poligoni.

void clear_outlines() 🔗

Cancella l'array dei contorni, ma non cancella i vertici e i poligoni da essi creati.

void clear_polygons() 🔗

Cancella l'array dei poligoni, ma non cancella l'array dei contorni e dei vertici.

Restituisce il NavigationMesh risultante da questo poligono di navigazione. È possibile utilizzare questa mesh di navigazione per aggiornare la mesh di navigazione di una regione con l'API NavigationServer3D.region_set_navigation_mesh() direttamente.

PackedVector2Array get_outline(idx: int) const 🔗

Restituisce un PackedVector2Array contenente i vertici di un contorno che è stato creato nell'editor o tramite script.

int get_outline_count() const 🔗

Restituisce il numero di contorni che sono stati creati nell'editor o tramite script.

bool get_parsed_collision_mask_value(layer_number: int) const 🔗

Restituisce se lo strato specificato del parsed_collision_mask è abilitato, dato un layer_number tra 1 e 32.

PackedInt32Array get_polygon(idx: int) 🔗

Restituisce un PackedInt32Array contenente gli indici dei vertici di un poligono creato.

int get_polygon_count() const 🔗

Restituisce il numero di tutti i poligoni.

PackedVector2Array get_vertices() const 🔗

Restituisce un PackedVector2Array contenente tutti i vertici utilizzati per creare i poligoni.

void make_polygons_from_outlines() 🔗

Deprecato: Use NavigationServer2D.parse_source_geometry_data() and NavigationServer2D.bake_from_source_geometry_data() instead.

Crea poligoni dai contorni aggiunti nell'editor o tramite script.

void remove_outline(idx: int) 🔗

Rimuove un contorno creato nell'editor o tramite script. È necessario chiamare make_polygons_from_outlines() per aggiornare i poligoni.

void set_outline(idx: int, outline: PackedVector2Array) 🔗

Modifica un contorno creato nell'editor o tramite script. È necessario chiamare make_polygons_from_outlines() per aggiornare i poligoni.

void set_parsed_collision_mask_value(layer_number: int, value: bool) 🔗

Basato su value, attiva o disattiva lo strato specificato nel parsed_collision_mask, dato un layer_number tra 1 e 32.

void set_vertices(vertices: PackedVector2Array) 🔗

Imposta i vertici che possono essere poi indicizzati per creare poligoni con il metodo add_polygon().