remove minigfx from the HAL aspect of cramium

it was sort of out of place there anyways...
This commit is contained in:
bunnie 2025-02-02 07:02:07 +08:00
parent 19de313067
commit e4646013d0
4 changed files with 10 additions and 358 deletions

View file

@ -23,6 +23,7 @@ riscv = { version = "0.5.6", package = "xous-riscv" }
usb-device = { version = "0.2.8", features = ["log"], optional = true }
bitfield = "0.13.2"
either = { version = "1.9.0", default-features = false }
ux-api = { path = "../ux-api", default-features = false }
# [target.'cfg(target_os = "xous")'.dependencies]
xous = { version = "0.9.64", features = ["v2p"] }
@ -49,6 +50,12 @@ udma-stress-test = [
compress-entropy = []
magic-manual = []
std = ["log", "xous-api-names", "usb-device", "xous-api-ticktimer"]
std = [
"log",
"xous-api-names",
"usb-device",
"xous-api-ticktimer",
"ux-api/std",
]
derive-rkyv = ["rkyv"]
default = []

View file

@ -17,4 +17,3 @@ pub mod udma;
pub mod usb;
pub use shared_csr::*;
pub mod mbox;
pub mod minigfx;

View file

@ -1,355 +0,0 @@
use core::cmp::{max, min};
use core::ops::{Add, AddAssign, Div, DivAssign, Index, Mul, MulAssign, Neg, Sub, SubAssign};
/// Type wrapper for native colors
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct ColorNative(pub usize);
impl From<usize> for ColorNative {
fn from(value: usize) -> Self { Self { 0: value } }
}
impl Into<usize> for ColorNative {
fn into(self) -> usize { self.0 }
}
/// Abstract trait for a FrameBuffer. Slower than native manipulation
/// of the [u8] contents of a frame buffer, but more portable.
pub trait FrameBuffer {
/// Puts a pixel of ColorNative at x, y. (0, 0) is defined as the lower left corner.
fn put_pixel(&mut self, p: Point, color: ColorNative);
/// Retrieves a pixel value from the frame buffer; returns None if the point is out of bounds.
fn get_pixel(&mut self, p: Point) -> Option<ColorNative>;
/// Swaps the drawable buffer to the screen and sends it to the hardware
fn draw(&mut self);
/// Clears the drawable buffer
fn clear(&mut self);
/// Returns the size of the frame buffer as a Point
fn dimensions(&self) -> Point;
}
/// Style properties for an object
#[derive(Debug, Copy, Clone)]
pub struct DrawStyle {
/// Fill colour of the object
pub fill_color: Option<ColorNative>,
/// Stroke (border/line) color of the object
pub stroke_color: Option<ColorNative>,
/// Stroke width
pub stroke_width: isize,
}
impl DrawStyle {
pub fn new(fill: ColorNative, stroke: ColorNative, width: isize) -> Self {
Self { fill_color: Some(fill), stroke_color: Some(stroke), stroke_width: width }
}
/// Create a new style with a given stroke value and defaults for everything else
pub fn stroke_color(stroke_color: ColorNative) -> Self {
Self { stroke_color: Some(stroke_color), ..DrawStyle::default() }
}
}
impl Default for DrawStyle {
fn default() -> Self {
Self { fill_color: Some(ColorNative(0)), stroke_color: Some(ColorNative(0)), stroke_width: 1 }
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Point {
pub x: isize,
pub y: isize,
}
impl Point {
pub fn new(x: isize, y: isize) -> Self { Point { x, y } }
pub fn to_f32(&self) -> (f32, f32) { (self.x as f32, self.y as f32) }
}
impl Default for Point {
fn default() -> Self { Point::new(0, 0) }
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point { Point::new(self.x + other.x, self.y + other.y) }
}
impl AddAssign for Point {
fn add_assign(&mut self, other: Point) {
self.x += other.x;
self.y += other.y;
}
}
impl Sub for Point {
type Output = Point;
fn sub(self, other: Point) -> Point { Point::new(self.x - other.x, self.y - other.y) }
}
impl SubAssign for Point {
fn sub_assign(&mut self, other: Point) {
self.x -= other.x;
self.y -= other.y;
}
}
impl Mul<isize> for Point {
type Output = Point;
fn mul(self, rhs: isize) -> Point { Point::new(self.x * rhs, self.y * rhs) }
}
impl MulAssign<isize> for Point {
fn mul_assign(&mut self, rhs: isize) {
self.x *= rhs;
self.y *= rhs;
}
}
impl Div<isize> for Point {
type Output = Point;
fn div(self, rhs: isize) -> Point { Point::new(self.x / rhs, self.y / rhs) }
}
impl DivAssign<isize> for Point {
fn div_assign(&mut self, rhs: isize) {
self.x /= rhs;
self.y /= rhs;
}
}
impl Index<usize> for Point {
type Output = isize;
fn index(&self, idx: usize) -> &isize {
match idx {
0 => &self.x,
1 => &self.y,
_ => panic!("index out of bounds: the len is 2 but the index is {}", idx),
}
}
}
impl Neg for Point {
type Output = Point;
fn neg(self) -> Self::Output { Point::new(-self.x, -self.y) }
}
//////////////////////////// RECTANGLE
#[derive(Debug, Clone, Copy)]
pub struct Rectangle {
pub tl: Point,
pub br: Point,
pub style: DrawStyle,
}
impl Rectangle {
pub fn new(p1: Point, p2: Point) -> Rectangle {
// always check point ordering
Rectangle {
tl: Point::new(min(p1.x, p2.x), min(p1.y, p2.y)),
br: Point::new(max(p1.x, p2.x), max(p1.y, p2.y)),
style: DrawStyle::default(),
}
}
pub fn new_coords(x0: isize, y0: isize, x1: isize, y1: isize) -> Rectangle {
Rectangle {
tl: Point::new(min(x0, x1), min(y0, y1)),
br: Point::new(max(x0, x1), max(y0, y1)),
style: DrawStyle::default(),
}
}
// stack a new rectangle on top of the current one (same width)
// positive heights go *below*, negative go *above* in screen coordinate space. borders are
// non-overlapping.
pub fn new_v_stack(reference: Rectangle, height: isize) -> Rectangle {
if height >= 0 {
// rectangle below
Rectangle::new_coords(reference.tl.x, reference.br.y + 1, reference.br.x, reference.br.y + height)
} else {
// rectangle above
Rectangle::new_coords(reference.tl.x, reference.tl.y + height, reference.br.x, reference.tl.y - 1)
}
}
// make a new rectangle than spans between the above and below rectangles. the borders are
// non-overlapping.
pub fn new_v_span(above: Rectangle, below: Rectangle) -> Rectangle {
Rectangle::new_coords(above.tl.x, above.br.y + 1, below.br.x, below.tl.y - 1)
}
// "stack" a rectangle to the left or right of the current one (same height)
// positive widths go to the right, negative to the left. borders are non-overlapping
pub fn new_h_stack(reference: Rectangle, width: isize) -> Rectangle {
if width >= 0 {
// stack to the right
Rectangle::new_coords(
reference.br.x + 1,
reference.tl.y,
reference.br.x + width + 1,
reference.br.y,
)
} else {
// stack to the left
Rectangle::new_coords(
reference.tl.x + width - 1,
reference.tl.y,
reference.tl.x - 1,
reference.br.y,
)
}
}
// make a new rectangle than spans between the left and right rectangles. borders are non-overlapping
pub fn new_h_span(left: Rectangle, right: Rectangle) -> Rectangle {
Rectangle::new_coords(left.br.x + 1, left.tl.y, right.tl.x - 1, right.br.y)
}
pub fn tl(&self) -> Point { self.tl }
pub fn br(&self) -> Point { self.br }
pub fn bl(&self) -> Point { Point { x: self.tl.x, y: self.br.y } }
pub fn tr(&self) -> Point { Point { x: self.br.x, y: self.tl.y } }
pub fn intersects(&self, other: Rectangle) -> bool {
!(self.br.x < other.tl.x
|| self.tl.y > other.br.y
|| self.br.y < other.tl.y
|| self.tl.x > other.br.x)
}
pub fn intersects_point(&self, point: Point) -> bool {
((point.x >= self.tl.x) && (point.x <= self.br.x))
&& ((point.y >= self.tl.y) && (point.y <= self.br.y))
}
/// takes the current Rectangle, and clips it with a clipping Rectangle; returns a new rectangle as the
/// result
pub fn clip_with(&self, clip: Rectangle) -> Option<Rectangle> {
// check to see if we even overlap; if not, don't do any computation
if !self.intersects(clip) {
return None;
}
let tl: Point = Point::new(
if self.tl.x < clip.tl.x { clip.tl.x } else { self.tl.x },
if self.tl.y < clip.tl.y { clip.tl.y } else { self.tl.y },
);
let br: Point = Point::new(
if self.br.x > clip.br.x { clip.br.x } else { self.br.x },
if self.br.y > clip.br.y { clip.br.y } else { self.br.y },
);
Some(Rectangle::new(tl, br))
}
pub fn new_coords_with_style(x0: isize, y0: isize, x1: isize, y1: isize, style: DrawStyle) -> Rectangle {
Rectangle {
tl: Point::new(min(x0, x1), min(y0, y1)),
br: Point::new(max(x0, x1), max(y0, y1)),
style,
}
}
pub fn new_with_style(p1: Point, p2: Point, style: DrawStyle) -> Rectangle {
// always check point ordering
Rectangle {
tl: Point::new(min(p1.x, p2.x), min(p1.y, p2.y)),
br: Point::new(max(p1.x, p2.x), max(p1.y, p2.y)),
style,
}
}
pub fn x0(&self) -> u32 { self.tl.x as u32 }
pub fn x1(&self) -> u32 { self.br.x as u32 }
pub fn y0(&self) -> u32 { self.tl.y as u32 }
pub fn y1(&self) -> u32 { self.br.y as u32 }
pub fn width(&self) -> u32 { (self.br.x - self.tl.x) as u32 }
pub fn height(&self) -> u32 { (self.br.y - self.tl.y) as u32 }
pub fn translate(&mut self, offset: Point) {
self.tl.x += offset.x;
self.br.x += offset.x;
self.tl.y += offset.y;
self.br.y += offset.y;
}
pub fn translate_chain(self, offset: Point) -> Rectangle {
Rectangle {
tl: Point::new(self.tl.x + offset.x, self.tl.y + offset.y),
br: Point::new(self.br.x + offset.x, self.br.y + offset.y),
style: self.style,
}
}
pub fn normalize(&mut self) {
self.br.x -= self.tl.x;
self.br.y -= self.tl.y;
self.tl.x = 0;
self.tl.y = 0;
}
// this "margins in" a rectangle on all sides; if the margin is more than the twice any
// dimension it just reduces the rectangle to a line at the midpoint of the axis dimension
pub fn margin(&mut self, margin: Point) {
if margin.x * 2 <= (self.br.x - self.tl.x) {
self.tl.x += margin.x;
self.br.x -= margin.x;
} else {
let midpoint = (self.br.x + self.tl.x) / 2;
self.tl.x = midpoint;
self.br.x = midpoint;
}
if margin.y * 2 <= (self.br.y - self.tl.y) {
self.tl.y += margin.y;
self.br.y -= margin.y;
} else {
let midpoint = (self.br.y + self.tl.y) / 2;
self.tl.y = midpoint;
self.br.y = midpoint;
}
}
// this "margins out" on all sides
pub fn margin_out(&mut self, margin: Point) {
self.tl.x -= margin.x;
self.tl.y -= margin.y;
self.br.x += margin.x;
self.br.y += margin.y;
}
}
//////////////////////////// LINE
#[derive(Debug, Clone, Copy)]
pub struct Line {
pub start: Point,
pub end: Point,
/// Drawing style
pub style: DrawStyle,
}
impl Line {
pub fn new(start: Point, end: Point) -> Line { Line { start, end, style: DrawStyle::default() } }
pub fn new_with_style(start: Point, end: Point, style: DrawStyle) -> Line { Line { start, end, style } }
pub fn translate(&mut self, offset: Point) {
self.start = self.start + offset;
self.end = self.end + offset;
}
}

View file

@ -1,8 +1,9 @@
// `Command` vendored from https://github.com/ithinuel/sh1107-rs/tree/main
use ux_api::minigfx::{ColorNative, FrameBuffer, Point};
use crate::{
ifram::IframRange,
iox::{IoGpio, IoSetup, IoxPort},
minigfx::{ColorNative, FrameBuffer, Point},
udma::{PeriphId, Spim, SpimClkPha, SpimClkPol, SpimCs, UdmaGlobalConfig},
};