Struct Navmesh

pub struct Navmesh { /* private fields */ }

See module docs.

Implementations

impl Navmesh

pub const OCTREE: &'static str = "octree"

pub const TRIANGLES: &'static str = "triangles"

pub const VERTICES: &'static str = "vertices"

pub const GRAPH: &'static str = "graph"

impl Navmesh

pub fn new( triangles: Vec<TriangleDefinition>, vertices: Vec<Vector3<f32>>, ) -> Self

Creates new navigation mesh from given set of triangles and vertices. This is low level method that allows to specify triangles and vertices directly. In most cases you should use from_mesh method.

pub fn from_mesh(mesh: &Mesh) -> Self

Creates new navigation mesh (navmesh) from given mesh. It is most simple way to create complex navigation mesh, it should be used in pair with model loading functionality - you can load model from file and turn it into navigation mesh, or even build navigation mesh from a model in existing scene. This method “eats” any kind of meshes with any amount of surfaces - it joins all surfaces into single mesh and creates navmesh from it.

Example:

fn make_navmesh(scene: &Scene, navmesh_name: &str) -> Navmesh {
    // Find mesh node in existing scene and create navigation mesh from it.
    let navmesh_node_handle = scene.graph.find_by_name_from_root(navmesh_name).unwrap().0;
    Navmesh::from_mesh(scene.graph[navmesh_node_handle].as_mesh())
}

pub fn query_closest( &self, query_point: Vector3<f32>, ) -> Option<(Vector3<f32>, usize)>

Tries to get a projected point on the navmesh, that is closest to the given query point. Returns a tuple with the projection point and the triangle index, that contains this projection point.

Complexity

This method has O(log(n)) complexity in the best case (when the query point lies inside the navmesh bounds) and O(n) complexity in the worst case. n here is the number of triangles in the navmesh.

pub fn modify(&mut self) -> NavmeshModificationContext<'_>

Creates a temporary modification context which allows you to modify the navmesh. When the modification context is dropped, it recalculates navigation graph automatically.

pub fn triangles(&self) -> &[TriangleDefinition]

Returns reference to array of triangles.

pub fn vertices(&self) -> &[Vector3<f32>]

Returns reference to the internal array of vertices.

pub fn octree(&self) -> &Octree

Returns shared reference to inner octree.

pub fn build_path( &self, from: usize, to: usize, path: &mut Vec<Vector3<f32>>, ) -> Result<PathKind, PathError>

Tries to build path using indices of begin and end points.

Example:

use fyrox_impl::utils::navmesh::Navmesh;
use fyrox_impl::core::algebra::Vector3;
use fyrox_impl::utils::astar::{PathKind, PathError};

fn find_path(navmesh: &Navmesh, begin: Vector3<f32>, end: Vector3<f32>, path: &mut Vec<Vector3<f32>>) -> Result<PathKind, PathError> {
    if let Some((_, begin_index)) = navmesh.query_closest(begin) {
        if let Some((_, end_index)) = navmesh.query_closest(end) {
            return navmesh.build_path(begin_index, end_index, path);
        }
    }
    Ok(PathKind::Partial)
}

pub fn ray_cast(&self, ray: Ray) -> Option<(Vector3<f32>, usize)>

Tries to pick a triangle by given ray. Returns closest result.

Trait Implementations

impl Clone for Navmesh

fn clone(&self) -> Navmesh

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Navmesh

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Navmesh

fn default() -> Navmesh

Returns the “default value” for a type.

impl PartialEq for Navmesh

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for Navmesh

where Self: 'static,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl Visit for Navmesh

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

Read or write this value, depending on whether Visitor::is_reading() is true or false.