From 3ac428be61a1b57061db8ce7399e1ceedcd86223 Mon Sep 17 00:00:00 2001 From: CN Z Date: Thu, 7 Nov 2024 16:15:03 +0800 Subject: [PATCH] try fix clippy --- build.rs | 2 +- src/demo/demo.rs | 30 +-- src/detour/base.rs | 92 ++++++--- src/detour/builder.rs | 26 +-- src/detour/mesh.rs | 176 ++++++++++++----- src/detour/query.rs | 96 +++++---- src/detour_crowd/crowd.rs | 118 +++++++++-- src/detour_crowd/local_boundary.rs | 13 +- src/detour_crowd/path_corridor.rs | 38 +++- src/lib.rs | 4 + src/recast/recast.rs | 307 +++++++++++++++++++++-------- tests/common/file.rs | 6 +- tests/common/state.rs | 6 +- tests/query.rs | 122 +++++++----- tests/solo_mesh.rs | 42 ++-- tests/tile_mesh.rs | 63 +++--- 16 files changed, 776 insertions(+), 365 deletions(-) diff --git a/build.rs b/build.rs index 3cec467..0392d12 100644 --- a/build.rs +++ b/build.rs @@ -72,5 +72,5 @@ fn list_cpp_files>(dir: P) -> Vec { } } } - return files; + files } diff --git a/src/demo/demo.rs b/src/demo/demo.rs index bd61b3a..6442170 100644 --- a/src/demo/demo.rs +++ b/src/demo/demo.rs @@ -61,13 +61,13 @@ pub struct RcMeshLoaderObj(UniquePtr); impl Default for RcMeshLoaderObj { fn default() -> Self { - return RcMeshLoaderObj::new(); + RcMeshLoaderObj::new() } } impl RcMeshLoaderObj { pub fn new() -> RcMeshLoaderObj { - return RcMeshLoaderObj(ffi::rcNewMeshLoaderObj()); + RcMeshLoaderObj(ffi::rcNewMeshLoaderObj()) } pub fn load(&mut self, file_name: &str) -> bool { @@ -88,11 +88,11 @@ impl RcMeshLoaderObj { } pub fn get_vert_count(&self) -> i32 { - return self.0.getVertCount(); + self.0.getVertCount() } pub fn get_tri_count(&self) -> i32 { - return self.0.getTriCount(); + self.0.getTriCount() } pub fn get_file_name(&self) -> &str { @@ -106,8 +106,8 @@ pub fn load_nav_mesh(path: &str) -> RNResult { if mesh.is_null() { return Err(RNError::Failed); } - return Ok(DtNavMesh::from_ptr(mesh)); - }; + Ok(DtNavMesh::from_ptr(mesh)) + } } pub fn save_nav_mesh(mesh: &DtNavMesh, path: &str) { @@ -161,17 +161,23 @@ impl Drop for RcChunkyTriMesh { } } +impl Default for RcChunkyTriMesh { + fn default() -> Self { + Self::new() + } +} + impl RcChunkyTriMesh { fn inner(&self) -> &CxxRcChunkyTriMesh { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } fn inner_mut(&mut self) -> Pin<&mut CxxRcChunkyTriMesh> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } pub fn new() -> RcChunkyTriMesh { - return RcChunkyTriMesh(unsafe { ffi::rcctm_new() }); + RcChunkyTriMesh(unsafe { ffi::rcctm_new() }) } pub fn nodes(&self) -> &[RcChunkyTriMeshNode] { @@ -208,7 +214,7 @@ pub fn rc_create_chunky_tri_mesh( if !result { return Err(RNError::Failed); } - return Ok(()); + Ok(()) } pub fn rc_get_chunks_overlapping_rect( @@ -220,11 +226,11 @@ pub fn rc_get_chunks_overlapping_rect( let n = unsafe { ffi::rcGetChunksOverlappingRect(cm.0, bmin.as_ptr(), bmax.as_ptr(), ids.as_mut_ptr(), ids.len() as i32) }; - return n as usize; + n as usize } pub fn rc_get_chunks_overlapping_segment(cm: &RcChunkyTriMesh, p: &[f32; 2], q: &[f32; 2], ids: &mut [i32]) -> usize { let n = unsafe { ffi::rcGetChunksOverlappingSegment(cm.0, p.as_ptr(), q.as_ptr(), ids.as_mut_ptr(), ids.len() as i32) }; - return n as usize; + n as usize } diff --git a/src/detour/base.rs b/src/detour/base.rs index b3a1a21..70d2b88 100644 --- a/src/detour/base.rs +++ b/src/detour/base.rs @@ -33,7 +33,7 @@ unsafe impl ExternType for DtStatus { impl DtStatus { pub fn to_result(self) -> RNResult<()> { if self.0 & DT_SUCCESS != 0 { - return Ok(()); + Ok(()) } else if self.0 & DT_FAILURE != 0 { match self.0 & DT_STATUS_DETAIL_MASK { DT_WRONG_MAGIC => return Err(RNError::WrongMagic), @@ -75,8 +75,9 @@ pub struct DtBuf { } impl Default for DtBuf { + #[inline] fn default() -> Self { - return DtBuf::from_raw(std::ptr::null_mut(), 0); + DtBuf::from_raw(std::ptr::null_mut(), 0) } } @@ -88,122 +89,153 @@ impl Drop for DtBuf { } impl DtBuf { + #[inline] pub(crate) fn from_raw(data: *mut u8, size: i32) -> DtBuf { - return DtBuf { data, size }; + DtBuf { data, size } } - pub fn as_ref(&self) -> &[u8] { + #[inline] + pub fn as_slice(&self) -> &[u8] { return unsafe { std::slice::from_raw_parts(self.data, self.size as usize) }; } - pub fn as_mut(&self) -> &mut [u8] { + #[inline] + pub fn as_slice_mut(&mut self) -> &mut [u8] { return unsafe { std::slice::from_raw_parts_mut(self.data, self.size as usize) }; } + #[inline] pub fn len(&self) -> usize { - return self.size as usize; + self.size as usize + } + + #[inline] + pub fn is_empty(&self) -> bool { + self.len() == 0 } } +#[inline] pub fn dt_vcross(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] { - return [ + [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], - ]; + ] } +#[inline] pub fn dt_vdot(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + a[0] * b[0] + a[1] * b[1] + a[2] * b[2] } +#[inline] pub fn dt_vdot_2d(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return a[0] * b[0] + a[2] * b[2]; + a[0] * b[0] + a[2] * b[2] } +#[inline] pub fn dt_vmad(a: &[f32; 3], b: &[f32; 3], s: f32) -> [f32; 3] { - return [a[0] + b[0] * s, a[1] + b[1] * s, a[2] + b[2] * s]; + [a[0] + b[0] * s, a[1] + b[1] * s, a[2] + b[2] * s] } +#[inline] pub fn dt_vlerp(a: &[f32; 3], b: &[f32; 3], t: f32) -> [f32; 3] { - return [ + [ a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, - ]; + ] } +#[inline] pub fn dt_vadd(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] { - return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; + [a[0] + b[0], a[1] + b[1], a[2] + b[2]] } +#[inline] pub fn dt_vsub(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] { - return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; + [a[0] - b[0], a[1] - b[1], a[2] - b[2]] } +#[inline] pub fn dt_vscale(a: &[f32; 3], b: f32) -> [f32; 3] { - return [a[0] * b, a[1] * b, a[2] * b]; + [a[0] * b, a[1] * b, a[2] * b] } +#[inline] pub fn dt_vmin(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] { - return [a[0].min(b[0]), a[1].min(b[1]), a[2].min(b[2])]; + [a[0].min(b[0]), a[1].min(b[1]), a[2].min(b[2])] } +#[inline] pub fn dt_vmax(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] { - return [a[0].max(b[0]), a[1].max(b[1]), a[2].max(b[2])]; + [a[0].max(b[0]), a[1].max(b[1]), a[2].max(b[2])] } +#[inline] pub fn dt_vlen(a: &[f32; 3]) -> f32 { - return dt_vlen2(a).sqrt(); + dt_vlen2(a).sqrt() } +#[inline] pub fn dt_vlen2(a: &[f32; 3]) -> f32 { - return a[0] * a[0] + a[1] * a[1] + a[2] * a[2]; + a[0] * a[0] + a[1] * a[1] + a[2] * a[2] } +#[inline] pub fn dt_vdist(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return dt_vlen(&dt_vsub(a, b)); + dt_vlen(&dt_vsub(a, b)) } +#[inline] pub fn dt_vdist2(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return dt_vlen2(&dt_vsub(a, b)); + dt_vlen2(&dt_vsub(a, b)) } +#[inline] pub fn dt_vdist_2d(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return dt_vdist2_2d(a, b).sqrt(); + dt_vdist2_2d(a, b).sqrt() } +#[inline] pub fn dt_vdist2_2d(a: &[f32; 3], b: &[f32; 3]) -> f32 { let dx = a[0] - b[0]; let dz = a[2] - b[2]; - return dx * dx + dz * dz; + dx * dx + dz * dz } +#[inline] pub fn dt_vnormalize(a: &[f32; 3]) -> [f32; 3] { let d = 1.0 / dt_vlen(a); - return [a[0] * d, a[1] * d, a[2] * d]; + [a[0] * d, a[1] * d, a[2] * d] } +#[inline] pub fn dt_visinf(a: &[f32; 3]) -> bool { - return a[0].is_infinite() && a[1].is_infinite() && a[2].is_infinite(); + a[0].is_infinite() && a[1].is_infinite() && a[2].is_infinite() } +#[inline] pub fn dt_visinf_2d(a: &[f32; 3]) -> bool { - return a[0].is_infinite() && a[2].is_infinite(); + a[0].is_infinite() && a[2].is_infinite() } +#[inline] pub fn dt_vperp_2d(a: &[f32; 3], b: &[f32; 3]) -> f32 { - return a[2] * b[0] - a[0] * b[2]; + a[2] * b[0] - a[0] * b[2] } +#[inline] pub fn dt_tri_area_2d(a: &[f32; 3], b: &[f32; 3], c: &[f32; 3]) -> f32 { let abx = b[0] - a[0]; let abz = b[2] - a[2]; let acx = c[0] - a[0]; let acz = c[2] - a[2]; - return acx * abz - abx * acz; + acx * abz - abx * acz } +#[inline] pub fn dt_overlap_bounds(amin: &[i32; 3], amax: &[i32; 3], bmin: &[i32; 3], bmax: &[i32; 3]) -> bool { let mut overlap = true; overlap = if amin[0] > bmax[0] || amax[0] < bmin[0] { @@ -221,5 +253,5 @@ pub fn dt_overlap_bounds(amin: &[i32; 3], amax: &[i32; 3], bmin: &[i32; 3], bmax } else { overlap }; - return overlap; + overlap } diff --git a/src/detour/builder.rs b/src/detour/builder.rs index fde0112..e10ee0c 100644 --- a/src/detour/builder.rs +++ b/src/detour/builder.rs @@ -63,16 +63,18 @@ pub struct DtNavMeshCreateParams<'t> { impl Debug for DtNavMeshCreateParams<'_> { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { let cp = CxxDtNavMeshCreateParams::from(self); - return write!(f, "{:?}", cp); + write!(f, "{:?}", cp) } } +#[inline] fn unpack_ptr(v: Option<&[T]>) -> *const T { - return v.map(|v| v.as_ptr()).unwrap_or(std::ptr::null()); + v.map(|v| v.as_ptr()).unwrap_or(std::ptr::null()) } +#[inline] fn unpack_len(v: Option<&[T]>) -> i32 { - return v.map(|v| v.len() as i32).unwrap_or(0); + v.map(|v| v.len() as i32).unwrap_or(0) } #[repr(C)] @@ -129,7 +131,7 @@ unsafe impl ExternType for CxxDtNavMeshCreateParams { impl CxxDtNavMeshCreateParams { fn from(params: &DtNavMeshCreateParams<'_>) -> CxxDtNavMeshCreateParams { - return CxxDtNavMeshCreateParams { + CxxDtNavMeshCreateParams { verts: unpack_ptr(params.verts) as *const _, vert_count: unpack_len(params.verts), polys: unpack_ptr(params.polys), @@ -166,7 +168,7 @@ impl CxxDtNavMeshCreateParams { ch: params.ch, build_bv_tree: params.build_bv_tree, - }; + } } } @@ -193,10 +195,8 @@ pub fn dt_create_nav_mesh_data(params: &mut DtNavMeshCreateParams) -> RNResult RNResult RNResult<()> { let res = unsafe { ffi::dtNavMeshHeaderSwapEndian(buf.data, buf.size) }; if !res { return Err(RNError::Failed); } - return Ok(()); + Ok(()) } +#[inline] pub fn dt_nav_mesh_data_swap_endian(buf: &mut DtBuf) -> RNResult<()> { let res = unsafe { ffi::dtNavMeshDataSwapEndian(buf.data, buf.size) }; if !res { return Err(RNError::Failed); } - return Ok(()); + Ok(()) } diff --git a/src/detour/mesh.rs b/src/detour/mesh.rs index 4c7a8a0..2e7cc66 100644 --- a/src/detour/mesh.rs +++ b/src/detour/mesh.rs @@ -154,8 +154,9 @@ unsafe impl ExternType for DtTileRef { } impl DtPolyRef { + #[inline] pub fn is_null(&self) -> bool { - return self.0 == 0; + self.0 == 0 } } @@ -182,25 +183,29 @@ unsafe impl ExternType for DtPoly { } impl DtPoly { + #[inline] pub fn set_area(&mut self, a: u8) { - return ffi::dtp_setArea(Pin::new(self), a); + ffi::dtp_setArea(Pin::new(self), a) } + #[inline] pub fn set_type(&mut self, t: DtPolyTypes) { - return ffi::dtp_setType(Pin::new(self), t.repr as u32 as u8); + ffi::dtp_setType(Pin::new(self), t.repr as u8) } + #[inline] pub fn area(&self) -> u8 { - return ffi::dtp_getArea(self); + ffi::dtp_getArea(self) } + #[inline] pub fn typ(&self) -> DtPolyTypes { let t = ffi::dtp_getType(self) as u32; - if t == DtPolyTypes::DT_POLYTYPE_OFFMESH_CONNECTION.repr as u32 { - return DtPolyTypes::DT_POLYTYPE_OFFMESH_CONNECTION; + if t == DtPolyTypes::DT_POLYTYPE_OFFMESH_CONNECTION.repr { + DtPolyTypes::DT_POLYTYPE_OFFMESH_CONNECTION } else { - return DtPolyTypes::DT_POLYTYPE_GROUND; - }; + DtPolyTypes::DT_POLYTYPE_GROUND + } } } @@ -364,12 +369,14 @@ pub struct DtMeshTile(CxxDtMeshTile); impl Deref for DtMeshTile { type Target = CxxDtMeshTile; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for DtMeshTile { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -382,153 +389,184 @@ impl Debug for DtMeshTile { } impl DtMeshTile { + #[inline] fn inner(&self) -> &ffi::dtMeshTile { - return &self.0; + &self.0 } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtMeshTile> { - return unsafe { Pin::new_unchecked(&mut self.0) }; + unsafe { Pin::new_unchecked(&mut self.0) } } + #[inline] pub fn as_ptr(&self) -> *const ffi::dtMeshTile { - return &self.0; + &self.0 } + #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::dtMeshTile { - return &mut self.0; + &mut self.0 } + #[inline] pub fn header(&self) -> Option<&DtMeshHeader> { unsafe { if self.header.is_null() { - return None; + None } else { - return Some(&*self.header); + Some(&*self.header) } - }; + } } + #[inline] pub fn header_mut(&mut self) -> Option<&mut DtMeshHeader> { unsafe { if self.header.is_null() { - return None; + None } else { - return Some(&mut *self.header); + Some(&mut *self.header) } - }; + } } + #[inline] pub fn polys(&self) -> &[DtPoly] { let poly_count = self.header().map_or(0, |h| h.poly_count as usize); return unsafe { std::slice::from_raw_parts(self.polys, poly_count) }; } + #[inline] pub fn polys_mut(&mut self) -> &mut [DtPoly] { let poly_count = self.header().map_or(0, |h| h.poly_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.polys, poly_count) }; } + #[inline] pub fn verts(&self) -> &[[f32; 3]] { let vert_count = self.header().map_or(0, |h| h.vert_count as usize); return unsafe { std::slice::from_raw_parts(self.verts, vert_count) }; } + #[inline] pub fn verts_mut(&mut self) -> &mut [[f32; 3]] { let vert_count = self.header().map_or(0, |h| h.vert_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.verts, vert_count) }; } + #[inline] pub fn links(&self) -> &[DtLink] { let link_count = self.header().map_or(0, |h| h.max_link_count as usize); return unsafe { std::slice::from_raw_parts(self.links, link_count) }; } + #[inline] pub fn links_mut(&mut self) -> &mut [DtLink] { let link_count = self.header().map_or(0, |h| h.max_link_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.links, link_count) }; } + #[inline] pub fn detail_meshes(&self) -> &[DtPolyDetail] { let detail_mesh_count = self.header().map_or(0, |h| h.detail_mesh_count as usize); return unsafe { std::slice::from_raw_parts(self.detail_meshes, detail_mesh_count) }; } + #[inline] pub fn detail_meshes_mut(&mut self) -> &mut [DtPolyDetail] { let detail_mesh_count = self.header().map_or(0, |h| h.detail_mesh_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.detail_meshes, detail_mesh_count) }; } + #[inline] pub fn detail_verts(&self) -> &[[f32; 3]] { let detail_vert_count = self.header().map_or(0, |h| h.detail_vert_count as usize); return unsafe { std::slice::from_raw_parts(self.detail_verts, detail_vert_count) }; } + #[inline] pub fn detail_verts_mut(&mut self) -> &mut [[f32; 3]] { let detail_vert_count = self.header().map_or(0, |h| h.detail_vert_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.detail_verts, detail_vert_count) }; } + #[inline] pub fn detail_tris(&self) -> &[[u8; 4]] { let detail_tri_count = self.header().map_or(0, |h| h.detail_tri_count as usize); return unsafe { std::slice::from_raw_parts(self.detail_tris, detail_tri_count) }; } + #[inline] pub fn detail_tris_mut(&mut self) -> &mut [[u8; 4]] { let detail_tri_count = self.header().map_or(0, |h| h.detail_tri_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.detail_tris, detail_tri_count) }; } + #[inline] pub fn bv_tree(&self) -> &[DtBVNode] { let bv_node_count = self.header().map_or(0, |h| h.bv_node_count as usize); return unsafe { std::slice::from_raw_parts(self.bv_tree, bv_node_count) }; } + #[inline] pub fn bv_tree_mut(&mut self) -> &mut [DtBVNode] { let bv_node_count = self.header().map_or(0, |h| h.bv_node_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.bv_tree, bv_node_count) }; } + #[inline] pub fn off_mesh_cons(&self) -> &[DtOffMeshConnection] { let off_mesh_con_count = self.header().map_or(0, |h| h.off_mesh_con_count as usize); return unsafe { std::slice::from_raw_parts(self.off_mesh_cons, off_mesh_con_count) }; } + #[inline] pub fn off_mesh_cons_mut(&mut self) -> &mut [DtOffMeshConnection] { let off_mesh_con_count = self.header().map_or(0, |h| h.off_mesh_con_count as usize); return unsafe { std::slice::from_raw_parts_mut(self.off_mesh_cons, off_mesh_con_count) }; } + #[inline] pub fn data(&self) -> &[u8] { + if self.data.is_null() { + return &[]; + } return unsafe { std::slice::from_raw_parts(self.data, self.data_size()) }; } + #[inline] pub fn data_mut(&mut self) -> &mut [u8] { + if self.data.is_null() { + return &mut []; + } return unsafe { std::slice::from_raw_parts_mut(self.data, self.data_size()) }; } + #[inline] pub fn data_size(&self) -> usize { - return self.data_size as usize; + self.data_size as usize } + #[inline] pub fn next(&self) -> Option<&DtMeshTile> { if self.next.is_null() { return None; - } else { - return Some(unsafe { mem::transmute(self.next) }); } + Some(unsafe { &*(self.next as *const DtMeshTile) }) } + #[inline] pub fn next_mut(&mut self) -> Option<&mut DtMeshTile> { if self.next.is_null() { return None; - } else { - return Some(unsafe { mem::transmute(self.next) }); } + Some(unsafe { &mut *(self.next as *mut DtMeshTile) }) } } pub fn get_detail_tri_edge_flags(tri_flags: u8, edge_index: i32) -> i32 { - return ffi::dtGetDetailTriEdgeFlags(tri_flags, edge_index); + ffi::dtGetDetailTriEdgeFlags(tri_flags, edge_index) } // @@ -566,37 +604,51 @@ impl Drop for DtNavMesh { } } +impl Default for DtNavMesh { + fn default() -> Self { + Self::new() + } +} + impl DtNavMesh { + #[inline] pub fn new() -> DtNavMesh { - return DtNavMesh(ffi::dtAllocNavMesh()); + DtNavMesh(ffi::dtAllocNavMesh()) } + #[inline] pub(crate) unsafe fn from_ptr(ptr: *mut ffi::dtNavMesh) -> DtNavMesh { - return DtNavMesh(ptr); + DtNavMesh(ptr) } + #[inline] fn inner(&self) -> &ffi::dtNavMesh { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtNavMesh> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } + #[inline] pub fn as_ptr(&self) -> *const ffi::dtNavMesh { - return self.0; + self.0 } + #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::dtNavMesh { - return self.0; + self.0 } + #[inline] pub fn with_params(params: &DtNavMeshParams) -> RNResult { let mut mesh = DtNavMesh::new(); unsafe { mesh.inner_mut().init_with_params(params) }.to_result()?; - return Ok(mesh); + Ok(mesh) } + #[inline] pub fn with_data(buf: DtBuf) -> RNResult { let mut mesh = DtNavMesh::new(); unsafe { @@ -605,13 +657,15 @@ impl DtNavMesh { } .to_result()?; mem::forget(buf); - return Ok(mesh); + Ok(mesh) } + #[inline] pub fn params(&self) -> &DtNavMeshParams { return unsafe { &*self.inner().getParams() }; } + #[inline] pub fn add_tile(&mut self, buf: DtBuf, last_ref: DtTileRef) -> RNResult { let mut re = DtTileRef::default(); unsafe { @@ -620,88 +674,99 @@ impl DtNavMesh { } .to_result()?; mem::forget(buf); - return Ok(re); + Ok(re) } + #[inline] pub fn remove_tile(&mut self, re: DtTileRef) -> RNResult<()> { return unsafe { self.inner_mut().removeTile(re, ptr::null_mut(), ptr::null_mut()) }.to_result(); } + #[inline] pub fn calc_tile_loc(&self, pos: &[f32; 3]) -> [i32; 2] { let mut t: [i32; 2] = [0, 0]; unsafe { self.inner().calcTileLoc(pos.as_ptr(), &mut t[0], &mut t[1]) }; - return t; + t } + #[inline] pub fn get_tile_at(&self, x: i32, y: i32, layer: i32) -> Option<&DtMeshTile> { let tile = unsafe { self.inner().getTileAt(x, y, layer) }; if tile.is_null() { return None; - } else { - return Some(unsafe { mem::transmute(tile) }); } + Some(unsafe { &*(tile as *const DtMeshTile) }) } + #[inline] pub fn get_tiles_at<'a, 'b: 'a>(&'b self, x: i32, y: i32, tiles: &mut [Option<&'a DtMeshTile>]) -> usize { let count = unsafe { self.inner() .getTilesAt(x, y, tiles.as_mut_ptr() as *mut _, tiles.len() as i32) }; - return count as usize; + count as usize } + #[inline] pub fn get_tile_ref_at(&self, x: i32, y: i32, layer: i32) -> DtTileRef { return self.inner().getTileRefAt(x, y, layer); } + #[inline] pub fn get_tile_ref(&self, tile: &DtMeshTile) -> DtTileRef { return unsafe { self.inner().getTileRef(tile.inner()) }; } + #[inline] pub fn get_tile_by_ref(&self, re: DtTileRef) -> Option<&DtMeshTile> { let tile = unsafe { self.inner().getTileByRef(re) }; if tile.is_null() { return None; - } else { - return Some(unsafe { mem::transmute(tile) }); } + Some(unsafe { &*(tile as *const DtMeshTile) }) } + #[inline] pub fn max_tiles(&self) -> i32 { return self.inner().getMaxTiles(); } + #[inline] pub fn get_tile(&self, i: i32) -> Option<&DtMeshTile> { let tile = unsafe { self.inner().getTile(i) }; if tile.is_null() { return None; - } else { - return Some(unsafe { mem::transmute(tile) }); } + Some(unsafe { &*(tile as *const DtMeshTile) }) } + #[inline] pub fn get_tile_and_poly_by_ref(&self, re: DtPolyRef) -> RNResult<(&DtMeshTile, &DtPoly)> { let mut tile = std::ptr::null(); let mut poly = std::ptr::null(); unsafe { self.inner().getTileAndPolyByRef(re, &mut tile, &mut poly) }.to_result()?; - return Ok(unsafe { (mem::transmute(tile), &*poly) }); + Ok(unsafe { (&*(tile as *const DtMeshTile), &*poly) }) } + #[inline] pub unsafe fn get_tile_and_poly_by_ref_unsafe(&self, re: DtPolyRef) -> (&DtMeshTile, &DtPoly) { let mut tile = std::ptr::null(); let mut poly = std::ptr::null(); unsafe { self.inner().getTileAndPolyByRefUnsafe(re, &mut tile, &mut poly) }; - return (mem::transmute(tile), unsafe { &*poly }); + (&*(tile as *const DtMeshTile), unsafe { &*poly }) } + #[inline] pub fn is_valid_poly_ref(&self, re: DtPolyRef) -> bool { - return self.inner().isValidPolyRef(re); + self.inner().isValidPolyRef(re) } + #[inline] pub unsafe fn get_poly_ref_base(&self, tile: &DtMeshTile) -> DtPolyRef { - return self.inner().getPolyRefBase(tile.inner()); + self.inner().getPolyRefBase(tile.inner()) } + #[inline] pub fn get_off_mesh_connection_poly_end_points( &self, prev_ref: DtPolyRef, @@ -714,66 +779,79 @@ impl DtNavMesh { .getOffMeshConnectionPolyEndPoints(prev_ref, poly_ref, &mut start_pos[0], &mut end_pos[0]) } .to_result()?; - return Ok((start_pos, end_pos)); + Ok((start_pos, end_pos)) } + #[inline] pub fn get_off_mesh_connection_by_ref(&self, re: DtPolyRef) -> &DtOffMeshConnection { return unsafe { &*self.inner().getOffMeshConnectionByRef(re) }; } + #[inline] pub fn set_poly_flags(&mut self, re: DtPolyRef, flags: u16) -> RNResult<()> { return self.inner_mut().setPolyFlags(re, flags).to_result(); } + #[inline] pub fn get_poly_flags(&self, re: DtPolyRef) -> RNResult { let mut flags = 0; unsafe { self.inner().getPolyFlags(re, &mut flags) }.to_result()?; - return Ok(flags); + Ok(flags) } + #[inline] pub fn set_poly_area(&mut self, re: DtPolyRef, area: u8) -> RNResult<()> { return self.inner_mut().setPolyArea(re, area).to_result(); } + #[inline] pub fn get_poly_area(&self, re: DtPolyRef) -> RNResult { let mut area = 0; unsafe { self.inner().getPolyArea(re, &mut area) }.to_result()?; - return Ok(area); + Ok(area) } + #[inline] pub unsafe fn get_tile_state_size(&self, tile: &DtMeshTile) -> usize { return self.inner().getTileStateSize(tile.inner()) as usize; } + #[inline] pub unsafe fn store_tile_state(&self, re: DtTileRef, data: &mut [u8]) -> RNResult<()> { return unsafe { ffi::dtmt_storeTileState(self.inner(), re, data.as_mut_ptr(), data.len() as i32) }.to_result(); } + #[inline] pub unsafe fn restore_tile_state(&mut self, re: DtTileRef, data: &[u8]) -> RNResult<()> { return unsafe { ffi::dtmt_restoreTileState(self.inner_mut(), re, data.as_ptr(), data.len() as i32) } .to_result(); } + #[inline] pub fn encode_poly_id(&self, salt: u32, it: u32, ip: u32) -> DtPolyRef { return self.inner().encodePolyId(salt, it, ip); } + #[inline] pub unsafe fn decode_poly_id(&self, re: DtPolyRef) -> (u32, u32, u32) { let mut salt = 0; let mut it = 0; let mut ip = 0; self.inner().decodePolyId(re, &mut salt, &mut it, &mut ip); - return (salt, it, ip); + (salt, it, ip) } + #[inline] pub fn decode_poly_id_salt(&self, re: DtPolyRef) -> u32 { return self.inner().decodePolyIdSalt(re); } + #[inline] pub fn decode_poly_id_tile(&self, re: DtPolyRef) -> u32 { return self.inner().decodePolyIdTile(re); } + #[inline] pub fn decode_poly_id_poly(&self, re: DtPolyRef) -> u32 { return self.inner().decodePolyIdPoly(re); } diff --git a/src/detour/query.rs b/src/detour/query.rs index a1a3adb..c787d40 100644 --- a/src/detour/query.rs +++ b/src/detour/query.rs @@ -316,20 +316,23 @@ unsafe impl ExternType for DtQueryFilter { } impl Default for DtQueryFilter { + #[inline] fn default() -> DtQueryFilter { - return DtQueryFilter { + DtQueryFilter { area_cost: [1.0; DT_MAX_AREAS], include_flags: 0xffff, exclude_flags: 0, - }; + } } } impl DtQueryFilter { + #[inline] pub fn pass_filter(&self, re: DtPolyRef, tile: DtMeshTile, poly: &DtPoly) -> bool { - return unsafe { ffi::dtqf_passFilter(self, re, tile.as_ptr(), poly) }; + unsafe { ffi::dtqf_passFilter(self, re, tile.as_ptr(), poly) } } + #[inline] pub fn get_cost( &self, pa: &[f32; 3], @@ -344,7 +347,7 @@ impl DtQueryFilter { next_tile: &DtMeshTile, next_poly: &DtPoly, ) -> f32 { - return unsafe { + unsafe { ffi::dtqf_getCost( self, pa.as_ptr(), @@ -359,7 +362,7 @@ impl DtQueryFilter { next_tile.as_ptr(), next_poly as *const _, ) - }; + } } } @@ -387,8 +390,9 @@ unsafe impl ExternType for DtRaycastHit { } impl Default for DtRaycastHit { + #[inline] fn default() -> DtRaycastHit { - return DtRaycastHit { + DtRaycastHit { t: 0.0, hit_normal: [0.0; 3], hit_edge_index: 0, @@ -396,21 +400,24 @@ impl Default for DtRaycastHit { path_count: 0, max_path: 0, path_cost: 0.0, - }; + } } } impl DtRaycastHit { + #[inline] pub fn path(&self) -> &[DtPolyRef] { return unsafe { std::slice::from_raw_parts(self.path, self.path_count as usize) }; } + #[inline] pub fn path_mut(&mut self) -> &mut [DtPolyRef] { return unsafe { std::slice::from_raw_parts_mut(self.path, self.path_count as usize) }; } + #[inline] pub fn path_count(&self) -> i32 { - return self.path_count; + self.path_count } } @@ -423,35 +430,48 @@ impl Drop for DtNavMeshQuery { } } +impl Default for DtNavMeshQuery { + fn default() -> Self { + Self::new() + } +} + impl DtNavMeshQuery { + #[inline] pub fn new() -> DtNavMeshQuery { - return DtNavMeshQuery(ffi::dtAllocNavMeshQuery()); + DtNavMeshQuery(ffi::dtAllocNavMeshQuery()) } + #[inline] fn inner(&self) -> &ffi::dtNavMeshQuery { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtNavMeshQuery> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } + #[inline] pub fn as_ptr(&self) -> *const ffi::dtNavMeshQuery { - return self.0; + self.0 } + #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::dtNavMeshQuery { - return self.0; + self.0 } + #[inline] pub fn init(&mut self, nav: &DtNavMesh, max_nodes: usize) -> RNResult<()> { return unsafe { self.inner_mut().init(nav.as_ptr(), max_nodes as i32) }.to_result(); } + #[inline] pub fn with_mesh(nav: &DtNavMesh, max_nodes: usize) -> RNResult { let mut query = DtNavMeshQuery::new(); query.init(nav, max_nodes)?; - return Ok(query); + Ok(query) } pub fn find_path( @@ -477,7 +497,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(path_count as usize); + Ok(path_count as usize) } pub fn find_straight_path( @@ -520,7 +540,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(straight_path_count as usize); + Ok(straight_path_count as usize) } pub fn init_sliced_find_path( @@ -552,7 +572,7 @@ impl DtNavMeshQuery { pub fn update_sliced_find_path(&mut self, max_iter: usize) -> RNResult { let mut done_iters = 0; unsafe { self.inner_mut().updateSlicedFindPath(max_iter as i32, &mut done_iters) }.to_result()?; - return Ok(done_iters as usize); + Ok(done_iters as usize) } pub fn finalize_sliced_find_path(&mut self, path: &mut [DtPolyRef]) -> RNResult { @@ -562,7 +582,7 @@ impl DtNavMeshQuery { .finalizeSlicedFindPath(path.as_mut_ptr(), &mut path_count, path.len() as i32) } .to_result()?; - return Ok(path_count as usize); + Ok(path_count as usize) } pub fn finalize_sliced_find_path_partial( @@ -581,7 +601,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(path_count as usize); + Ok(path_count as usize) } pub fn find_polys_around_circle( @@ -633,7 +653,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(result_count as usize); + Ok(result_count as usize) } pub fn find_polys_around_shape( @@ -684,7 +704,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(result_count as usize); + Ok(result_count as usize) } pub fn get_path_from_dijkstra_search(&self, end_ref: DtPolyRef, path: &mut [DtPolyRef]) -> RNResult { @@ -694,7 +714,7 @@ impl DtNavMeshQuery { .getPathFromDijkstraSearch(end_ref, path.as_mut_ptr(), &mut path_count, path.len() as i32) } .to_result()?; - return Ok(path_count as usize); + Ok(path_count as usize) } /// Returns `Result<(nearest_ref: DtPolyRef, nearest_pt: [f32; 3])>` @@ -716,7 +736,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((nearest_ref, nearest_pt)); + Ok((nearest_ref, nearest_pt)) } /// Returns `Result<(nearest_ref: DtPolyRef, nearest_pt: [f32; 3], is_over_poly: bool)>` @@ -740,7 +760,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((nearest_ref, nearest_pt, is_over_poly)); + Ok((nearest_ref, nearest_pt, is_over_poly)) } pub fn query_polygons( @@ -762,7 +782,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(poly_count as usize); + Ok(poly_count as usize) } // TODO: query_polygons with dtPolyQuery @@ -797,7 +817,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(result_count as usize); + Ok(result_count as usize) } /// Returns `Result<(result_pos: [f32; 3], visited_count: usize)>` @@ -824,7 +844,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((result_pos, visited_count as usize)); + Ok((result_pos, visited_count as usize)) } /// Returns `Result<(t: f32, hit_normal: [f32; 3], path_count: usize)>` @@ -860,7 +880,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((t, hit_normal, path_count as usize)); + Ok((t, hit_normal, path_count as usize)) } pub fn raycast_2( @@ -881,11 +901,11 @@ impl DtNavMeshQuery { filter, options as u32, &mut hit, - prev_ref.unwrap_or(DtPolyRef::default()), + prev_ref.unwrap_or_default(), ) } .to_result()?; - return Ok(hit); + Ok(hit) } /// Returns `Result<(hit_dist: f32, hit_pos: [f32; 3], hit_normal: [f32; 3])>` @@ -911,7 +931,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((hit_dist, hit_pos, hit_normal)); + Ok((hit_dist, hit_pos, hit_normal)) } pub fn get_poly_wall_segments( @@ -941,7 +961,7 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok(segment_count as usize); + Ok(segment_count as usize) } /// Returns `Result<(closest: [f32; 3], pos_over_poly: bool)>` @@ -953,7 +973,7 @@ impl DtNavMeshQuery { .closestPointOnPoly(re, pos.as_ptr(), closest.as_mut_ptr(), &mut pos_over_poly) } .to_result()?; - return Ok((closest, pos_over_poly)); + Ok((closest, pos_over_poly)) } pub fn closest_point_on_poly_boundary(&self, re: DtPolyRef, pos: &[f32; 3]) -> RNResult<[f32; 3]> { @@ -963,19 +983,21 @@ impl DtNavMeshQuery { .closestPointOnPolyBoundary(re, pos.as_ptr(), closest.as_mut_ptr()) } .to_result()?; - return Ok(closest); + Ok(closest) } pub fn get_poly_height(&self, re: DtPolyRef, pos: &[f32; 3]) -> RNResult { let mut height = 0.0; unsafe { self.inner().getPolyHeight(re, pos.as_ptr(), &mut height) }.to_result()?; - return Ok(height); + Ok(height) } + #[inline] pub fn is_valid_poly_ref(&self, re: DtPolyRef, filter: &DtQueryFilter) -> bool { return unsafe { self.inner().isValidPolyRef(re, filter) }; } + #[inline] pub fn is_in_closed_list(&self, re: DtPolyRef) -> bool { return unsafe { self.inner().isInClosedList(re) }; } @@ -994,7 +1016,7 @@ impl DtNavMeshQuery { let mut random_pt = [0.0; 3]; unsafe { ffi::dtnmq_findRandomPoint(self.inner(), filter, frand, &mut random_ref, random_pt.as_mut_ptr()) } .to_result()?; - return Ok((random_ref, random_pt)); + Ok((random_ref, random_pt)) } /// Returns `Result<(random_ref: DtPolyRef, random_pt: [f32; 3])>` @@ -1021,6 +1043,6 @@ impl DtNavMeshQuery { ) } .to_result()?; - return Ok((random_ref, random_pt)); + Ok((random_ref, random_pt)) } } diff --git a/src/detour_crowd/crowd.rs b/src/detour_crowd/crowd.rs index 0fca107..c187a68 100644 --- a/src/detour_crowd/crowd.rs +++ b/src/detour_crowd/crowd.rs @@ -1,7 +1,6 @@ use cxx::{type_id, ExternType}; use static_assertions::const_assert_eq; use std::fmt::{self, Debug, Formatter}; -use std::mem; use std::pin::Pin; use crate::detour::{DtNavMesh, DtPolyRef, DtQueryFilter}; @@ -186,7 +185,7 @@ unsafe impl ExternType for DtCrowdAgentParams { impl Default for DtCrowdAgentParams { fn default() -> Self { - return DtCrowdAgentParams { + DtCrowdAgentParams { radius: 0.6, height: 2.0, max_acceleration: 8.0, @@ -198,7 +197,7 @@ impl Default for DtCrowdAgentParams { obstacle_avoidance_type: 3, query_filter_type: 0, user_data: std::ptr::null_mut(), - }; + } } } @@ -222,71 +221,87 @@ impl Debug for DtCrowdAgent { } impl DtCrowdAgent { + #[inline] fn inner(&self) -> &ffi::dtCrowdAgent { - return &self.0; + &self.0 } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtCrowdAgent> { - return unsafe { Pin::new_unchecked(&mut self.0) }; + unsafe { Pin::new_unchecked(&mut self.0) } } + #[inline] pub fn as_ptr(&self) -> *const ffi::dtCrowdAgent { - return &self.0; + &self.0 } + #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::dtCrowdAgent { - return &mut self.0; + &mut self.0 } + #[inline] pub fn active(&self) -> bool { return ffi::dtca_getActive(self.inner()); } + #[inline] pub fn set_active(&mut self, active: bool) { ffi::dtca_setActive(self.inner_mut(), active); } - // TODO: CrowdAgentState + #[inline] // TODO: CrowdAgentState pub fn state(&self) -> u8 { return ffi::dtca_getState(self.inner()); } + #[inline] pub fn set_state(&mut self, state: u8) { ffi::dtca_setState(self.inner_mut(), state); } + #[inline] pub fn partial(&self) -> bool { return ffi::dtca_getPartial(self.inner()); } + #[inline] pub fn set_partial(&mut self, partial: bool) { ffi::dtca_setPartial(self.inner_mut(), partial); } + #[inline] pub fn corridor(&self) -> &DtPathCorridor { - return unsafe { mem::transmute(ffi::dtca_getCorridor(self.inner())) }; + return unsafe { &*(ffi::dtca_getCorridor(self.inner()) as *const DtPathCorridor) }; } + #[inline] pub fn corridor_mut(&mut self) -> &mut DtPathCorridor { - return unsafe { mem::transmute(ffi::dtca_getCorridor_mut(self.inner_mut())) }; + return unsafe { &mut *(ffi::dtca_getCorridor_mut(self.inner_mut()) as *mut DtPathCorridor) }; } + #[inline] pub fn boundary(&self) -> &DtLocalBoundary { - return unsafe { mem::transmute(ffi::dtca_getBoundary(self.inner())) }; + return unsafe { &*(ffi::dtca_getBoundary(self.inner()) as *const DtLocalBoundary) }; } + #[inline] pub fn boundary_mut(&mut self) -> &mut DtLocalBoundary { - return unsafe { mem::transmute(ffi::dtca_getBoundary_mut(self.inner_mut())) }; + return unsafe { &mut *(ffi::dtca_getBoundary_mut(self.inner_mut()) as *mut DtLocalBoundary) }; } + #[inline] pub fn topology_opt_time(&self) -> f32 { return ffi::dtca_getTopologyOptTime(self.inner()); } + #[inline] pub fn set_topology_opt_time(&mut self, topology_opt_time: f32) { ffi::dtca_setTopologyOptTime(self.inner_mut(), topology_opt_time); } + #[inline] pub fn neis(&self) -> &[DtCrowdNeighbour] { return unsafe { std::slice::from_raw_parts( @@ -296,6 +311,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn neis_mut(&mut self) -> &mut [DtCrowdNeighbour] { return unsafe { std::slice::from_raw_parts_mut( @@ -305,62 +321,77 @@ impl DtCrowdAgent { }; } + #[inline] pub fn desired_speed(&self) -> f32 { return ffi::dtca_getDesiredSpeed(self.inner()); } + #[inline] pub fn set_desired_speed(&mut self, desired_speed: f32) { ffi::dtca_setDesiredSpeed(self.inner_mut(), desired_speed); } + #[inline] pub fn npos(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getNpos(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_npos(&mut self, npos: &[f32; 3]) { unsafe { ffi::dtca_setNpos(self.inner_mut(), npos.as_ptr()) }; } + #[inline] pub fn disp(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getDisp(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_disp(&mut self, disp: &[f32; 3]) { unsafe { ffi::dtca_setDisp(self.inner_mut(), disp.as_ptr()) }; } + #[inline] pub fn dvel(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getDvel(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_dvel(&mut self, dvel: &[f32; 3]) { unsafe { ffi::dtca_setDvel(self.inner_mut(), dvel.as_ptr()) }; } + #[inline] pub fn nvel(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getNvel(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_nvel(&mut self, nvel: &[f32; 3]) { unsafe { ffi::dtca_setNvel(self.inner_mut(), nvel.as_ptr()) }; } + #[inline] pub fn vel(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getVel(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_vel(&mut self, vel: &[f32; 3]) { unsafe { ffi::dtca_setVel(self.inner_mut(), vel.as_ptr()) }; } + #[inline] pub fn params(&self) -> &DtCrowdAgentParams { return unsafe { &*ffi::dtca_getParams(self.inner()) }; } + #[inline] pub fn params_mut(&mut self) -> &mut DtCrowdAgentParams { return unsafe { &mut *ffi::dtca_getParams_mut(self.inner_mut()) }; } + #[inline] pub fn corner_verts(&self) -> &[[f32; 3]] { return unsafe { std::slice::from_raw_parts( @@ -370,6 +401,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn corner_verts_mut(&mut self) -> &mut [[f32; 3]] { return unsafe { std::slice::from_raw_parts_mut( @@ -379,6 +411,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn corner_flags(&self) -> &[u8] { return unsafe { std::slice::from_raw_parts( @@ -388,6 +421,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn corner_flags_mut(&mut self) -> &mut [u8] { return unsafe { std::slice::from_raw_parts_mut( @@ -397,6 +431,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn corner_polys(&self) -> &[DtPolyRef] { return unsafe { std::slice::from_raw_parts( @@ -406,6 +441,7 @@ impl DtCrowdAgent { }; } + #[inline] pub fn corner_polys_mut(&mut self) -> &mut [DtPolyRef] { return unsafe { std::slice::from_raw_parts_mut( @@ -415,54 +451,67 @@ impl DtCrowdAgent { }; } + #[inline] pub fn ncorners(&self) -> i32 { return ffi::dtca_getNcorners(self.inner()); } + #[inline] pub fn target_state(&self) -> u8 { return ffi::dtca_getTargetState(self.inner()); } + #[inline] pub fn set_target_state(&mut self, target_state: u8) { ffi::dtca_setTargetState(self.inner_mut(), target_state); } + #[inline] pub fn target_ref(&self) -> DtPolyRef { return ffi::dtca_getTargetRef(self.inner()); } + #[inline] pub fn set_target_ref(&mut self, target_ref: DtPolyRef) { ffi::dtca_setTargetRef(self.inner_mut(), target_ref); } + #[inline] pub fn target_pos(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtca_getTargetPos(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn set_target_pos(&mut self, target_pos: &[f32; 3]) { unsafe { ffi::dtca_setTargetPos(self.inner_mut(), target_pos.as_ptr()) }; } + #[inline] pub fn target_pathq_ref(&self) -> u32 { return ffi::dtca_getTargetPathqRef(self.inner()); } + #[inline] pub fn set_target_pathq_ref(&mut self, target_pathq_ref: u32) { ffi::dtca_setTargetPathqRef(self.inner_mut(), target_pathq_ref); } + #[inline] pub fn target_replan(&self) -> bool { return ffi::dtca_getTargetReplan(self.inner()); } + #[inline] pub fn set_target_replan(&mut self, target_replan: bool) { ffi::dtca_setTargetReplan(self.inner_mut(), target_replan); } + #[inline] pub fn target_replan_time(&self) -> f32 { return ffi::dtca_getTargetReplanTime(self.inner()); } + #[inline] pub fn set_target_replan_time(&mut self, target_replan_time: f32) { ffi::dtca_setTargetReplanTime(self.inner_mut(), target_replan_time); } @@ -509,35 +558,49 @@ impl Drop for DtCrowd { } } +impl Default for DtCrowd { + fn default() -> Self { + Self::new() + } +} + impl DtCrowd { + #[inline] pub fn new() -> DtCrowd { - return DtCrowd(ffi::dtAllocCrowd()); + DtCrowd(ffi::dtAllocCrowd()) } + #[inline] fn inner(&self) -> &ffi::dtCrowd { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtCrowd> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } + #[inline] pub fn as_ptr(&self) -> *const ffi::dtCrowd { - return self.0; + self.0 } + #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::dtCrowd { - return self.0; + self.0 } + #[inline] pub fn init(&mut self, max_agents: i32, max_agent_radius: f32, nav: &mut DtNavMesh) -> bool { return unsafe { self.inner_mut().init(max_agents, max_agent_radius, nav.as_mut_ptr()) }; } + #[inline] pub fn set_obstacle_avoidance_params(&mut self, idx: i32, params: &DtObstacleAvoidanceParams) { unsafe { self.inner_mut().setObstacleAvoidanceParams(idx, params) }; } + #[inline] pub fn get_obstacle_avoidance_params(&self, idx: i32) -> &DtObstacleAvoidanceParams { return unsafe { &*self.inner().getObstacleAvoidanceParams(idx) }; } @@ -546,38 +609,47 @@ impl DtCrowd { // return unsafe { mem::transmute(self.inner().get) }; // } + #[inline] pub fn get_agent_mut(&mut self, idx: i32) -> &mut DtCrowdAgent { - return unsafe { mem::transmute(self.inner_mut().getEditableAgent(idx)) }; + return unsafe { &mut *(self.inner_mut().getEditableAgent(idx) as *mut DtCrowdAgent) }; } + #[inline] pub fn get_agent_count(&self) -> i32 { return self.inner().getAgentCount(); } + #[inline] pub fn add_agent(&mut self, pos: &[f32; 3], params: &DtCrowdAgentParams) -> i32 { return unsafe { self.inner_mut().addAgent(pos as *const _, params) }; } + #[inline] pub fn update_agent_parameters(&mut self, idx: i32, params: &DtCrowdAgentParams) { unsafe { self.inner_mut().updateAgentParameters(idx, params) }; } + #[inline] pub fn remove_agent(&mut self, idx: i32) { self.inner_mut().removeAgent(idx); } + #[inline] pub fn request_move_target(&mut self, idx: i32, re: DtPolyRef, pos: &[f32; 3]) -> bool { return unsafe { self.inner_mut().requestMoveTarget(idx, re, pos as *const _) }; } + #[inline] pub fn request_move_velocity(&mut self, idx: i32, vel: &[f32; 3]) -> bool { return unsafe { self.inner_mut().requestMoveVelocity(idx, vel as *const _) }; } + #[inline] pub fn reset_move_target(&mut self, idx: i32) -> bool { return self.inner_mut().resetMoveTarget(idx); } + #[inline] pub fn get_active_agents(&mut self, agents: &mut [&mut DtCrowdAgent]) -> i32 { return unsafe { self.inner_mut() @@ -585,26 +657,32 @@ impl DtCrowd { }; } + #[inline] pub fn update(&mut self, dt: f32, debug: &mut DtCrowdAgentDebugInfo) { unsafe { self.inner_mut().update(dt, debug) }; } + #[inline] pub fn filter(&self, i: i32) -> &DtQueryFilter { - return unsafe { mem::transmute(self.inner().getFilter(i)) }; + return unsafe { &*self.inner().getFilter(i) }; } + #[inline] pub fn filter_mut(&mut self, i: i32) -> &mut DtQueryFilter { - return unsafe { mem::transmute(self.inner_mut().getEditableFilter(i)) }; + return unsafe { &mut *self.inner_mut().getEditableFilter(i) }; } + #[inline] pub fn query_half_extents(&self) -> &[f32; 3] { return unsafe { &*(self.inner().getQueryHalfExtents() as *const [f32; 3]) }; } + #[inline] pub fn query_extents(&self) -> &[f32; 3] { return unsafe { &*(self.inner().getQueryExtents() as *const [f32; 3]) }; } + #[inline] pub fn velocity_sample_count(&self) -> i32 { return self.inner().getVelocitySampleCount(); } diff --git a/src/detour_crowd/local_boundary.rs b/src/detour_crowd/local_boundary.rs index a232649..e2135fb 100644 --- a/src/detour_crowd/local_boundary.rs +++ b/src/detour_crowd/local_boundary.rs @@ -55,18 +55,22 @@ impl Debug for CxxDtLocalBoundary { } impl DtLocalBoundary { + #[inline] fn inner(&self) -> &ffi::dtLocalBoundary { - return &self.0; + &self.0 } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtLocalBoundary> { - return unsafe { Pin::new_unchecked(&mut self.0) }; + unsafe { Pin::new_unchecked(&mut self.0) } } + #[inline] pub fn reset(&mut self) { unsafe { ffi::dtlb_reset(self.inner_mut()) }; } + #[inline] pub fn update( &mut self, re: DtPolyRef, @@ -87,19 +91,22 @@ impl DtLocalBoundary { } } + #[inline] pub fn is_valid(&self, navquery: &mut DtNavMeshQuery, filter: &DtQueryFilter) -> bool { return unsafe { ffi::dtlb_isValid(self.inner(), navquery.as_mut_ptr(), filter) }; } + #[inline] pub fn center(&self) -> &[f32; 3] { return unsafe { &*(ffi::dtlb_getCenter(self.inner()) as *const [f32; 3]) }; } + #[inline] pub fn segment(&self, i: usize) -> Option<&DtAABB> { if i >= ffi::dtlb_getSegmentCount(self.inner()) as usize { return None; } let seg = unsafe { &*(ffi::dtlb_getSegment(self.inner(), i as i32) as *const DtAABB) }; - return Some(seg); + Some(seg) } } diff --git a/src/detour_crowd/path_corridor.rs b/src/detour_crowd/path_corridor.rs index fde15ea..ccb5163 100644 --- a/src/detour_crowd/path_corridor.rs +++ b/src/detour_crowd/path_corridor.rs @@ -123,22 +123,27 @@ impl Debug for DtPathCorridor { } impl DtPathCorridor { + #[inline] fn inner(&self) -> &ffi::dtPathCorridor { - return &self.0; + &self.0 } + #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::dtPathCorridor> { - return unsafe { Pin::new_unchecked(&mut self.0) }; + unsafe { Pin::new_unchecked(&mut self.0) } } + #[inline] pub fn init(&mut self, max_path: i32) -> bool { return self.inner_mut().init(max_path); } + #[inline] pub fn reset(&mut self, rer: DtPolyRef, pos: &[f32; 3]) { unsafe { self.inner_mut().reset(rer, pos.as_ptr()) }; } + #[inline] pub fn find_corners( &mut self, corner_verts: &mut [[f32; 3]], @@ -163,6 +168,7 @@ impl DtPathCorridor { }; } + #[inline] pub fn optimize_path_visibility( &mut self, next: &[f32; 3], @@ -180,10 +186,12 @@ impl DtPathCorridor { }; } + #[inline] pub fn optimize_path_topology(&mut self, navquery: &mut DtNavMeshQuery, filter: &DtQueryFilter) -> bool { return unsafe { self.inner_mut().optimizePathTopology(navquery.as_mut_ptr(), filter) }; } + #[inline] pub fn move_over_offmesh_connection( &mut self, off_mesh_con_ref: DtPolyRef, @@ -203,10 +211,12 @@ impl DtPathCorridor { }; } + #[inline] pub fn fix_path_start(&mut self, safe_ref: DtPolyRef, safe_pos: &[f32; 3]) -> bool { return unsafe { self.inner_mut().fixPathStart(safe_ref, safe_pos.as_ptr()) }; } + #[inline] pub fn trim_invalid_path( &mut self, safe_ref: DtPolyRef, @@ -220,10 +230,12 @@ impl DtPathCorridor { }; } + #[inline] pub fn is_valid(&mut self, max_look_ahead: i32, navquery: &mut DtNavMeshQuery, filter: &DtQueryFilter) -> bool { return unsafe { self.inner_mut().isValid(max_look_ahead, navquery.as_mut_ptr(), filter) }; } + #[inline] pub fn move_position(&mut self, npos: &[f32; 3], navquery: &mut DtNavMeshQuery, filter: &DtQueryFilter) -> bool { return unsafe { self.inner_mut() @@ -231,6 +243,7 @@ impl DtPathCorridor { }; } + #[inline] pub fn move_target_position( &mut self, npos: &[f32; 3], @@ -243,33 +256,40 @@ impl DtPathCorridor { }; } + #[inline] pub fn set_corridor(&mut self, target: &[f32; 3], polys: &[DtPolyRef], npath: i32) { unsafe { self.inner_mut().setCorridor(target.as_ptr(), polys.as_ptr(), npath) }; } + #[inline] pub fn pos(&self) -> &[f32; 3] { return unsafe { &*(self.inner().getPos() as *const [f32; 3]) }; } + #[inline] pub fn target(&self) -> &[f32; 3] { return unsafe { &*(self.inner().getTarget() as *const [f32; 3]) }; } + #[inline] pub fn first_poly(&self) -> DtPolyRef { return self.inner().getFirstPoly(); } + #[inline] pub fn last_poly(&self) -> DtPolyRef { return self.inner().getLastPoly(); } + #[inline] pub fn path(&self) -> &[DtPolyRef] { return unsafe { std::slice::from_raw_parts(self.inner().getPath(), self.inner().getPathCount() as usize) }; } } +#[inline] pub fn merge_corridor_start_moved(path: &mut [DtPolyRef], npath: usize, visited: &[DtPolyRef]) -> usize { - return unsafe { + unsafe { ffi::dtMergeCorridorStartMoved( path.as_mut_ptr(), npath as i32, @@ -277,11 +297,12 @@ pub fn merge_corridor_start_moved(path: &mut [DtPolyRef], npath: usize, visited: visited.as_ptr(), visited.len() as i32, ) as usize - }; + } } +#[inline] pub fn merge_corridor_end_moved(path: &mut [DtPolyRef], npath: usize, visited: &[DtPolyRef]) -> usize { - return unsafe { + unsafe { ffi::dtMergeCorridorEndMoved( path.as_mut_ptr(), npath as i32, @@ -289,11 +310,12 @@ pub fn merge_corridor_end_moved(path: &mut [DtPolyRef], npath: usize, visited: & visited.as_ptr(), visited.len() as i32, ) as usize - }; + } } +#[inline] pub fn merge_corridor_start_shortcut(path: &mut [DtPolyRef], npath: usize, visited: &[DtPolyRef]) -> usize { - return unsafe { + unsafe { ffi::dtMergeCorridorStartShortcut( path.as_mut_ptr(), npath as i32, @@ -301,5 +323,5 @@ pub fn merge_corridor_start_shortcut(path: &mut [DtPolyRef], npath: usize, visit visited.as_ptr(), visited.len() as i32, ) as usize - }; + } } diff --git a/src/lib.rs b/src/lib.rs index 68316c2..4773284 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,7 @@ +#![allow(clippy::missing_safety_doc)] +#![allow(clippy::module_inception)] +#![allow(clippy::too_many_arguments)] + mod error; pub use error::*; diff --git a/src/recast/recast.rs b/src/recast/recast.rs index f62029b..5b17c67 100644 --- a/src/recast/recast.rs +++ b/src/recast/recast.rs @@ -374,8 +374,9 @@ impl Debug for RcContext { } impl RcContext { + #[inline] pub fn new(state: bool) -> RcContext { - return RcContext(ffi::rcNewContext(state)); + RcContext(ffi::rcNewContext(state)) } #[inline] @@ -410,7 +411,7 @@ impl RcContext { #[inline] pub fn get_accumulated_time(&self, label: RcTimerLabel) -> i32 { - return self.0.getAccumulatedTime(label); + self.0.getAccumulatedTime(label) } } @@ -524,7 +525,7 @@ const RC_SPAN_AREA_MASK: u32 = !(RC_SPAN_SMIN_MASK | RC_SPAN_SMAX_MASK); impl RcSpan { #[inline] pub fn smin(&self) -> u32 { - return self.bits & RC_SPAN_SMIN_MASK; + self.bits & RC_SPAN_SMIN_MASK } #[inline] @@ -534,7 +535,7 @@ impl RcSpan { #[inline] pub fn smax(&self) -> u32 { - return (self.bits & RC_SPAN_SMAX_MASK) >> RC_SPAN_SMAX_OFF; + (self.bits & RC_SPAN_SMAX_MASK) >> RC_SPAN_SMAX_OFF } #[inline] @@ -544,7 +545,7 @@ impl RcSpan { #[inline] pub fn area(&self) -> u32 { - return self.bits >> RC_SPAN_AREA_OFF; + self.bits >> RC_SPAN_AREA_OFF } #[inline] @@ -555,9 +556,9 @@ impl RcSpan { #[inline] pub fn next(&self) -> Option<&RcSpan> { if self.next.is_null() { - return None; + None } else { - return Some(unsafe { &*self.next }); + Some(unsafe { &*self.next }) } } } @@ -630,12 +631,14 @@ pub struct RcHeightfield(*mut CxxRcHeightfield); impl Deref for RcHeightfield { type Target = CxxRcHeightfield; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcHeightfield { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -647,40 +650,46 @@ impl Drop for RcHeightfield { } } +impl Default for RcHeightfield { + fn default() -> Self { + Self::new() + } +} + impl RcHeightfield { #[inline] pub fn new() -> RcHeightfield { - return RcHeightfield(unsafe { ffi::rcAllocHeightfield() }); + RcHeightfield(unsafe { ffi::rcAllocHeightfield() }) } #[inline] fn inner(&self) -> &ffi::rcHeightfield { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcHeightfield> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcHeightfield { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcHeightfield { - return self.0; + self.0 } #[inline] pub fn width(&self) -> i32 { - return self.width; + self.width } #[inline] pub fn height(&self) -> i32 { - return self.height; + self.height } #[inline] @@ -692,7 +701,7 @@ impl RcHeightfield { if span.is_null() { return None; } - return Some(unsafe { &*span }); + Some(unsafe { &*span }) } #[inline] @@ -704,7 +713,7 @@ impl RcHeightfield { if span.is_null() { return None; } - return Some(unsafe { &mut *span }); + Some(unsafe { &mut *span }) } } @@ -738,7 +747,7 @@ const RC_COMPACT_CELL_COUNT_MASK: u32 = 0xFF; impl RcCompactCell { #[inline] pub fn index(&self) -> u32 { - return self.bits & RC_COMPACT_CELL_INDEX_MASK; + self.bits & RC_COMPACT_CELL_INDEX_MASK } #[inline] @@ -748,7 +757,7 @@ impl RcCompactCell { #[inline] pub fn count(&self) -> u32 { - return self.bits >> RC_COMPACT_CELL_COUNT_OFF; + self.bits >> RC_COMPACT_CELL_COUNT_OFF } #[inline] @@ -793,7 +802,7 @@ const RC_COMPACT_SPAN_H_MASK: u32 = 0xFF; impl RcCompactSpan { #[inline] pub fn con(&self) -> u32 { - return self.bits & RC_COMPACT_SPAN_CON_MASK; + self.bits & RC_COMPACT_SPAN_CON_MASK } #[inline] @@ -803,7 +812,7 @@ impl RcCompactSpan { #[inline] pub fn h(&self) -> u32 { - return self.bits >> RC_COMPACT_SPAN_H_OFF; + self.bits >> RC_COMPACT_SPAN_H_OFF } #[inline] @@ -865,12 +874,14 @@ pub struct RcCompactHeightfield(*mut ffi::rcCompactHeightfield); impl Deref for RcCompactHeightfield { type Target = CxxRcCompactHeightfield; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcCompactHeightfield { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -882,45 +893,51 @@ impl Drop for RcCompactHeightfield { } } +impl Default for RcCompactHeightfield { + fn default() -> Self { + Self::new() + } +} + impl RcCompactHeightfield { #[inline] pub fn new() -> RcCompactHeightfield { - return RcCompactHeightfield(unsafe { ffi::rcAllocCompactHeightfield() }); + RcCompactHeightfield(unsafe { ffi::rcAllocCompactHeightfield() }) } #[inline] fn inner(&self) -> &ffi::rcCompactHeightfield { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcCompactHeightfield> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcCompactHeightfield { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcCompactHeightfield { - return self.0; + self.0 } #[inline] pub fn width(&self) -> i32 { - return self.width; + self.width } #[inline] pub fn height(&self) -> i32 { - return self.height; + self.height } #[inline] pub fn span_count(&self) -> usize { - return self.span_count as usize; + self.span_count as usize } #[inline] @@ -1018,12 +1035,12 @@ unsafe impl ExternType for RcHeightfieldLayer { impl RcHeightfieldLayer { #[inline] pub fn width(&self) -> i32 { - return self.width; + self.width } #[inline] pub fn height(&self) -> i32 { - return self.height; + self.height } #[inline] @@ -1084,12 +1101,14 @@ pub struct RcHeightfieldLayerSet(*mut ffi::rcHeightfieldLayerSet); impl Deref for RcHeightfieldLayerSet { type Target = CxxRcHeightfieldLayerSet; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcHeightfieldLayerSet { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -1101,30 +1120,36 @@ impl Drop for RcHeightfieldLayerSet { } } +impl Default for RcHeightfieldLayerSet { + fn default() -> Self { + Self::new() + } +} + impl RcHeightfieldLayerSet { #[inline] pub fn new() -> RcHeightfieldLayerSet { - return RcHeightfieldLayerSet(unsafe { ffi::rcAllocHeightfieldLayerSet() }); + RcHeightfieldLayerSet(unsafe { ffi::rcAllocHeightfieldLayerSet() }) } #[inline] fn inner(&self) -> &ffi::rcHeightfieldLayerSet { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcHeightfieldLayerSet> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcHeightfieldLayerSet { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcHeightfieldLayerSet { - return self.0; + self.0 } #[inline] @@ -1178,7 +1203,7 @@ unsafe impl ExternType for RcContour { impl RcContour { #[inline] pub fn nverts(&self) -> usize { - return self.nverts as usize; + self.nverts as usize } #[inline] @@ -1193,7 +1218,7 @@ impl RcContour { #[inline] pub fn nrverts(&self) -> usize { - return self.nrverts as usize; + self.nrverts as usize } #[inline] @@ -1242,12 +1267,14 @@ pub struct RcContourSet(*mut ffi::rcContourSet); impl Deref for RcContourSet { type Target = CxxRcContourSet; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcContourSet { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -1259,30 +1286,36 @@ impl Drop for RcContourSet { } } +impl Default for RcContourSet { + fn default() -> Self { + Self::new() + } +} + impl RcContourSet { #[inline] pub fn new() -> RcContourSet { - return RcContourSet(unsafe { ffi::rcAllocContourSet() }); + RcContourSet(unsafe { ffi::rcAllocContourSet() }) } #[inline] fn inner(&self) -> &ffi::rcContourSet { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcContourSet> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcContourSet { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcContourSet { - return self.0; + self.0 } #[inline] @@ -1347,12 +1380,14 @@ pub struct RcPolyMesh(*mut ffi::rcPolyMesh); impl Deref for RcPolyMesh { type Target = CxxRcPolyMesh; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcPolyMesh { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -1364,30 +1399,36 @@ impl Drop for RcPolyMesh { } } +impl Default for RcPolyMesh { + fn default() -> Self { + Self::new() + } +} + impl RcPolyMesh { #[inline] pub fn new() -> RcPolyMesh { - return RcPolyMesh(unsafe { ffi::rcAllocPolyMesh() }); + RcPolyMesh(unsafe { ffi::rcAllocPolyMesh() }) } #[inline] fn inner(&self) -> &ffi::rcPolyMesh { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcPolyMesh> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcPolyMesh { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcPolyMesh { - return self.0; + self.0 } #[inline] @@ -1442,22 +1483,22 @@ impl RcPolyMesh { #[inline] pub fn nverts(&self) -> usize { - return self.nverts as usize; + self.nverts as usize } #[inline] pub fn npolys(&self) -> usize { - return self.npolys as usize; + self.npolys as usize } #[inline] pub fn maxpolys(&self) -> usize { - return self.maxpolys as usize; + self.maxpolys as usize } #[inline] pub fn nvp(&self) -> usize { - return self.nvp as usize; + self.nvp as usize } } @@ -1498,12 +1539,14 @@ pub struct RcPolyMeshDetail(*mut ffi::rcPolyMeshDetail); impl Deref for RcPolyMeshDetail { type Target = CxxRcPolyMeshDetail; + #[inline] fn deref(&self) -> &Self::Target { return self.inner(); } } impl DerefMut for RcPolyMeshDetail { + #[inline] fn deref_mut(&mut self) -> &mut Self::Target { return self.inner_mut().get_mut(); } @@ -1515,30 +1558,36 @@ impl Drop for RcPolyMeshDetail { } } +impl Default for RcPolyMeshDetail { + fn default() -> Self { + Self::new() + } +} + impl RcPolyMeshDetail { #[inline] pub fn new() -> RcPolyMeshDetail { - return RcPolyMeshDetail(unsafe { ffi::rcAllocPolyMeshDetail() }); + RcPolyMeshDetail(unsafe { ffi::rcAllocPolyMeshDetail() }) } #[inline] fn inner(&self) -> &ffi::rcPolyMeshDetail { - return unsafe { &*self.0 }; + unsafe { &*self.0 } } #[inline] fn inner_mut(&mut self) -> Pin<&mut ffi::rcPolyMeshDetail> { - return unsafe { Pin::new_unchecked(&mut *self.0) }; + unsafe { Pin::new_unchecked(&mut *self.0) } } #[inline] pub fn as_ptr(&self) -> *const ffi::rcPolyMeshDetail { - return self.0; + self.0 } #[inline] pub fn as_mut_ptr(&mut self) -> *mut ffi::rcPolyMeshDetail { - return self.0; + self.0 } #[inline] @@ -1573,17 +1622,17 @@ impl RcPolyMeshDetail { #[inline] pub fn nmeshes(&self) -> usize { - return self.nmeshes as usize; + self.nmeshes as usize } #[inline] pub fn nverts(&self) -> usize { - return self.nverts as usize; + self.nverts as usize } #[inline] pub fn ntris(&self) -> usize { - return self.ntris as usize; + self.ntris as usize } } @@ -1597,6 +1646,7 @@ impl Debug for RcPolyMeshDetail { // functions // +#[inline] pub fn rc_calc_bounds(verts: &[[f32; 3]]) -> ([f32; 3], [f32; 3]) { let mut min_bounds = [0.0; 3]; let mut max_bounds = [0.0; 3]; @@ -1608,9 +1658,10 @@ pub fn rc_calc_bounds(verts: &[[f32; 3]]) -> ([f32; 3], [f32; 3]) { max_bounds.as_mut_ptr(), ); } - return (min_bounds, max_bounds); + (min_bounds, max_bounds) } +#[inline] pub fn rc_calc_grid_size(min_bounds: &[f32; 3], max_bounds: &[f32; 3], cell_size: f32) -> (i32, i32) { let mut size_x = 0; let mut size_z = 0; @@ -1623,9 +1674,10 @@ pub fn rc_calc_grid_size(min_bounds: &[f32; 3], max_bounds: &[f32; 3], cell_size &mut size_z, ); } - return (size_x, size_z); + (size_x, size_z) } +#[inline] pub fn rc_create_heightfield( context: &mut RcContext, heightfield: &mut RcHeightfield, @@ -1648,9 +1700,14 @@ pub fn rc_create_heightfield( cell_height, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_mark_walkable_triangles( context: &mut RcContext, walkable_slope_angle: f32, @@ -1672,9 +1729,10 @@ pub fn rc_mark_walkable_triangles( tri_area_ids.as_mut_ptr(), ); } - return Ok(()); + Ok(()) } +#[inline] pub fn rc_clear_unwalkable_triangles( context: &mut RcContext, walkable_slope_angle: f32, @@ -1696,9 +1754,10 @@ pub fn rc_clear_unwalkable_triangles( tri_area_ids.as_mut_ptr(), ); } - return Ok(()); + Ok(()) } +#[inline] pub fn rc_add_span( context: &mut RcContext, heightfield: &mut RcHeightfield, @@ -1721,9 +1780,14 @@ pub fn rc_add_span( flag_merge_threshold, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_rasterize_triangle( context: &mut RcContext, v0: &[f32; 3], @@ -1744,9 +1808,14 @@ pub fn rc_rasterize_triangle( flag_merge_threshold, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_rasterize_triangles_1( context: &mut RcContext, verts: &[[f32; 3]], @@ -1770,9 +1839,10 @@ pub fn rc_rasterize_triangles_1( flag_merge_threshold, ) }; - return Ok(res); + Ok(res) } +#[inline] pub fn rc_rasterize_triangles_2( context: &mut RcContext, verts: &[[f32; 3]], @@ -1796,9 +1866,10 @@ pub fn rc_rasterize_triangles_2( flag_merge_threshold, ) }; - return Ok(res); + Ok(res) } +#[inline] pub fn rc_rasterize_triangles_3( context: &mut RcContext, verts: &[[f32; 3]], @@ -1819,9 +1890,10 @@ pub fn rc_rasterize_triangles_3( flag_merge_threshold, ) }; - return Ok(res); + Ok(res) } +#[inline] pub fn rc_filter_low_hanging_walkable_obstacles( context: &mut RcContext, walkable_climb: i32, @@ -1836,6 +1908,7 @@ pub fn rc_filter_low_hanging_walkable_obstacles( } } +#[inline] pub fn rc_filter_ledge_spans( context: &mut RcContext, walkable_height: i32, @@ -1852,6 +1925,7 @@ pub fn rc_filter_ledge_spans( } } +#[inline] pub fn rc_filter_walkable_low_height_spans( context: &mut RcContext, walkable_height: i32, @@ -1866,12 +1940,14 @@ pub fn rc_filter_walkable_low_height_spans( } } +#[inline] pub fn rc_get_height_field_span_count(context: &mut RcContext, heightfield: &RcHeightfield) -> i32 { unsafe { return ffi::rcGetHeightFieldSpanCount(context.0.pin_mut().get_unchecked_mut() as *mut _, heightfield.inner()); } } +#[inline] pub fn rc_build_compact_heightfield( context: &mut RcContext, walkable_height: i32, @@ -1888,9 +1964,14 @@ pub fn rc_build_compact_heightfield( compact_heightfield.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_erode_walkable_area( context: &mut RcContext, erosion_radius: i32, @@ -1903,9 +1984,14 @@ pub fn rc_erode_walkable_area( compact_heightfield.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_median_filter_walkable_area( context: &mut RcContext, compact_heightfield: &mut RcCompactHeightfield, @@ -1916,9 +2002,14 @@ pub fn rc_median_filter_walkable_area( compact_heightfield.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_mark_box_area( context: &mut RcContext, box_min_bounds: &[f32; 3], @@ -1937,6 +2028,7 @@ pub fn rc_mark_box_area( } } +#[inline] pub fn rc_offset_poly( verts: &[[f32; 3]], num_verts: i32, @@ -1945,16 +2037,17 @@ pub fn rc_offset_poly( max_out_verts: i32, ) -> i32 { unsafe { - return ffi::rcOffsetPoly( + ffi::rcOffsetPoly( verts.as_ptr() as *const f32, num_verts, offset, out_verts.as_mut_ptr() as *mut f32, max_out_verts, - ); + ) } } +#[inline] pub fn rc_mark_convex_poly_area( context: &mut RcContext, verts: &[[f32; 3]], @@ -1976,6 +2069,7 @@ pub fn rc_mark_convex_poly_area( } } +#[inline] pub fn rc_mark_cylinder_area( context: &mut RcContext, position: &[f32; 3], @@ -1996,11 +2090,17 @@ pub fn rc_mark_cylinder_area( } } +#[inline] pub fn rc_build_distance_field(context: &mut RcContext, chf: &mut RcCompactHeightfield) -> RNResult<()> { let res = unsafe { ffi::rcBuildDistanceField(context.0.pin_mut().get_unchecked_mut() as *mut _, chf.inner_mut()) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_regions( context: &mut RcContext, chf: &mut RcCompactHeightfield, @@ -2017,9 +2117,14 @@ pub fn rc_build_regions( merge_region_area, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_layer_regions( context: &mut RcContext, chf: &mut RcCompactHeightfield, @@ -2034,9 +2139,14 @@ pub fn rc_build_layer_regions( min_region_area, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_regions_monotone( context: &mut RcContext, chf: &mut RcCompactHeightfield, @@ -2053,9 +2163,14 @@ pub fn rc_build_regions_monotone( merge_region_area, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_heightfield_layers( context: &mut RcContext, chf: &RcCompactHeightfield, @@ -2072,9 +2187,14 @@ pub fn rc_build_heightfield_layers( lset.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_contours( context: &mut RcContext, chf: &RcCompactHeightfield, @@ -2093,9 +2213,14 @@ pub fn rc_build_contours( build_flags.repr, ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_build_poly_mesh( context: &mut RcContext, cset: &RcContourSet, @@ -2110,9 +2235,14 @@ pub fn rc_build_poly_mesh( mesh.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_merge_poly_meshes(context: &mut RcContext, meshes: &[&RcPolyMesh], mesh: &mut RcPolyMesh) -> bool { let tmp_meshes: Vec<_> = meshes.iter().map(|m| m.as_ptr()).collect(); unsafe { @@ -2125,6 +2255,7 @@ pub fn rc_merge_poly_meshes(context: &mut RcContext, meshes: &[&RcPolyMesh], mes } } +#[inline] pub fn rc_build_poly_mesh_detail( context: &mut RcContext, mesh: &RcPolyMesh, @@ -2143,9 +2274,14 @@ pub fn rc_build_poly_mesh_detail( dmesh.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_copy_poly_mesh(context: &mut RcContext, src: &RcPolyMesh, dst: &mut RcPolyMesh) -> RNResult<()> { let res = unsafe { ffi::rcCopyPolyMesh( @@ -2154,9 +2290,14 @@ pub fn rc_copy_poly_mesh(context: &mut RcContext, src: &RcPolyMesh, dst: &mut Rc dst.inner_mut(), ) }; - return if res { Ok(()) } else { Err(RNError::Failed) }; + if res { + Ok(()) + } else { + Err(RNError::Failed) + } } +#[inline] pub fn rc_merge_poly_mesh_details( context: &mut RcContext, meshes: &[&RcPolyMeshDetail], diff --git a/tests/common/file.rs b/tests/common/file.rs index 1091611..c260779 100644 --- a/tests/common/file.rs +++ b/tests/common/file.rs @@ -41,7 +41,7 @@ pub fn compare_with_cpp_out(rs_mesh: &DtNavMesh, folder: &str, name: &str) -> Re } } - return Ok(()); + Ok(()) } #[cfg(feature = "rkyv")] @@ -83,13 +83,13 @@ where expected_buf.extend_from_slice(&unaligned_buf); let archived = unsafe { rkyv::archived_root::(&expected_buf) }; - let mut deserializer = rkyv::Infallible::default(); + let mut deserializer = rkyv::Infallible; let expected = archived.deserialize(&mut deserializer)?; if data != &expected { return Err(format!("compare_with_rkyv({})", path).into()); } } - return Ok(()); + Ok(()) } #[cfg(not(feature = "rkyv"))] diff --git a/tests/common/state.rs b/tests/common/state.rs index 7e7bb36..bcbbb37 100644 --- a/tests/common/state.rs +++ b/tests/common/state.rs @@ -42,7 +42,7 @@ pub fn dump_heightfield_state(hf: &RcHeightfield) -> RcHeightfieldState { span = sp.next(); } } - return state; + state } #[derive(Debug, PartialEq)] @@ -112,8 +112,8 @@ pub fn dump_compact_heightfield_state(chf: &RcCompactHeightfield) -> RcCompactHe h: x.h(), }) .collect(), - dist: chf.dist().iter().map(|x| *x).collect(), - areas: chf.areas().iter().map(|x| *x).collect(), + dist: chf.dist().to_vec(), + areas: chf.areas().to_vec(), }; } diff --git a/tests/query.rs b/tests/query.rs index 34088de..2a375cb 100644 --- a/tests/query.rs +++ b/tests/query.rs @@ -3,7 +3,7 @@ use recastnavigation_rs::demo::*; use recastnavigation_rs::detour::*; use recastnavigation_rs::detour_crowd::*; -use recastnavigation_rs::XError; +use recastnavigation_rs::RNError; use rkyv::{Archive, Deserialize, Serialize}; mod common; @@ -99,12 +99,14 @@ struct PathFindStaightData { } fn path_find_straight(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> PathFindStaightData { - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = PathFindStaightData::default(); - data.start = start; - data.end = end; + let mut data = PathFindStaightData { + start, + end, + ..PathFindStaightData::default() + }; let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); let (end_ref, _) = query.find_nearest_poly_1(&end, &POLY_PICK_EXT, &filter).unwrap(); @@ -136,7 +138,7 @@ fn path_find_straight(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> P data.straight_path = straight_path[0..straight_size].to_vec(); data.straight_path_flags = straight_path_flags[0..straight_size].to_vec(); data.straight_path_refs = straight_path_refs[0..straight_size].to_vec(); - return data; + data } #[test] @@ -161,12 +163,14 @@ struct PathFindSlicedData { } fn path_find_sliced(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> PathFindSlicedData { - let mut query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let mut query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = PathFindSlicedData::default(); - data.start = start; - data.end = end; + let mut data = PathFindSlicedData { + start, + end, + ..PathFindSlicedData::default() + }; let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); let (end_ref, _) = query.find_nearest_poly_1(&end, &POLY_PICK_EXT, &filter).unwrap(); @@ -175,14 +179,14 @@ fn path_find_sliced(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat let mut result = query.init_sliced_find_path(start_ref, end_ref, &start, &end, &filter, true); loop { match &result { - Err(XError::InProgress) => { + Err(RNError::InProgress) => { result = query.update_sliced_find_path(1).map(|_| ()); } Ok(_) => { npolys = query.finalize_sliced_find_path(&mut polys).unwrap(); break; } - err @ _ => err.unwrap(), + err => err.unwrap(), } } let mut real_end = end; @@ -208,7 +212,7 @@ fn path_find_sliced(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat data.straight_path = straight_path[0..straight_size].to_vec(); data.straight_path_flags = straight_path_flags[0..straight_size].to_vec(); data.straight_path_refs = straight_path_refs[0..straight_size].to_vec(); - return data; + data } #[test] @@ -234,12 +238,14 @@ struct RaycastData { } fn raycast(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> RaycastData { - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = RaycastData::default(); - data.start = start; - data.end = end; + let mut data = RaycastData { + start, + end, + ..RaycastData::default() + }; let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); let mut path = vec![DtPolyRef::default(); MAX_POLYS]; @@ -266,7 +272,7 @@ fn raycast(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> RaycastData } data.hit_pos = hit_pos; data.hit_res = hit_res; - return data; + data } #[test] @@ -289,18 +295,20 @@ struct DistanceToWallData { } fn distance_to_wall(nav_mesh: &DtNavMesh, point: [f32; 3], _: [f32; 3]) -> DistanceToWallData { - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = DistanceToWallData::default(); - data.point = point; + let mut data = DistanceToWallData { + point, + ..DistanceToWallData::default() + }; let (point_ref, _) = query.find_nearest_poly_1(&point, &POLY_PICK_EXT, &filter).unwrap(); let (hit_distance, hit_pos, hit_normal) = query.find_distance_to_wall(point_ref, &point, 100.0, &filter).unwrap(); data.hit_distance = hit_distance; data.hit_pos = hit_pos; data.hit_normal = hit_normal; - return data; + data } #[test] @@ -324,12 +332,14 @@ struct FindPolysInCircleData { } fn find_polys_in_circle(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> FindPolysInCircleData { - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = FindPolysInCircleData::default(); - data.start = start; - data.end = end; + let mut data = FindPolysInCircleData { + start, + end, + ..FindPolysInCircleData::default() + }; let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); let dx = end[0] - start[0]; @@ -353,7 +363,7 @@ fn find_polys_in_circle(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> data.polys = polys[0..count].to_vec(); data.parents = parents[0..count].to_vec(); data.costs = costs[0..count].to_vec(); - return data; + data } #[test] @@ -380,12 +390,14 @@ struct FindPolysInShapeData { fn find_polys_in_shape(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> FindPolysInShapeData { const ANGLE_HEIGHT: f32 = 2.0; - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = FindPolysInShapeData::default(); - data.start = start; - data.end = end; + let mut data = FindPolysInShapeData { + start, + end, + ..FindPolysInShapeData::default() + }; let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); let nx = (end[2] - start[2]) * 0.25; @@ -414,7 +426,7 @@ fn find_polys_in_shape(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> data.polys = polys[0..count].to_vec(); data.parents = parents[0..count].to_vec(); data.costs = costs[0..count].to_vec(); - return data; + data } #[test] @@ -439,11 +451,13 @@ struct FindLocalNeighbourhoodData { fn find_local_neighbourhood(nav_mesh: &DtNavMesh, point: [f32; 3], _: [f32; 3]) -> FindLocalNeighbourhoodData { const RADIUS: f32 = 12.0; - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); - let mut data = FindLocalNeighbourhoodData::default(); - data.point = point; + let mut data = FindLocalNeighbourhoodData { + point, + ..FindLocalNeighbourhoodData::default() + }; let (point_ref, _) = query.find_nearest_poly_1(&point, &POLY_PICK_EXT, &filter).unwrap(); let mut polys = vec![DtPolyRef::default(); MAX_POLYS]; @@ -453,7 +467,7 @@ fn find_local_neighbourhood(nav_mesh: &DtNavMesh, point: [f32; 3], _: [f32; 3]) .unwrap(); data.polys = polys[0..count].to_vec(); data.parents = parents[0..count].to_vec(); - return data; + data } #[test] @@ -480,11 +494,13 @@ struct PathFindFollowData { } fn path_find_follow(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> PathFindFollowData { - let mut data = PathFindFollowData::default(); - data.start = start; - data.end = end; + let mut data = PathFindFollowData { + start, + end, + ..PathFindFollowData::default() + }; - let query = DtNavMeshQuery::with_mesh(&nav_mesh, 2048).unwrap(); + let query = DtNavMeshQuery::with_mesh(nav_mesh, 2048).unwrap(); let filter = DtQueryFilter::default(); let (start_ref, _) = query.find_nearest_poly_1(&start, &POLY_PICK_EXT, &filter).unwrap(); @@ -496,7 +512,7 @@ fn path_find_follow(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat .unwrap(); data.polys = polys[0..npolys].to_vec(); - if npolys <= 0 { + if npolys == 0 { return data; } @@ -509,7 +525,7 @@ fn path_find_follow(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat smooth_count += 1; while npolys > 0 && smooth_count < MAX_SMOOTH { - let steer = match get_steer_target(&query, iter_pos, target_pos, SLOP, &mut polys[0..npolys]) { + let steer = match get_steer_target(&query, iter_pos, target_pos, SLOP, &polys[0..npolys]) { Some(steer) => steer, None => break, }; @@ -534,7 +550,7 @@ fn path_find_follow(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat data.move_along_surface.push((result, nvisited)); npolys = merge_corridor_start_moved(&mut polys, npolys, &visited[0..nvisited]); - npolys = fixup_shortcuts(&nav_mesh, &mut polys[0..npolys]); + npolys = fixup_shortcuts(nav_mesh, &mut polys[0..npolys]); data.fixup_shortcuts.push(npolys); result[1] = query.get_poly_height(polys[0], &result).unwrap_or(result[1]); @@ -582,7 +598,7 @@ fn path_find_follow(nav_mesh: &DtNavMesh, start: [f32; 3], end: [f32; 3]) -> Pat } data.smooth_path = smooth_path[0..smooth_count].to_vec(); - return data; + data } #[derive(Debug, Default, Clone, PartialEq, Archive, Serialize, Deserialize)] @@ -641,14 +657,14 @@ fn get_steer_target( out.steer_pos_flag = steer_path_flags[ns]; out.steer_pos_ref = steer_path_polys[ns]; - return Some(out); + Some(out) } fn in_range(v1: &[f32; 3], v2: &[f32; 3], r: f32, h: f32) -> bool { let dx = v2[0] - v1[0]; let dy = v2[1] - v1[1]; let dz = v2[2] - v1[2]; - return (dx * dx + dz * dz) < r * r && dy.abs() < h; + (dx * dx + dz * dz) < r * r && dy.abs() < h } fn fixup_shortcuts(nav_mesh: &DtNavMesh, path: &mut [DtPolyRef]) -> usize { @@ -670,11 +686,9 @@ fn fixup_shortcuts(nav_mesh: &DtNavMesh, path: &mut [DtPolyRef]) -> usize { let mut k = poly.first_link; while k != DT_NULL_LINK { let link = &tile.links()[k as usize]; - if !link.re.is_null() { - if nneis < MAX_NEIS { - neis[nneis] = link.re; - nneis += 1; - } + if !link.re.is_null() && nneis < MAX_NEIS { + neis[nneis] = link.re; + nneis += 1; } k = link.next; } @@ -682,8 +696,8 @@ fn fixup_shortcuts(nav_mesh: &DtNavMesh, path: &mut [DtPolyRef]) -> usize { let mut cut = 0; let mut i = usize::min(MAX_LOOK_AHEAD, path.len()) - 1; while i > 1 && cut == 0 { - for j in 0..nneis { - if path[i] == neis[j] { + for nei in neis.iter().take(nneis) { + if path[i] == *nei { cut = i; break; } @@ -700,5 +714,5 @@ fn fixup_shortcuts(nav_mesh: &DtNavMesh, path: &mut [DtPolyRef]) -> usize { } } - return npath; + npath } diff --git a/tests/solo_mesh.rs b/tests/solo_mesh.rs index 1a189eb..3b757bf 100644 --- a/tests/solo_mesh.rs +++ b/tests/solo_mesh.rs @@ -123,7 +123,7 @@ fn build_nav_mesh(folder: &str, name: &str) -> DtNavMesh { // let mut chf = RcCompactHeightfield::new(); - rc_build_compact_heightfield(&mut ctx, cfg.walkable_height, cfg.walkable_climb, &mut solid, &mut chf).unwrap(); + rc_build_compact_heightfield(&mut ctx, cfg.walkable_height, cfg.walkable_climb, &solid, &mut chf).unwrap(); rc_erode_walkable_area(&mut ctx, cfg.walkable_radius, &mut chf).unwrap(); rc_build_distance_field(&mut ctx, &mut chf).unwrap(); rc_build_regions( @@ -143,7 +143,7 @@ fn build_nav_mesh(folder: &str, name: &str) -> DtNavMesh { let mut cset = RcContourSet::new(); rc_build_contours( &mut ctx, - &mut chf, + &chf, cfg.max_simplification_error, cfg.max_edge_len, &mut cset, @@ -196,27 +196,29 @@ fn build_nav_mesh(folder: &str, name: &str) -> DtNavMesh { } } - let mut params = DtNavMeshCreateParams::default(); - params.verts = Some(pmesh.verts()); - params.polys = Some(pmesh.polys()); - params.poly_areas = Some(pmesh.areas()); - params.poly_flags = Some(pmesh.flags()); - params.nvp = pmesh.nvp(); - params.detail_meshes = Some(dmesh.meshes()); - params.detail_verts = Some(dmesh.verts()); - params.detail_tris = Some(dmesh.tris()); - params.walkable_height = 2.0; - params.walkable_radius = 0.6; - params.walkable_climb = 0.9; - params.bmin = pmesh.bmin; - params.bmax = pmesh.bmax; - params.cs = cfg.cs; - params.ch = cfg.ch; - params.build_bv_tree = true; + let mut params = DtNavMeshCreateParams { + verts: Some(pmesh.verts()), + polys: Some(pmesh.polys()), + poly_areas: Some(pmesh.areas()), + poly_flags: Some(pmesh.flags()), + nvp: pmesh.nvp(), + detail_meshes: Some(dmesh.meshes()), + detail_verts: Some(dmesh.verts()), + detail_tris: Some(dmesh.tris()), + walkable_height: 2.0, + walkable_radius: 0.6, + walkable_climb: 0.9, + bmin: pmesh.bmin, + bmax: pmesh.bmax, + cs: cfg.cs, + ch: cfg.ch, + build_bv_tree: true, + ..DtNavMeshCreateParams::default() + }; let nav_data = dt_create_nav_mesh_data(&mut params).unwrap(); let nav_mesh = DtNavMesh::with_data(nav_data).unwrap(); compare_with_cpp_out(&nav_mesh, folder, name).unwrap(); - return nav_mesh; + nav_mesh } diff --git a/tests/tile_mesh.rs b/tests/tile_mesh.rs index 27afb46..3fe5d1c 100644 --- a/tests/tile_mesh.rs +++ b/tests/tile_mesh.rs @@ -1,4 +1,5 @@ #![cfg(feature = "rkyv")] +#![allow(clippy::too_many_arguments)] use recastnavigation_rs::demo::*; use recastnavigation_rs::detour::*; @@ -79,7 +80,7 @@ fn build_nav_mesh(folder: &str, name: &str, tile_size: f32, part: PartitionType) compare_with_cpp_out(&nav_mesh, folder, name).unwrap(); - return nav_mesh; + nav_mesh } fn build_nav_mesh_tile( @@ -176,17 +177,17 @@ fn build_nav_mesh_tile( let mut cid = [0; 64]; let ncid = rc_get_chunks_overlapping_rect( - &chunky_mesh, + chunky_mesh, &[cfg.bmin[0], cfg.bmin[2]], - &mut [cfg.bmax[0], cfg.bmax[2]], + &[cfg.bmax[0], cfg.bmax[2]], &mut cid, ); if ncid == 0 { return None; } - for i in 0..ncid { - let node = &chunky_mesh.nodes()[cid[i] as usize]; + for cid in cid.iter().take(ncid) { + let node = &chunky_mesh.nodes()[*cid as usize]; let tris = &chunky_mesh.tris()[node.i as usize..(node.i + node.n) as usize]; triareas[0..node.n as usize].fill(0); @@ -223,7 +224,7 @@ fn build_nav_mesh_tile( // between walkable cells will be calculated. let mut chf = RcCompactHeightfield::new(); - rc_build_compact_heightfield(&mut ctx, cfg.walkable_height, cfg.walkable_climb, &mut solid, &mut chf).unwrap(); + rc_build_compact_heightfield(&mut ctx, cfg.walkable_height, cfg.walkable_climb, &solid, &mut chf).unwrap(); // Erode the walkable area by agent radius. rc_erode_walkable_area(&mut ctx, cfg.walkable_radius, &mut chf).unwrap(); @@ -245,7 +246,7 @@ fn build_nav_mesh_tile( let mut cset = RcContourSet::new(); rc_build_contours( &mut ctx, - &mut chf, + &chf, cfg.max_simplification_error, cfg.max_edge_len, &mut cset, @@ -291,28 +292,30 @@ fn build_nav_mesh_tile( } } - let mut params = DtNavMeshCreateParams::default(); - params.verts = Some(pmesh.verts()); - params.polys = Some(pmesh.polys()); - params.poly_areas = Some(pmesh.areas()); - params.poly_flags = Some(pmesh.flags()); - params.nvp = pmesh.nvp(); - params.detail_meshes = Some(dmesh.meshes()); - params.detail_verts = Some(dmesh.verts()); - params.detail_tris = Some(dmesh.tris()); - params.walkable_height = 2.0; - params.walkable_radius = 0.6; - params.walkable_climb = 0.9; - params.tile_x = tx; - params.tile_y = ty; - params.tile_layer = 0; - params.bmin = pmesh.bmin; - params.bmax = pmesh.bmax; - params.cs = cfg.cs; - params.ch = cfg.ch; - params.build_bv_tree = true; + let mut params = DtNavMeshCreateParams { + verts: Some(pmesh.verts()), + polys: Some(pmesh.polys()), + poly_areas: Some(pmesh.areas()), + poly_flags: Some(pmesh.flags()), + nvp: pmesh.nvp(), + detail_meshes: Some(dmesh.meshes()), + detail_verts: Some(dmesh.verts()), + detail_tris: Some(dmesh.tris()), + walkable_height: 2.0, + walkable_radius: 0.6, + walkable_climb: 0.9, + tile_x: tx, + tile_y: ty, + tile_layer: 0, + bmin: pmesh.bmin, + bmax: pmesh.bmax, + cs: cfg.cs, + ch: cfg.ch, + build_bv_tree: true, + ..DtNavMeshCreateParams::default() + }; let nav_data = dt_create_nav_mesh_data(&mut params).unwrap(); - return Some(nav_data); + Some(nav_data) } fn next_pow2(mut v: i32) -> i32 { @@ -323,7 +326,7 @@ fn next_pow2(mut v: i32) -> i32 { v |= v >> 8; v |= v >> 16; v += 1; - return v; + v } fn ilog2(mut v: i32) -> i32 { @@ -346,5 +349,5 @@ fn ilog2(mut v: i32) -> i32 { r |= shift; r |= v >> 1; - return r; + r }