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

NavigationMesh

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

Eredita: Resource < RefCounted < Object

Una mesh di navigazione che definisce le aree attraversabili e gli ostacoli.

Descrizione

Una mesh di navigazione è una collezione di poligoni che definiscono quali aree di un ambiente sono attraversabili per aiutare gli agenti a trovare il percorso attraverso spazi complicati.

Tutorial

Proprietà

float	agent_height	`1.5`
float	agent_max_climb	`0.25`
float	agent_max_slope	`45.0`
float	agent_radius	`0.5`
float	border_size	`0.0`
float	cell_height	`0.25`
float	cell_size	`0.25`
float	detail_sample_distance	`6.0`
float	detail_sample_max_error	`1.0`
float	edge_max_error	`1.3`
float	edge_max_length	`0.0`
AABB	filter_baking_aabb	`AABB(0, 0, 0, 0, 0, 0)`
Vector3	filter_baking_aabb_offset	`Vector3(0, 0, 0)`
bool	filter_ledge_spans	`false`
bool	filter_low_hanging_obstacles	`false`
bool	filter_walkable_low_height_spans	`false`
int	geometry_collision_mask	`4294967295`
ParsedGeometryType	geometry_parsed_geometry_type	`2`
SourceGeometryMode	geometry_source_geometry_mode	`0`
StringName	geometry_source_group_name	`&"navigation_mesh_source_group"`
float	region_merge_size	`20.0`
float	region_min_size	`2.0`
SamplePartitionType	sample_partition_type	`0`
float	vertices_per_polygon	`6.0`

Metodi

void	add_polygon(polygon: PackedInt32Array)
void	clear()
void	clear_polygons()
void	create_from_mesh(mesh: Mesh)
bool	get_collision_mask_value(layer_number: int) const
PackedInt32Array	get_polygon(idx: int)
int	get_polygon_count() const
PackedVector3Array	get_vertices() const
void	set_collision_mask_value(layer_number: int, value: bool)
void	set_vertices(vertices: PackedVector3Array)

Enumerazioni

enum SamplePartitionType: 🔗

SamplePartitionType SAMPLE_PARTITION_WATERSHED = 0

Partizionamento spartiacque. In genere è la scelta migliore se si precalcola la mesh di navigazione, da usare se si hanno grandi aree aperte.

SamplePartitionType SAMPLE_PARTITION_MONOTONE = 1

Partizionamento monotono. Da usare se si desidera una generazione veloce della mesh di navigazione.

SamplePartitionType SAMPLE_PARTITION_LAYERS = 2

Partizionamento a livelli. Una buona scelta da usare per le mesh di navigazione con tessere di medie e piccole dimensioni.

SamplePartitionType SAMPLE_PARTITION_MAX = 3

Rappresenta la dimensione dell'enumerazione SamplePartitionType.

enum ParsedGeometryType: 🔗

ParsedGeometryType PARSED_GEOMETRY_MESH_INSTANCES = 0

Interpreta le istanze di mesh come geometria. Ciò include i nodi MeshInstance3D, CSGShape3D e GridMap.

ParsedGeometryType PARSED_GEOMETRY_STATIC_COLLIDERS = 1

Interpreta i collisori StaticBody3D come geometria. Il collisore deve trovarsi in uno qualsiasi degli strati specificati da geometry_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 trovare la geometria. Il gruppo è specificato da geometry_source_group_name.

SourceGeometryMode SOURCE_GEOMETRY_GROUPS_EXPLICIT = 2

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

SourceGeometryMode SOURCE_GEOMETRY_MAX = 3

Rappresenta la dimensione dell'enumerazione SourceGeometryMode.

Descrizioni delle proprietà

float agent_height = 1.5 🔗

void set_agent_height(value: float)
float get_agent_height()

L'altezza minima tra pavimento e soffitto che consentirà comunque all'area del pavimento di essere considerata percorribile.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_height.

float agent_max_climb = 0.25 🔗

void set_agent_max_climb(value: float)
float get_agent_max_climb()

L'altezza minima di una sporgenza che è considerata ancora percorribile.

Nota: Durante la preparazione, questo valore sarà arrotondato per difetto al multiplo più vicino di cell_height.

float agent_max_slope = 45.0 🔗

void set_agent_max_slope(value: float)
float get_agent_max_slope()

La pendenza massima che è considerata percorribile, in gradi.

float agent_radius = 0.5 🔗

void set_agent_radius(value: float)
float get_agent_radius()

La distanza per erodere/restringere l'area percorribile dell'heightfield dagli ostacoli.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_size.

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.

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.

In combinazione con filter_baking_aabb e un valore edge_max_error inferiore o uguale a 1.0, è possibile utilizzare la dimensione del bordo per preparare mesh di navigazione allineate ai tasselli senza che i bordi dei tasselli siano ridotti di agent_radius.

Nota: Se questo valore non è 0.0, sarà arrotondato al multiplo più vicino di cell_size durante la preparazione.

float cell_height = 0.25 🔗

void set_cell_height(value: float)
float get_cell_height()

L'altezza delle celle utilizzata per rasterizzare i vertici della mesh di navigazione sull'asse Y. Deve corrispondere all'altezza delle celle sulla mappa di navigazione.

float cell_size = 0.25 🔗

void set_cell_size(value: float)
float get_cell_size()

Le dimensioni delle celle utilizzate per rasterizzare i vertici della mesh di navigazione sul piano XZ. Deve corrispondere alle dimensioni delle celle sulla mappa di navigazione.

float detail_sample_distance = 6.0 🔗

void set_detail_sample_distance(value: float)
float get_detail_sample_distance()

La distanza di campionamento da utilizzare per generare la mesh di dettaglio, in unità di cella.

float detail_sample_max_error = 1.0 🔗

void set_detail_sample_max_error(value: float)
float get_detail_sample_max_error()

La distanza massima a cui la superficie della mesh di dettaglio deve deviare da heightfield, in unità di cella.

float edge_max_error = 1.3 🔗

void set_edge_max_error(value: float)
float get_edge_max_error()

La distanza massima alla quale i bordi di un contorno semplificato devono deviare dal contorno grezzo originale.

float edge_max_length = 0.0 🔗

void set_edge_max_length(value: float)
float get_edge_max_length()

La lunghezza massima consentita per i bordi del contorno lungo il bordo della mesh. Un valore di 0.0 disabilita questa funzionalità.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_size.

AABB filter_baking_aabb = AABB(0, 0, 0, 0, 0, 0) 🔗

void set_filter_baking_aabb(value: AABB)
AABB get_filter_baking_aabb()

Se l'elaborazione dell'AABB ha un volume, l'elaborazionedella mesh di navigazione sarà limitata all'area che la racchiude.

Vector3 filter_baking_aabb_offset = Vector3(0, 0, 0) 🔗

void set_filter_baking_aabb_offset(value: Vector3)
Vector3 get_filter_baking_aabb_offset()

L'offset di posizione applicato all'AABB filter_baking_aabb.

bool filter_ledge_spans = false 🔗

void set_filter_ledge_spans(value: bool)
bool get_filter_ledge_spans()

Se true, segna bordi che sono sporgenze come non camminabili.

bool filter_low_hanging_obstacles = false 🔗

void set_filter_low_hanging_obstacles(value: bool)
bool get_filter_low_hanging_obstacles()

Se true, contrassegna gli intervalli non percorribili come percorribili se il loro massimo è compreso entro agent_max_climb da un vicino percorribile.

bool filter_walkable_low_height_spans = false 🔗

void set_filter_walkable_low_height_spans(value: bool)
bool get_filter_walkable_low_height_spans()

Se true, contrassegna gli intervalli percorribili come non percorribili se lo spazio libero sopra l'intervallo è inferiore a agent_height.

int geometry_collision_mask = 4294967295 🔗

void set_collision_mask(value: int)
int get_collision_mask()

Gli strati di fisica da scansionare per i collisori statici.

Utilizzato solo quando geometry_parsed_geometry_type è PARSED_GEOMETRY_STATIC_COLLIDERS o PARSED_GEOMETRY_BOTH.

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

SourceGeometryMode geometry_source_geometry_mode = 0 🔗

void set_source_geometry_mode(value: SourceGeometryMode)
SourceGeometryMode get_source_geometry_mode()

La sorgente della geometria utilizzata durante la preparazione.

StringName geometry_source_group_name = &"navigation_mesh_source_group" 🔗

void set_source_group_name(value: StringName)
StringName get_source_group_name()

Il nome del gruppo da scansionare per la geometria.

Utilizzato solo quando geometry_source_geometry_mode è SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN o SOURCE_GEOMETRY_GROUPS_EXPLICIT.

float region_merge_size = 20.0 🔗

void set_region_merge_size(value: float)
float get_region_merge_size()

Tutte le regioni con dimensioni inferiori a questa saranno unite a regioni più grandi, se possibile.

Nota: Questo valore sarà elevato al quadrato per calcolare il numero di celle. Ad esempio, un valore di 20 imposterà il numero di celle a 400.

float region_min_size = 2.0 🔗

void set_region_min_size(value: float)
float get_region_min_size()

La dimensione minima di una regione per la sua creazione.

Nota: Questo valore sarà elevato al quadrato per calcolare il numero minimo di celle autorizzate a formare aree insulari isolate. Ad esempio, un valore di 8 imposterà il numero di celle a 64.

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.

float vertices_per_polygon = 6.0 🔗

void set_vertices_per_polygon(value: float)
float get_vertices_per_polygon()

Il numero massimo di vertici consentiti per i poligoni generati durante il processo di conversione da contorno a poligono.

Descrizioni dei metodi

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_polygons() 🔗

Svuota l'array di poligoni, ma non svuota l'array di vertici.

void create_from_mesh(mesh: Mesh) 🔗

Inizializza la mesh di navigazione impostando i vertici e gli indici secondo una Mesh.

Nota: mesh deve essere di tipo Mesh.PRIMITIVE_TRIANGLES e avere un array di indici.

bool get_collision_mask_value(layer_number: int) const 🔗

Restituisce se lo strato specificato della geometry_collision_mask è abilitato o meno, fornito un numero di strato 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 poligoni nella mesh di navigazione.

PackedVector3Array get_vertices() const 🔗

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

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

In base a value, abilita o disabilita lo strato specificato nella geometry_collision_mask, fornito un layer_number tra 1 e 32.

void set_vertices(vertices: PackedVector3Array) 🔗

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