use crate::VoxelError;
pub const CHUNK_SIZE: i32 = 16;
pub const CHUNK_VOLUME: usize = 4096;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BlockPos {
pub x: i32,
pub y: i32,
pub z: i32,
}
impl BlockPos {
pub const fn new(x: i32, y: i32, z: i32) -> Self {
Self { x, y, z }
}
pub fn split(self) -> (ChunkPos, LocalPos) {
let chunk = ChunkPos::new(
self.x.div_euclid(CHUNK_SIZE),
self.y.div_euclid(CHUNK_SIZE),
self.z.div_euclid(CHUNK_SIZE),
);
let local = LocalPos {
x: self.x.rem_euclid(CHUNK_SIZE) as u8,
y: self.y.rem_euclid(CHUNK_SIZE) as u8,
z: self.z.rem_euclid(CHUNK_SIZE) as u8,
};
(chunk, local)
}
pub fn neighbor(self, face: Face) -> Option<Self> {
let [x, y, z] = face.normal();
Some(Self::new(
self.x.checked_add(x)?,
self.y.checked_add(y)?,
self.z.checked_add(z)?,
))
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ChunkPos {
pub x: i32,
pub y: i32,
pub z: i32,
}
impl ChunkPos {
pub const fn new(x: i32, y: i32, z: i32) -> Self {
Self { x, y, z }
}
pub fn origin(self) -> Result<BlockPos, VoxelError> {
let axis = |v: i32| {
let origin = v
.checked_mul(CHUNK_SIZE)
.ok_or(VoxelError::InvalidChunkPosition)?;
origin
.checked_add(CHUNK_SIZE - 1)
.ok_or(VoxelError::InvalidChunkPosition)?;
Ok(origin)
};
Ok(BlockPos::new(axis(self.x)?, axis(self.y)?, axis(self.z)?))
}
pub fn block(self, local: LocalPos) -> Result<BlockPos, VoxelError> {
let origin = self.origin()?;
Ok(BlockPos::new(
origin.x + i32::from(local.x),
origin.y + i32::from(local.y),
origin.z + i32::from(local.z),
))
}
pub fn neighbor(self, face: Face) -> Option<Self> {
let [x, y, z] = face.normal();
let next = Self::new(
self.x.checked_add(x)?,
self.y.checked_add(y)?,
self.z.checked_add(z)?,
);
next.origin().ok()?;
Some(next)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LocalPos {
x: u8,
y: u8,
z: u8,
}
impl LocalPos {
pub fn new(x: u8, y: u8, z: u8) -> Result<Self, VoxelError> {
if x >= 16 || y >= 16 || z >= 16 {
return Err(VoxelError::InvalidLocalPosition);
}
Ok(Self { x, y, z })
}
pub const fn x(self) -> u8 {
self.x
}
pub const fn y(self) -> u8 {
self.y
}
pub const fn z(self) -> u8 {
self.z
}
pub const fn index(self) -> usize {
self.x as usize + 16 * self.z as usize + 256 * self.y as usize
}
pub fn from_index(index: usize) -> Result<Self, VoxelError> {
if index >= CHUNK_VOLUME {
return Err(VoxelError::InvalidLocalPosition);
}
Ok(Self {
x: (index % 16) as u8,
y: (index / 256) as u8,
z: ((index / 16) % 16) as u8,
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum Face {
NegX = 0,
PosX = 1,
NegY = 2,
PosY = 3,
NegZ = 4,
PosZ = 5,
}
impl Face {
pub const ALL: [Self; 6] = [
Self::NegX,
Self::PosX,
Self::NegY,
Self::PosY,
Self::NegZ,
Self::PosZ,
];
pub const fn index(self) -> usize {
self as usize
}
pub const fn normal(self) -> [i32; 3] {
match self {
Self::NegX => [-1, 0, 0],
Self::PosX => [1, 0, 0],
Self::NegY => [0, -1, 0],
Self::PosY => [0, 1, 0],
Self::NegZ => [0, 0, -1],
Self::PosZ => [0, 0, 1],
}
}
pub const fn opposite(self) -> Self {
match self {
Self::NegX => Self::PosX,
Self::PosX => Self::NegX,
Self::NegY => Self::PosY,
Self::PosY => Self::NegY,
Self::NegZ => Self::PosZ,
Self::PosZ => Self::NegZ,
}
}
pub(crate) fn entering(axis: usize, step: i32) -> Self {
Self::ALL[axis * 2 + usize::from(step < 0)]
}
}