use std::collections::HashMap;
use std::hash::Hash;
use bevy::prelude::Resource;
pub trait VoxelType:
Copy + Clone + Default + Send + Sync + PartialEq + Eq + Hash + 'static
{
fn name(&self) -> &'static str;
fn is_solid(&self) -> bool;
fn color(&self) -> [f32; 4];
fn to_byte(&self) -> u8;
fn from_byte(byte: u8) -> Self;
fn hardness(&self) -> f32 {
1.0
}
fn mining_level(&self) -> u8 {
0
}
fn texture_layer(&self, _face_index: usize) -> u32 {
0
}
#[inline]
fn texture_layer_for_state(&self, face_index: usize, _state: u8) -> u32 {
self.texture_layer(face_index)
}
fn air() -> Self {
Self::default()
}
fn movement_modifier(&self) -> MovementModifier {
MovementModifier::default()
}
#[inline]
fn alpha(&self) -> f32 {
1.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MovementModifier {
pub speed_mult: f32,
pub jump_mult: f32,
pub gravity_mult: f32,
pub friction_mult: f32,
}
impl Default for MovementModifier {
fn default() -> Self {
Self {
speed_mult: 1.0,
jump_mult: 1.0,
gravity_mult: 1.0,
friction_mult: 1.0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum DefaultVoxel {
#[default]
Air,
Rock,
IronOre,
SiliconCrystal,
RareMineral,
}
impl VoxelType for DefaultVoxel {
#[inline]
fn name(&self) -> &'static str {
match self {
DefaultVoxel::Air => "Air",
DefaultVoxel::Rock => "Rock",
DefaultVoxel::IronOre => "Iron Ore",
DefaultVoxel::SiliconCrystal => "Silicon Crystal",
DefaultVoxel::RareMineral => "Rare Mineral",
}
}
#[inline]
fn is_solid(&self) -> bool {
!matches!(self, DefaultVoxel::Air)
}
#[inline]
fn color(&self) -> [f32; 4] {
match self {
DefaultVoxel::Air => [0.0, 0.0, 0.0, 0.0],
DefaultVoxel::Rock => [0.35, 0.30, 0.28, 1.0],
DefaultVoxel::IronOre => [0.55, 0.35, 0.20, 1.0],
DefaultVoxel::SiliconCrystal => [0.40, 0.50, 0.80, 1.0],
DefaultVoxel::RareMineral => [0.20, 0.85, 0.60, 1.0],
}
}
#[inline]
fn to_byte(&self) -> u8 {
match self {
DefaultVoxel::Air => 0,
DefaultVoxel::Rock => 1,
DefaultVoxel::IronOre => 2,
DefaultVoxel::SiliconCrystal => 3,
DefaultVoxel::RareMineral => 4,
}
}
#[inline]
fn from_byte(byte: u8) -> Self {
match byte {
0 => DefaultVoxel::Air,
1 => DefaultVoxel::Rock,
2 => DefaultVoxel::IronOre,
3 => DefaultVoxel::SiliconCrystal,
4 => DefaultVoxel::RareMineral,
_ => DefaultVoxel::Air,
}
}
#[inline]
fn hardness(&self) -> f32 {
match self {
DefaultVoxel::Air => 0.0,
DefaultVoxel::Rock => 3.0,
DefaultVoxel::IronOre => 4.0,
DefaultVoxel::SiliconCrystal => 2.5,
DefaultVoxel::RareMineral => 5.0,
}
}
#[inline]
fn mining_level(&self) -> u8 {
match self {
DefaultVoxel::Air => 0,
DefaultVoxel::Rock => 1,
DefaultVoxel::IronOre => 2,
DefaultVoxel::SiliconCrystal => 1,
DefaultVoxel::RareMineral => 2,
}
}
#[inline]
fn texture_layer(&self, _face_index: usize) -> u32 {
match self {
DefaultVoxel::Air => 0,
DefaultVoxel::Rock => 1,
DefaultVoxel::IronOre => 2,
DefaultVoxel::SiliconCrystal => 3,
DefaultVoxel::RareMineral => 4,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum DefaultTerrainVoxel {
#[default]
Air,
Grass,
Dirt,
Stone,
Sand,
Wood,
Leaves,
Gravel,
Snow,
Water,
CoalOre,
IronOre,
Cobblestone,
Sandstone,
Planks,
Brick,
}
impl VoxelType for DefaultTerrainVoxel {
#[inline]
fn name(&self) -> &'static str {
match self {
DefaultTerrainVoxel::Air => "Air",
DefaultTerrainVoxel::Grass => "Grass",
DefaultTerrainVoxel::Dirt => "Dirt",
DefaultTerrainVoxel::Stone => "Stone",
DefaultTerrainVoxel::Sand => "Sand",
DefaultTerrainVoxel::Wood => "Wood",
DefaultTerrainVoxel::Leaves => "Leaves",
DefaultTerrainVoxel::Gravel => "Gravel",
DefaultTerrainVoxel::Snow => "Snow",
DefaultTerrainVoxel::Water => "Water",
DefaultTerrainVoxel::CoalOre => "Coal Ore",
DefaultTerrainVoxel::IronOre => "Iron Ore",
DefaultTerrainVoxel::Cobblestone => "Cobblestone",
DefaultTerrainVoxel::Sandstone => "Sandstone",
DefaultTerrainVoxel::Planks => "Planks",
DefaultTerrainVoxel::Brick => "Brick",
}
}
#[inline]
fn is_solid(&self) -> bool {
!matches!(self, DefaultTerrainVoxel::Air | DefaultTerrainVoxel::Water)
}
#[inline]
fn color(&self) -> [f32; 4] {
match self {
DefaultTerrainVoxel::Air => [0.0, 0.0, 0.0, 0.0],
DefaultTerrainVoxel::Grass => [0.30, 0.60, 0.20, 1.0],
DefaultTerrainVoxel::Dirt => [0.50, 0.35, 0.20, 1.0],
DefaultTerrainVoxel::Stone => [0.50, 0.50, 0.50, 1.0],
DefaultTerrainVoxel::Sand => [0.85, 0.80, 0.50, 1.0],
DefaultTerrainVoxel::Wood => [0.45, 0.30, 0.18, 1.0],
DefaultTerrainVoxel::Leaves => [0.20, 0.55, 0.15, 1.0],
DefaultTerrainVoxel::Gravel => [0.55, 0.52, 0.50, 1.0],
DefaultTerrainVoxel::Snow => [0.92, 0.95, 0.98, 1.0],
DefaultTerrainVoxel::Water => [0.15, 0.40, 0.75, 0.7],
DefaultTerrainVoxel::CoalOre => [0.30, 0.30, 0.30, 1.0],
DefaultTerrainVoxel::IronOre => [0.60, 0.45, 0.35, 1.0],
DefaultTerrainVoxel::Cobblestone => [0.40, 0.40, 0.40, 1.0],
DefaultTerrainVoxel::Sandstone => [0.80, 0.72, 0.45, 1.0],
DefaultTerrainVoxel::Planks => [0.65, 0.48, 0.28, 1.0],
DefaultTerrainVoxel::Brick => [0.65, 0.28, 0.20, 1.0],
}
}
#[inline]
fn to_byte(&self) -> u8 {
match self {
DefaultTerrainVoxel::Air => 0,
DefaultTerrainVoxel::Grass => 1,
DefaultTerrainVoxel::Dirt => 2,
DefaultTerrainVoxel::Stone => 3,
DefaultTerrainVoxel::Sand => 4,
DefaultTerrainVoxel::Wood => 5,
DefaultTerrainVoxel::Leaves => 6,
DefaultTerrainVoxel::Gravel => 7,
DefaultTerrainVoxel::Snow => 8,
DefaultTerrainVoxel::Water => 9,
DefaultTerrainVoxel::CoalOre => 10,
DefaultTerrainVoxel::IronOre => 11,
DefaultTerrainVoxel::Cobblestone => 12,
DefaultTerrainVoxel::Sandstone => 13,
DefaultTerrainVoxel::Planks => 14,
DefaultTerrainVoxel::Brick => 15,
}
}
#[inline]
fn from_byte(byte: u8) -> Self {
match byte {
1 => DefaultTerrainVoxel::Grass,
2 => DefaultTerrainVoxel::Dirt,
3 => DefaultTerrainVoxel::Stone,
4 => DefaultTerrainVoxel::Sand,
5 => DefaultTerrainVoxel::Wood,
6 => DefaultTerrainVoxel::Leaves,
7 => DefaultTerrainVoxel::Gravel,
8 => DefaultTerrainVoxel::Snow,
9 => DefaultTerrainVoxel::Water,
10 => DefaultTerrainVoxel::CoalOre,
11 => DefaultTerrainVoxel::IronOre,
12 => DefaultTerrainVoxel::Cobblestone,
13 => DefaultTerrainVoxel::Sandstone,
14 => DefaultTerrainVoxel::Planks,
15 => DefaultTerrainVoxel::Brick,
_ => DefaultTerrainVoxel::Air,
}
}
#[inline]
fn hardness(&self) -> f32 {
match self {
DefaultTerrainVoxel::Air => 0.0, DefaultTerrainVoxel::Grass => 0.5,
DefaultTerrainVoxel::Dirt => 0.5,
DefaultTerrainVoxel::Stone => 3.0,
DefaultTerrainVoxel::Sand => 0.5,
DefaultTerrainVoxel::Wood => 1.5,
DefaultTerrainVoxel::Leaves => 0.3,
DefaultTerrainVoxel::Gravel => 0.75,
DefaultTerrainVoxel::Snow => 0.3,
DefaultTerrainVoxel::Water => 0.0, DefaultTerrainVoxel::CoalOre => 3.0,
DefaultTerrainVoxel::IronOre => 4.0,
DefaultTerrainVoxel::Cobblestone => 2.5,
DefaultTerrainVoxel::Sandstone => 1.5,
DefaultTerrainVoxel::Planks => 1.0,
DefaultTerrainVoxel::Brick => 2.0,
}
}
#[inline]
fn mining_level(&self) -> u8 {
match self {
DefaultTerrainVoxel::Stone => 1,
DefaultTerrainVoxel::Gravel => 1,
DefaultTerrainVoxel::CoalOre => 1,
DefaultTerrainVoxel::IronOre => 2,
DefaultTerrainVoxel::Cobblestone => 1,
DefaultTerrainVoxel::Sandstone => 1,
DefaultTerrainVoxel::Brick => 1,
_ => 0,
}
}
#[inline]
fn texture_layer(&self, _face_index: usize) -> u32 {
match self {
DefaultTerrainVoxel::Air => 0,
DefaultTerrainVoxel::Grass => 1,
DefaultTerrainVoxel::Dirt => 2,
DefaultTerrainVoxel::Stone => 3,
DefaultTerrainVoxel::Sand => 4,
DefaultTerrainVoxel::Wood => 5,
DefaultTerrainVoxel::Leaves => 6,
DefaultTerrainVoxel::Gravel => 7,
DefaultTerrainVoxel::Snow => 8,
DefaultTerrainVoxel::Water => 9,
DefaultTerrainVoxel::CoalOre => 10,
DefaultTerrainVoxel::IronOre => 11,
DefaultTerrainVoxel::Cobblestone => 12,
DefaultTerrainVoxel::Sandstone => 13,
DefaultTerrainVoxel::Planks => 14,
DefaultTerrainVoxel::Brick => 15,
}
}
#[inline]
fn movement_modifier(&self) -> MovementModifier {
match self {
DefaultTerrainVoxel::Water => MovementModifier {
speed_mult: 0.4,
jump_mult: 0.5,
gravity_mult: 1.0,
friction_mult: 1.0,
},
DefaultTerrainVoxel::Snow => MovementModifier {
speed_mult: 0.7,
..MovementModifier::default()
},
_ => MovementModifier::default(),
}
}
#[inline]
fn alpha(&self) -> f32 {
match self {
Self::Water => 0.7,
_ => 1.0,
}
}
}
#[derive(Resource, Clone, Debug)]
pub struct VoxelPalette<V: VoxelType> {
colors: HashMap<V, [f32; 4]>,
}
impl<V: VoxelType> VoxelPalette<V> {
pub fn new(colors: HashMap<V, [f32; 4]>) -> Self {
Self { colors }
}
#[inline]
pub fn color_of(&self, voxel: &V) -> [f32; 4] {
self.colors
.get(voxel)
.copied()
.unwrap_or_else(|| voxel.color())
}
}
impl<V: VoxelType> Default for VoxelPalette<V> {
fn default() -> Self {
Self {
colors: HashMap::new(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_voxel_hardness_overrides() {
assert_eq!(DefaultVoxel::Air.hardness(), 0.0);
assert_eq!(DefaultVoxel::Rock.hardness(), 3.0);
assert_eq!(DefaultVoxel::IronOre.hardness(), 4.0);
assert_eq!(DefaultVoxel::SiliconCrystal.hardness(), 2.5);
assert_eq!(DefaultVoxel::RareMineral.hardness(), 5.0);
}
#[test]
fn default_voxel_mining_level_overrides() {
assert_eq!(DefaultVoxel::Air.mining_level(), 0);
assert_eq!(DefaultVoxel::Rock.mining_level(), 1);
assert_eq!(DefaultVoxel::IronOre.mining_level(), 2);
assert_eq!(DefaultVoxel::SiliconCrystal.mining_level(), 1);
assert_eq!(DefaultVoxel::RareMineral.mining_level(), 2);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
enum MinimalVoxel {
#[default]
Air,
Solid,
}
impl VoxelType for MinimalVoxel {
fn name(&self) -> &'static str {
match self {
MinimalVoxel::Air => "Air",
MinimalVoxel::Solid => "Solid",
}
}
fn is_solid(&self) -> bool {
matches!(self, MinimalVoxel::Solid)
}
fn color(&self) -> [f32; 4] {
[0.0, 0.0, 0.0, 1.0]
}
fn to_byte(&self) -> u8 {
match self {
MinimalVoxel::Air => 0,
MinimalVoxel::Solid => 1,
}
}
fn from_byte(byte: u8) -> Self {
match byte {
1 => MinimalVoxel::Solid,
_ => MinimalVoxel::Air,
}
}
}
#[test]
fn voxel_type_trait_defaults() {
assert_eq!(MinimalVoxel::Solid.hardness(), 1.0);
assert_eq!(MinimalVoxel::Solid.mining_level(), 0);
assert_eq!(MinimalVoxel::Air.hardness(), 1.0);
assert_eq!(MinimalVoxel::Air.mining_level(), 0);
}
}