rect, rectfill and fillp

Author: funmaker

Cargo.lock

@@ -17,6 +17,7 @@ test = false
 p8rs = { workspace = true, features = ["log-04", "std"] }
 p8rs-types.workspace = true
 anyhow.workspace = true
+env_logger.workspace = true
 colored = "3.0.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"

p8rs-tests/Cargo.toml

@@ -21,6 +21,8 @@ fn setup() {
 			err => err.expect("Unable to remove tmp dir"),
 		}
 		fs::create_dir_all(TMP_DIR).expect("Unable to create tmp dir");
+		
+		env_logger::init();
 	});
 }
 

p8rs-tests/src/tester.rs

@@ -2,10 +2,12 @@ use core::alloc::Allocator;
 use p8rs_macros::api_callback;
 use p8rs_piccolo::Context;
 use p8rs_types::p8num::P8Num;
+
 use crate::vm::Runtime;
 
 pub fn install_pico8_drawing<A: Allocator + 'static>(ctx: Context) {
 	ctx.set_global("rectfill", rectfill::callback::<A>(ctx));
+	ctx.set_global("rect", rect::callback::<A>(ctx));
 }
 
 #[api_callback]
@@ -15,6 +17,27 @@ pub fn rectfill<A: Allocator + 'static>(rt: &mut Runtime<A>, x0: Option<i16>, y0
 	let y0 = y0.unwrap_or(0);
 	let x1 = x1.unwrap_or(0);
 	let y1 = y1.unwrap_or(0);
+	let (x0, x1) = (x0.min(x1), x0.max(x1));
+	let (y0, y1) = (y0.min(y1), y0.max(y1));
 
 	rt.memory.painter().paint_range(x0..=x1, y0..=y1);
 }
+
+#[api_callback]
+pub fn rect<A: Allocator + 'static>(rt: &mut Runtime<A>, x0: Option<i16>, y0: Option<i16>, x1: Option<i16>, y1: Option<i16>, col: Option<P8Num>) {
+	if let Some(col) = col { rt.memory.machine_state().set_pen_color(col); }
+	let x0 = x0.unwrap_or(0);
+	let y0 = y0.unwrap_or(0);
+	let x1 = x1.unwrap_or(0);
+	let y1 = y1.unwrap_or(0);
+	let (x0, x1) = (x0.min(x1), x0.max(x1));
+	let (y0, y1) = (y0.min(y1), y0.max(y1));
+	
+	let mut painter = rt.memory.painter();
+	painter.paint_range(x0..=x1, y0..=y0);
+	painter.paint_range(x0..=x1, y1..=y1);
+	painter.paint_range(x0..=x0, y0..=y1);
+	painter.paint_range(x1..=x1, y0..=y1);
+}
+
+

p8rs/src/vm/api/drawing.rs

@@ -3,7 +3,7 @@ use p8rs_macros::{api_callback, p8};
 use p8rs_piccolo::{Context, Value};
 use p8rs_types::p8num::P8Num;
 
-use crate::vm::memory::machine_state::Palette;
+use crate::vm::memory::machine_state::{FillPatternFlags, FillPatternState, Palette};
 use crate::vm::Runtime;
 
 pub fn install_pico8_gfx<A: Allocator + 'static>(ctx: Context) {
@@ -13,6 +13,7 @@ pub fn install_pico8_gfx<A: Allocator + 'static>(ctx: Context) {
 	ctx.set_global("pal", pal::callback::<A>(ctx));
 	ctx.set_global("cls", cls::callback::<A>(ctx));
 	ctx.set_global("cursor", cursor::callback::<A>(ctx));
+	ctx.set_global("fillp", fillp::callback::<A>(ctx));
 }
 
 #[api_callback]
@@ -114,4 +115,15 @@ pub fn pal<'gc, A: Allocator + 'static>(rt: &mut Runtime<A>, c0: Option<Value<'g
 		let k = k.to_integer().cast_unsigned() as usize % 16;
 		pal[k] = v.to_integer() as u8;
 	}
+}
+
+#[api_callback]
+pub fn fillp<'gc, A: Allocator + 'static>(rt: &mut Runtime<A>, pat: Option<P8Num>) {
+	let pat = pat.unwrap().saturating_add(P8Num::ZERO);
+	let flags = (pat.to_raw() >> 8) as u8;
+	let flags = flags.reverse_bits() & 0b0000_0111;
+	let flags = FillPatternFlags::from_bits_retain(flags);
+	let pattern = pat.to_integer().cast_unsigned();
+	
+	*rt.memory.machine_state().fill_pattern() = FillPatternState::new(pattern, flags);
 }

p8rs/src/vm/api/gfx.rs

@@ -369,16 +369,20 @@ impl FillPatternState {
 		u16::from_le_bytes([self.0[0], self.0[1]])
 	}
 
-	pub fn expand(&self) -> [[bool; 4]; 4] {
+	pub fn expand(&self) -> Option<[[bool; 4]; 4]> {
 		let lo = self.0[0];
 		let hi = self.0[1];
 
-		[
-			[hi & 1 << 7 != 0, hi & 1 << 6 != 0, hi & 1 << 5 != 0, hi & 1 << 4 != 0],
-			[hi & 1 << 3 != 0, hi & 1 << 2 != 0, hi & 1 << 1 != 0, hi & 1 << 0 != 0],
-			[lo & 1 << 7 != 0, lo & 1 << 6 != 0, lo & 1 << 5 != 0, lo & 1 << 4 != 0],
-			[lo & 1 << 3 != 0, lo & 1 << 2 != 0, lo & 1 << 1 != 0, lo & 1 << 0 != 0],
-		]
+		if lo == 0 && hi == 0 {
+			None
+		} else {
+			Some([
+				[hi & 1 << 7 != 0, hi & 1 << 6 != 0, hi & 1 << 5 != 0, hi & 1 << 4 != 0],
+				[hi & 1 << 3 != 0, hi & 1 << 2 != 0, hi & 1 << 1 != 0, hi & 1 << 0 != 0],
+				[lo & 1 << 7 != 0, lo & 1 << 6 != 0, lo & 1 << 5 != 0, lo & 1 << 4 != 0],
+				[lo & 1 << 3 != 0, lo & 1 << 2 != 0, lo & 1 << 1 != 0, lo & 1 << 0 != 0],
+			])
+		}
 	}
 }
 
@@ -392,9 +396,9 @@ bitflags! {
 		/// Enables transparency
         const TRANSPARENT = 1 << 0;
 		/// When drawing sprites, fill pattern will determine nibble of secondary palette to use
-        const SPRITES_REMAP = 1 << 1;
+        const REMAP_SPRITES = 1 << 1;
 		/// All drawing functions that accept fill pattern will use it to determine nibble of secondary palette to use
-        const ALL_REMAP = 1 << 2;
+        const REMAP_ALL = 1 << 2;
 
         const _ = !0;
     }

p8rs/src/vm/memory/machine_state.rs

@@ -2,6 +2,7 @@ use core::alloc::Allocator;
 use core::ops::{Deref, DerefMut};
 use alloc::boxed::Box;
 use alloc::alloc::Global;
+use core::fmt::{Debug, Formatter};
 use p8rs_types::p8num::P8Num;
 use p8rs_macros::TransparentRef;
 
@@ -22,9 +23,9 @@ use music::Music;
 use sound_effects::SoundEffects;
 use machine_state::MachineState;
 use screen::Screen;
-use crate::vm::memory::painter::Painter;
+use painter::Painter;
 
-#[derive(Debug, Clone, TransparentRef)]
+#[derive(Clone, TransparentRef)]
 #[repr(transparent)]
 pub struct Memory([u8; 0x10000]);
 
@@ -145,6 +146,19 @@ impl DerefMut for Memory {
 	}
 }
 
+impl Debug for Memory {
+	fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+		f.write_str("Memory[64KB]")
+	}
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Memory {
+	fn format(&self, fmt: defmt::Formatter) {
+		defmt::write!(fmt, "Memory[64KB]");
+	}
+}
+
 pub trait Serializable {
 	fn read<const S: usize>(mem: &[u8; S], addr: u16) -> Self;
 	fn write<const S: usize>(self, mem: &mut [u8; S], addr: u16);

p8rs/src/vm/memory/mod.rs

@@ -1,17 +1,18 @@
-use core::ops::{Range, RangeInclusive};
-use crate::vm::memory::machine_state::FillPatternFlags;
+use core::ops::{Not, Range, RangeInclusive};
+
+use crate::vm::memory::machine_state::{FillPatternFlags, Palette};
 use crate::vm::memory::Memory;
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Painter<'a> {
 	memory: &'a mut Memory,
 	fg: u8,
-	_bg: u8,
+	bg: Option<u8>,
 	clip_x: Range<i16>,
 	clip_y: Range<i16>,
 	camera: Vector<i16>,
-	_fill: [[bool; 4]; 4],
-	_fill_flags: FillPatternFlags,
+	fill: Option<[[bool; 4]; 4]>,
 }
 
 impl Painter<'_> {
@@ -21,27 +22,46 @@ impl Painter<'_> {
 		let camera = memory.machine_state().get_camera_position();
 		let fill = memory.machine_state().fill_pattern().expand();
 		let fill_flags = *memory.machine_state().fill_pattern().flags();
-		let fg = pen_color & 0xF;
-		let bg = pen_color >> 4;
+		
+		let (fg, bg) = if fill_flags.contains(FillPatternFlags::REMAP_ALL) {
+			let pal = *memory.machine_state().palette(Palette::Secondary);
+			let color = pal[(pen_color & 0xF) as usize];
+			
+			(color & 0x0F, color >> 4)
+		} else {
+			let pal = *memory.machine_state().palette(Palette::Draw);
+			let fg = pal[(pen_color & 0xF) as usize];
+			let bg = pal[(pen_color >> 4) as usize];
+			
+			(fg, bg)
+		};
+		
+		let bg = fill_flags.contains(FillPatternFlags::TRANSPARENT)
+		                   .not()
+		                   .then_some(bg);
 
 		Painter {
 			memory,
 			fg,
-			_bg: bg,
+			bg,
 			clip_x: clip[0] as i16 .. clip[2].min(128) as i16,
 			clip_y: clip[1] as i16 .. clip[3].min(128) as i16,
 			camera: Vector::from(camera),
-			_fill: fill,
-			_fill_flags: fill_flags,
+			fill,
 		}
 	}
 
 	pub fn paint(&mut self, x: i16, y: i16) {
-		let x = x.saturating_add(self.camera.x);
-		let y = y.saturating_add(self.camera.y);
+		let x = x.saturating_sub(self.camera.x);
+		let y = y.saturating_sub(self.camera.y);
+		
+		self.paint_abs_impl(x, y);
+	}
+	
+	pub fn paint_abs(mut self, x: i16, y: i16) {
 		if !self.clip_x.contains(&x) || !self.clip_y.contains(&y) { return }
 
-		self.paint_abs(x, y);
+		self.paint_abs_impl(x, y);
 	}
 
 	pub fn paint_range(&mut self, x: impl IntoClip, y: impl IntoClip) {
@@ -51,13 +71,23 @@ impl Painter<'_> {
 
 		for y in y {
 			for x in x.clone() {
-				self.paint_abs(x, y);
+				self.paint_abs_impl(x, y);
 			}
 		}
 	}
 
-	fn paint_abs(&mut self, x: i16, y: i16) {
-		self.memory.screen().set_pixel(x, y, self.fg);
+	fn paint_abs_impl(&mut self, x: i16, y: i16) {
+		let col = if let Some(fill) = self.fill && fill[y as usize % 4][x as usize % 4] {
+			if let Some(bg) = self.bg {
+				bg
+			} else {
+				return;
+			}
+		} else {
+			self.fg
+		};
+		
+		self.memory.screen().set_pixel(x, y, col);
 	}
 }
 
@@ -86,17 +116,17 @@ macro_rules! impl_clip {
 	($typ:ty $(, $rest:ty )*) => {
 		impl IntoClip for Range<$typ> {
 			fn into_clip(self, camera: i16) -> Range<i16> {
-				let start = (self.start as i16).saturating_add(camera);
-				let end = (self.end as i16).saturating_add(camera);
+				let start = (self.start as i16).saturating_sub(camera);
+				let end = (self.end as i16).saturating_sub(camera);
 
 				start..end
 			}
 		}
 
 		impl IntoClip for RangeInclusive<$typ> {
 			fn into_clip(self, camera: i16) -> Range<i16> {
-				let start = (*self.start() as i16).saturating_add(camera);
-				let end = (*self.end() as i16).saturating_add(camera).saturating_add(1);
+				let start = (*self.start() as i16).saturating_sub(camera);
+				let end = (*self.end() as i16).saturating_sub(camera).saturating_add(1);
 
 				start..end
 			}