owo

Cargo.lock

@@ -1026,6 +1026,7 @@ dependencies = [
  "hashbrown 0.14.2",
  "nohash-hasher",
  "num_enum",
+ "nz",
  "postcard",
  "rand",
  "rand_xoshiro",
@@ -1325,6 +1326,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "nz"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28ba9cab725a7d7ece4bbf38968a1717ed73abf0516f7ff90a4127d016bebd51"
+
 [[package]]
 name = "objc-sys"
 version = "0.3.1"

kubi-shared/Cargo.toml

@@ -20,6 +20,7 @@ hashbrown = { version = "0.14", features = ["serde"] }
 nohash-hasher = "0.2"
 #bytemuck = { version = "1.14", features = ["derive"] }
 static_assertions = "1.1"
+nz = "0.3"
 
 [features]
 default = []

kubi-shared/src/block.rs

@@ -1,6 +1,7 @@
 use serde::{Serialize, Deserialize};
 use strum::EnumIter;
 use num_enum::TryFromPrimitive;
+use crate::item::Item;
 
 #[derive(Serialize, Deserialize, Clone, Copy, Debug, EnumIter)]
 #[repr(u8)]
@@ -50,82 +51,95 @@ impl Block {
         render: RenderType::None,
         collision: CollisionType::None,
         raycast_collision: false,
+        drops: None,
       },
       Self::Marker => BlockDescriptor {
         name: "marker",
         render: RenderType::None,
         collision: CollisionType::None,
         raycast_collision: false,
+        drops: None,
       },
-      Self::Stone => BlockDescriptor { 
+      Self::Stone => BlockDescriptor {
-        name: "stone", 
+        name: "stone",
-        render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Stone)), 
+        render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Stone)),
-        collision: CollisionType::Solid, 
+        collision: CollisionType::Solid,
-        raycast_collision: true, 
+        raycast_collision: true,
+        drops: None,
       },
-      Self::Dirt => BlockDescriptor { 
+      Self::Dirt => BlockDescriptor {
-        name: "dirt", 
+        name: "dirt",
-        render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Dirt)), 
+        render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Dirt)),
-        collision: CollisionType::Solid, 
+        collision: CollisionType::Solid,
-        raycast_collision: true, 
+        raycast_collision: true,
+        drops: None,
       },
-      Self::Grass => BlockDescriptor { 
+      Self::Grass => BlockDescriptor {
-        name: "grass", 
+        name: "grass",
         render: RenderType::SolidBlock(CubeTexture::top_sides_bottom(
-          BlockTexture::GrassTop, 
+          BlockTexture::GrassTop,
-          BlockTexture::GrassSide, 
+          BlockTexture::GrassSide,
           BlockTexture::Dirt
-        )), 
+        )),
-        collision: CollisionType::Solid, 
+        collision: CollisionType::Solid,
-        raycast_collision: true, 
+        raycast_collision: true,
+        drops: None,
       },
-      Self::Sand => BlockDescriptor { 
+      Self::Sand => BlockDescriptor {
-        name: "sand", 
+        name: "sand",
         render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Sand)), 
-        collision: CollisionType::Solid, 
+        collision: CollisionType::Solid,
-        raycast_collision: true, 
+        raycast_collision: true,
+        drops: None,
       },
       Self::Cobblestone => BlockDescriptor {
         name: "cobblestone",
         render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Cobblestone)),
         collision: CollisionType::Solid,
         raycast_collision: true,
+        drops: None,
       },
       Self::TallGrass => BlockDescriptor {
         name: "tall grass",
         render: RenderType::CrossShape(CrossTexture::all(BlockTexture::TallGrass)),
         collision: CollisionType::None,
         raycast_collision: true,
+        drops: None,
       },
-      Self::Planks => BlockDescriptor { 
+      Self::Planks => BlockDescriptor {
-        name: "planks", 
+        name: "planks",
         render: RenderType::SolidBlock(CubeTexture::all(BlockTexture::Planks)), 
         collision: CollisionType::Solid, 
         raycast_collision: true, 
+        drops: None,
       },
       Self::Torch => BlockDescriptor {
         name: "torch",
         render: RenderType::CrossShape(CrossTexture::all(BlockTexture::Torch)),
         collision: CollisionType::None,
         raycast_collision: true,
+        drops: None,
       },
       Self::Wood => BlockDescriptor {
         name: "leaf",
         render: RenderType::SolidBlock(CubeTexture::horizontal_vertical(BlockTexture::Wood, BlockTexture::WoodTop)),
         collision: CollisionType::Solid,
         raycast_collision: true,
+        drops: None,
       },
       Self::Leaf => BlockDescriptor {
         name: "leaf",
         render: RenderType::BinaryTransparency(CubeTexture::all(BlockTexture::Leaf)),
         collision: CollisionType::Solid,
         raycast_collision: true,
+        drops: None,
       },
       Self::Water => BlockDescriptor {
         name: "water",
         render: RenderType::BinaryTransparency(CubeTexture::all(BlockTexture::WaterSolid)),
         collision: CollisionType::None,
         raycast_collision: true,
+        drops: None,
       },
     }
   }
@@ -137,12 +151,8 @@ pub struct BlockDescriptor {
   pub render: RenderType,
   pub collision: CollisionType,
   pub raycast_collision: bool,
+  pub drops: Option<Item>,
 }
-// impl BlockDescriptor {
-//   pub fn of(block: Block) -> Self {
-//     block.descriptor()
-//   }
-// }
 
 #[derive(Clone, Copy, Debug)]
 pub struct CubeTexture {

kubi-shared/src/item.rs

@@ -0,0 +1,66 @@
+use std::num::NonZeroU8;
+use num_enum::TryFromPrimitive;
+use serde::{Serialize, Deserialize};
+use strum::EnumIter;
+use crate::block::Block;
+
+#[derive(Clone, Copy)]
+pub enum ItemUsage {
+  AsBlock(Block)
+}
+
+pub struct ItemDescriptor {
+  pub name: &'static str,
+  pub usage: Option<ItemUsage>,
+  pub stack_size: NonZeroU8,
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Hash, Debug, EnumIter, TryFromPrimitive)]
+#[repr(u8)]
+pub enum Item {
+  TestItem,
+}
+
+impl Item {
+  #[inline]
+  pub const fn descriptor(self) -> ItemDescriptor {
+    match self {
+      Self::TestItem => ItemDescriptor {
+        name: "Test Item",
+        usage: None,
+        stack_size: nz::u8!(32),
+      },
+    }
+  }
+}
+
+#[derive(Clone, Copy)]
+pub struct ItemCollection(Option<(Item, NonZeroU8)>);
+
+impl ItemCollection {
+  pub const fn new(item: Item, amount: NonZeroU8) -> Self {
+    Self(Some((item, amount)))
+  }
+
+  pub const fn new_single(item: Item) -> Self {
+    Self(Some((item, nz::u8!(1))))
+  }
+
+  pub const fn new_empty() -> Self {
+    Self(None)
+  }
+
+  pub const fn with_amount(&self, amount: NonZeroU8) -> Self {
+    Self(match self.0 {
+      Some((item, _)) => Some((item, amount)),
+      None => None,
+    })
+  }
+
+  /// Add items from another slot, copying them\
+  /// Returns the leftover items
+  pub fn add(&mut self, from: &Self) -> Self {
+    let Some((item, count)) = from.0 else { return Self::new_empty() };
+    todo!() //TODO finish item slot system
+  }
+}

kubi-shared/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod block;
+pub mod item;
 pub mod networking;
 pub mod worldgen;
 pub mod chunk;

kubi-ui/src/draw.rs

@@ -1,6 +1,8 @@
+use std::borrow::Cow;
 use glam::{Vec2, Vec4, vec2};
+use crate::text::TextRenderer;
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum UiDrawCommand {
   ///Filled, colored rectangle
   Rectangle {
@@ -10,7 +12,17 @@ pub enum UiDrawCommand {
     size: Vec2,
     ///Color (RGBA)
     color: Vec4,
-  }
+  },
+  Text {
+    ///Position in pixels
+    position: Vec2,
+    ///Font size
+    size: u8,
+    ///Color (RGBA)
+    color: Vec4,
+    ///Text to draw
+    text: Cow<'static, str>,
+  },
 }
 
 #[derive(Default)]
@@ -25,6 +37,11 @@ pub struct UiDrawCommands {
 //   }
 // }
 
+pub enum BindTexture {
+  FontTexture,
+  //UserDefined(usize),
+}
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct UiVertex {
   pub position: Vec2,
@@ -45,7 +62,7 @@ pub struct UiDrawPlan {
 }
 
 impl UiDrawPlan {
-  pub fn build(calls: &UiDrawCommands) -> Self {
+  pub fn build(calls: &UiDrawCommands, tr: &mut TextRenderer) -> Self {
     let mut call = UiDrawCall::default();
     for command in &calls.commands {
       match command {
@@ -74,6 +91,9 @@ impl UiDrawPlan {
               uv: vec2(0.0, 1.0),
             },
           ]);
+        },
+        UiDrawCommand::Text { position, size, color, text } => {
+          todo!()
         }
       }
     }

kubi-ui/src/lib.rs

@@ -15,11 +15,11 @@ use event::UiEvent;
 use draw::{UiDrawCommands, UiDrawPlan};
 use text::TextRenderer;
 
-pub struct ElementContext<'a> {
+// pub struct ElementContext<'a> {
-  pub state: &'a mut StateRepo,
+//   pub state: &'a mut StateRepo,
-  pub draw: &'a mut UiDrawCommands,
+//   pub draw: &'a mut UiDrawCommands,
-  pub text: &'a mut TextRenderer,
+//   pub text: &'a mut TextRenderer,
-}
+// }
 
 pub struct KubiUi {
   mouse_position: Vec2,
@@ -67,7 +67,7 @@ impl KubiUi {
     if self.draw_commands.commands == self.prev_draw_commands.commands {
       return
     }
-    self.draw_plan = UiDrawPlan::build(&self.draw_commands);
+    self.draw_plan = UiDrawPlan::build(&self.draw_commands, &mut self.font_renderer);
     self.draw_plan_modified = true;
   }
 

kubi-ui/src/text.rs

@@ -10,6 +10,9 @@ const BIN_FONT: &[u8] = include_bytes!("../assets/font/ProggyTiny.ttf");
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct FontHandle(pub(crate) usize);
 
+#[cfg(feature = "builtin_font")]
+pub const BUILTIN_FONT: FontHandle = FontHandle(0);
+
 #[derive(PartialEq, Eq, Hash)]
 struct GlyphCacheKey {
   font_index: usize,