Skip to content

rename error #24

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Nov 4, 2024
Merged

rename error #24

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 5 additions & 5 deletions src/demo/demo.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,8 @@ use std::mem;
use std::pin::Pin;
use std::slice;

use crate::base::XError;
use crate::detour::DtNavMesh;
use crate::error::{RNError, RNResult};

#[allow(dead_code)]
#[cxx::bridge]
Expand Down Expand Up @@ -100,11 +100,11 @@ impl RcMeshLoaderObj {
}
}

pub fn load_nav_mesh(path: &str) -> Result<DtNavMesh, XError> {
pub fn load_nav_mesh(path: &str) -> RNResult<DtNavMesh> {
unsafe {
let mesh = ffi::loadNavMesh(path);
if mesh.is_null() {
return Err(XError::Failed);
return Err(RNError::Failed);
}
return Ok(DtNavMesh::from_ptr(mesh));
};
Expand Down Expand Up @@ -200,13 +200,13 @@ pub fn rc_create_chunky_tri_mesh(
verts: &[[f32; 3]],
tris: &[[i32; 3]],
tris_per_chunk: i32,
) -> Result<(), XError> {
) -> RNResult<()> {
let verts_ptr = verts.as_ptr() as *const f32;
let tris_ptr = tris.as_ptr() as *const i32;
let ntris = tris.len() as i32;
let result = unsafe { ffi::rcCreateChunkyTriMesh(verts_ptr, tris_ptr, ntris, tris_per_chunk, cm.0) };
if !result {
return Err(XError::Failed);
return Err(RNError::Failed);
}
return Ok(());
}
Expand Down
26 changes: 13 additions & 13 deletions src/detour/base.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
use cxx::{type_id, ExternType};

use crate::base::XError;
use crate::error::{RNError, RNResult};

#[repr(C)]
#[derive(Debug, Default, Clone, Copy, PartialEq)]
Expand Down Expand Up @@ -31,25 +31,25 @@ unsafe impl ExternType for DtStatus {
}

impl DtStatus {
pub fn to_result(self) -> Result<(), XError> {
pub fn to_result(self) -> RNResult<()> {
if self.0 & DT_SUCCESS != 0 {
return Ok(());
} else if self.0 & DT_FAILURE != 0 {
match self.0 & DT_STATUS_DETAIL_MASK {
DT_WRONG_MAGIC => return Err(XError::WrongMagic),
DT_WRONG_VERSION => return Err(XError::WrongVersion),
DT_OUT_OF_MEMORY => return Err(XError::OutOfMemory),
DT_INVALID_PARAM => return Err(XError::InvalidParam),
DT_BUFFER_TOO_SMALL => return Err(XError::BufferTooSmall),
DT_OUT_OF_NODES => return Err(XError::OutOfNodes),
DT_PARTIAL_RESULT => return Err(XError::PartialResult),
DT_ALREADY_OCCUPIED => return Err(XError::AlreadyOccupied),
_ => return Err(XError::Failed),
DT_WRONG_MAGIC => return Err(RNError::WrongMagic),
DT_WRONG_VERSION => return Err(RNError::WrongVersion),
DT_OUT_OF_MEMORY => return Err(RNError::OutOfMemory),
DT_INVALID_PARAM => return Err(RNError::InvalidParam),
DT_BUFFER_TOO_SMALL => return Err(RNError::BufferTooSmall),
DT_OUT_OF_NODES => return Err(RNError::OutOfNodes),
DT_PARTIAL_RESULT => return Err(RNError::PartialResult),
DT_ALREADY_OCCUPIED => return Err(RNError::AlreadyOccupied),
_ => return Err(RNError::Failed),
}
} else if self.0 & DT_IN_PROGRESS != 0 {
return Err(XError::InProgress);
return Err(RNError::InProgress);
} else {
return Err(XError::Failed);
return Err(RNError::Failed);
}
}
}
Expand Down
38 changes: 19 additions & 19 deletions src/detour/builder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,9 +3,9 @@ use static_assertions::const_assert_eq;
use std::fmt::{self, Debug, Formatter};
use std::mem;

use crate::base::XError;
use crate::detour::base::{DtAABB, DtBuf};
use crate::detour::mesh::DT_VERTS_PER_POLYGON;
use crate::error::{RNError, RNResult};

#[cxx::bridge]
pub(crate) mod ffi {
Expand Down Expand Up @@ -170,73 +170,73 @@ impl CxxDtNavMeshCreateParams {
}
}

pub fn dt_create_nav_mesh_data(params: &mut DtNavMeshCreateParams) -> Result<DtBuf, XError> {
pub fn dt_create_nav_mesh_data(params: &mut DtNavMeshCreateParams) -> RNResult<DtBuf> {
let mut cp = CxxDtNavMeshCreateParams::from(params);

if cp.vert_count < 3 || cp.vert_count >= 0xFFFF {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}

if cp.poly_count < 1 {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.polys) != cp.poly_count * 2 * cp.nvp {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.poly_flags) != cp.poly_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.poly_areas) != cp.poly_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if cp.nvp < 3 || cp.nvp > DT_VERTS_PER_POLYGON as i32 {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}

if cp.detail_meshes.is_null() {
if unpack_len(params.detail_meshes) != cp.poly_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
}

if unpack_len(params.off_mesh_con_rad) != cp.off_mesh_con_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.off_mesh_con_flags) != cp.off_mesh_con_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.off_mesh_con_areas) != cp.off_mesh_con_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.off_mesh_con_dir) != cp.off_mesh_con_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}
if unpack_len(params.off_mesh_con_user_id) != cp.off_mesh_con_count {
return Err(XError::InvalidParam);
return Err(RNError::InvalidParam);
}

unsafe {
let mut buf = DtBuf::default();
let res = ffi::dtCreateNavMeshData((&mut cp) as *mut _, &mut buf.data, &mut buf.size);
if !res {
return Err(XError::Failed);
return Err(RNError::Failed);
}
return Ok(buf);
}
}

pub fn dt_nav_mesh_header_swap_endian(buf: &mut DtBuf) -> Result<(), XError> {
pub fn dt_nav_mesh_header_swap_endian(buf: &mut DtBuf) -> RNResult<()> {
let res = unsafe { ffi::dtNavMeshHeaderSwapEndian(buf.data, buf.size) };
if !res {
return Err(XError::Failed);
return Err(RNError::Failed);
}
return Ok(());
}

pub fn dt_nav_mesh_data_swap_endian(buf: &mut DtBuf) -> Result<(), XError> {
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(XError::Failed);
return Err(RNError::Failed);
}
return Ok(());
}
26 changes: 13 additions & 13 deletions src/detour/mesh.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,8 +5,8 @@ use std::ops::{Deref, DerefMut};
use std::pin::Pin;
use std::{mem, ptr};

use crate::base::XError;
use crate::detour::base::{DtAABB, DtBuf};
use crate::error::RNResult;

pub const DT_VERTS_PER_POLYGON: usize = 6;

Expand Down Expand Up @@ -591,13 +591,13 @@ impl DtNavMesh {
return self.0;
}

pub fn with_params(params: &DtNavMeshParams) -> Result<DtNavMesh, XError> {
pub fn with_params(params: &DtNavMeshParams) -> RNResult<DtNavMesh> {
let mut mesh = DtNavMesh::new();
unsafe { mesh.inner_mut().init_with_params(params) }.to_result()?;
return Ok(mesh);
}

pub fn with_data(buf: DtBuf) -> Result<DtNavMesh, XError> {
pub fn with_data(buf: DtBuf) -> RNResult<DtNavMesh> {
let mut mesh = DtNavMesh::new();
unsafe {
mesh.inner_mut()
Expand All @@ -612,7 +612,7 @@ impl DtNavMesh {
return unsafe { &*self.inner().getParams() };
}

pub fn add_tile(&mut self, buf: DtBuf, last_ref: DtTileRef) -> Result<DtTileRef, XError> {
pub fn add_tile(&mut self, buf: DtBuf, last_ref: DtTileRef) -> RNResult<DtTileRef> {
let mut re = DtTileRef::default();
unsafe {
self.inner_mut()
Expand All @@ -623,7 +623,7 @@ impl DtNavMesh {
return Ok(re);
}

pub fn remove_tile(&mut self, re: DtTileRef) -> Result<(), XError> {
pub fn remove_tile(&mut self, re: DtTileRef) -> RNResult<()> {
return unsafe { self.inner_mut().removeTile(re, ptr::null_mut(), ptr::null_mut()) }.to_result();
}

Expand Down Expand Up @@ -680,7 +680,7 @@ impl DtNavMesh {
}
}

pub fn get_tile_and_poly_by_ref(&self, re: DtPolyRef) -> Result<(&DtMeshTile, &DtPoly), XError> {
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()?;
Expand All @@ -706,7 +706,7 @@ impl DtNavMesh {
&self,
prev_ref: DtPolyRef,
poly_ref: DtPolyRef,
) -> Result<([f32; 3], [f32; 3]), XError> {
) -> RNResult<([f32; 3], [f32; 3])> {
let mut start_pos = [0.0; 3];
let mut end_pos = [0.0; 3];
unsafe {
Expand All @@ -721,21 +721,21 @@ impl DtNavMesh {
return unsafe { &*self.inner().getOffMeshConnectionByRef(re) };
}

pub fn set_poly_flags(&mut self, re: DtPolyRef, flags: u16) -> Result<(), XError> {
pub fn set_poly_flags(&mut self, re: DtPolyRef, flags: u16) -> RNResult<()> {
return self.inner_mut().setPolyFlags(re, flags).to_result();
}

pub fn get_poly_flags(&self, re: DtPolyRef) -> Result<u16, XError> {
pub fn get_poly_flags(&self, re: DtPolyRef) -> RNResult<u16> {
let mut flags = 0;
unsafe { self.inner().getPolyFlags(re, &mut flags) }.to_result()?;
return Ok(flags);
}

pub fn set_poly_area(&mut self, re: DtPolyRef, area: u8) -> Result<(), XError> {
pub fn set_poly_area(&mut self, re: DtPolyRef, area: u8) -> RNResult<()> {
return self.inner_mut().setPolyArea(re, area).to_result();
}

pub fn get_poly_area(&self, re: DtPolyRef) -> Result<u8, XError> {
pub fn get_poly_area(&self, re: DtPolyRef) -> RNResult<u8> {
let mut area = 0;
unsafe { self.inner().getPolyArea(re, &mut area) }.to_result()?;
return Ok(area);
Expand All @@ -745,11 +745,11 @@ impl DtNavMesh {
return self.inner().getTileStateSize(tile.inner()) as usize;
}

pub unsafe fn store_tile_state(&self, re: DtTileRef, data: &mut [u8]) -> Result<(), XError> {
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();
}

pub unsafe fn restore_tile_state(&mut self, re: DtTileRef, data: &[u8]) -> Result<(), XError> {
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();
}
Expand Down
Loading
Loading