mirror of
https://github.com/LegitCamper/picocalc-os-rs.git
synced 2025-12-27 15:55:25 +00:00
Compare commits
7 Commits
doom
...
selection-
| Author | SHA1 | Date | |
|---|---|---|---|
| 513042b561 | |||
| 375b5d1d47 | |||
| dd26e3528b | |||
| 74ec86da8f | |||
| cc463a34be | |||
| 355be5cde3 | |||
| 1bbb892fcc |
3
.gitmodules
vendored
3
.gitmodules
vendored
@@ -1,3 +0,0 @@
|
||||
[submodule "user-apps/doom/doomgeneric"]
|
||||
path = user-apps/doom/doomgeneric
|
||||
url = https://github.com/ozkl/doomgeneric
|
||||
139
Cargo.lock
generated
139
Cargo.lock
generated
@@ -18,7 +18,6 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"abi_sys",
|
||||
"embedded-graphics",
|
||||
"embedded-sdmmc",
|
||||
"once_cell",
|
||||
"rand_core 0.9.3",
|
||||
]
|
||||
@@ -31,7 +30,6 @@ dependencies = [
|
||||
"cbindgen",
|
||||
"defmt 0.3.100",
|
||||
"embedded-graphics",
|
||||
"embedded-sdmmc",
|
||||
"strum",
|
||||
]
|
||||
|
||||
@@ -133,26 +131,6 @@ version = "0.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
|
||||
|
||||
[[package]]
|
||||
name = "bindgen"
|
||||
version = "0.71.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
|
||||
dependencies = [
|
||||
"bitflags 2.9.4",
|
||||
"cexpr",
|
||||
"clang-sys",
|
||||
"itertools 0.10.5",
|
||||
"log",
|
||||
"prettyplease",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"regex",
|
||||
"rustc-hash",
|
||||
"shlex",
|
||||
"syn 2.0.104",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bit-set"
|
||||
version = "0.5.3"
|
||||
@@ -295,42 +273,12 @@ dependencies = [
|
||||
"toml",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
version = "1.2.43"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "739eb0f94557554b3ca9a86d2d37bebd49c5e6d0c1d2bda35ba5bdac830befc2"
|
||||
dependencies = [
|
||||
"find-msvc-tools",
|
||||
"shlex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cexpr"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
|
||||
dependencies = [
|
||||
"nom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
|
||||
|
||||
[[package]]
|
||||
name = "clang-sys"
|
||||
version = "1.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
|
||||
dependencies = [
|
||||
"glob",
|
||||
"libc",
|
||||
"libloading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "3.2.25"
|
||||
@@ -614,16 +562,6 @@ dependencies = [
|
||||
"litrs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "doom"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"abi",
|
||||
"bindgen",
|
||||
"cc",
|
||||
"embedded-graphics",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.15.0"
|
||||
@@ -1167,12 +1105,6 @@ version = "2.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
|
||||
|
||||
[[package]]
|
||||
name = "find-msvc-tools"
|
||||
version = "0.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
|
||||
|
||||
[[package]]
|
||||
name = "fixed"
|
||||
version = "1.29.0"
|
||||
@@ -1355,15 +1287,10 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"abi",
|
||||
"embedded-graphics",
|
||||
"selection_ui",
|
||||
"tinygif",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "glob"
|
||||
version = "0.3.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
|
||||
|
||||
[[package]]
|
||||
name = "goblin"
|
||||
version = "0.10.2"
|
||||
@@ -1676,16 +1603,6 @@ version = "0.2.174"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.8.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libredox"
|
||||
version = "0.1.4"
|
||||
@@ -1742,12 +1659,6 @@ version = "2.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"
|
||||
|
||||
[[package]]
|
||||
name = "minimal-lexical"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
|
||||
|
||||
[[package]]
|
||||
name = "nb"
|
||||
version = "0.1.3"
|
||||
@@ -1769,16 +1680,6 @@ version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
|
||||
|
||||
[[package]]
|
||||
name = "nom"
|
||||
version = "7.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
"minimal-lexical",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
@@ -2042,16 +1943,6 @@ version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
|
||||
|
||||
[[package]]
|
||||
name = "prettyplease"
|
||||
version = "0.2.36"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"syn 2.0.104",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-error"
|
||||
version = "1.0.4"
|
||||
@@ -2244,12 +2135,6 @@ dependencies = [
|
||||
"crc-any",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc-hash"
|
||||
version = "2.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
|
||||
|
||||
[[package]]
|
||||
name = "rustc_version"
|
||||
version = "0.2.3"
|
||||
@@ -2305,6 +2190,16 @@ version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add"
|
||||
|
||||
[[package]]
|
||||
name = "selection_ui"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"abi",
|
||||
"embedded-graphics",
|
||||
"embedded-layout",
|
||||
"embedded-text",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "0.9.0"
|
||||
@@ -2379,12 +2274,6 @@ dependencies = [
|
||||
"keccak",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shlex"
|
||||
version = "1.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
|
||||
|
||||
[[package]]
|
||||
name = "siphasher"
|
||||
version = "1.0.1"
|
||||
@@ -2953,12 +2842,6 @@ version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.59.0"
|
||||
|
||||
@@ -4,11 +4,11 @@ members = [
|
||||
"kernel",
|
||||
"abi_sys",
|
||||
"abi",
|
||||
"selection_ui",
|
||||
"user-apps/calculator",
|
||||
"user-apps/snake",
|
||||
"user-apps/gallery",
|
||||
"user-apps/gif",
|
||||
"user-apps/doom",
|
||||
]
|
||||
|
||||
[profile.release]
|
||||
@@ -27,4 +27,4 @@ panic = "abort"
|
||||
|
||||
[profile.dev]
|
||||
lto = true
|
||||
opt-level = "z"
|
||||
opt-level = "s"
|
||||
|
||||
@@ -4,8 +4,7 @@ version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
embedded-sdmmc = { version = "0.9.0", default-features = false }
|
||||
embedded-graphics = "0.8.1"
|
||||
abi_sys = { path = "../abi_sys" }
|
||||
embedded-graphics = "0.8.1"
|
||||
once_cell = { version = "1", default-features = false }
|
||||
rand_core = "0.9.3"
|
||||
|
||||
@@ -140,7 +140,9 @@ impl RngCore for Rng {
|
||||
}
|
||||
|
||||
pub mod fs {
|
||||
use embedded_sdmmc::DirEntry;
|
||||
use core::fmt::Display;
|
||||
|
||||
use alloc::{format, vec::Vec};
|
||||
|
||||
pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
|
||||
abi_sys::read_file(
|
||||
@@ -152,8 +154,85 @@ pub mod fs {
|
||||
)
|
||||
}
|
||||
|
||||
pub fn list_dir(path: &str, files: &mut [Option<DirEntry>]) -> usize {
|
||||
abi_sys::list_dir(path.as_ptr(), path.len(), files.as_mut_ptr(), files.len())
|
||||
pub struct FileName<'a> {
|
||||
full: &'a str,
|
||||
base: &'a str,
|
||||
ext: Option<&'a str>,
|
||||
}
|
||||
|
||||
impl<'a> FileName<'a> {
|
||||
pub fn full_name(&self) -> &str {
|
||||
self.full
|
||||
}
|
||||
|
||||
pub fn base(&self) -> &str {
|
||||
self.base
|
||||
}
|
||||
|
||||
pub fn extension(&self) -> Option<&str> {
|
||||
self.ext
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Display for FileName<'a> {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||
write!(f, "{}", self.full_name())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a str> for FileName<'a> {
|
||||
fn from(s: &'a str) -> FileName<'a> {
|
||||
let full = s;
|
||||
|
||||
// Split on last dot for extension
|
||||
let (base, ext) = match s.rfind('.') {
|
||||
Some(idx) => (&s[..idx], Some(&s[idx + 1..])),
|
||||
None => (s, None),
|
||||
};
|
||||
|
||||
FileName { full, base, ext }
|
||||
}
|
||||
}
|
||||
|
||||
const MAX_ENTRY_NAME_LEN: usize = 25;
|
||||
const MAX_ENTRIES: usize = 25;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]);
|
||||
|
||||
impl Entries {
|
||||
pub fn new() -> Self {
|
||||
Self([[0; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES])
|
||||
}
|
||||
|
||||
/// Get list of file names after listing
|
||||
pub fn entries<'a>(&'a self) -> Vec<FileName<'a>> {
|
||||
self.0
|
||||
.iter()
|
||||
.filter_map(|buf| {
|
||||
let nul_pos = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
|
||||
Some(core::str::from_utf8(&buf[..nul_pos]).ok()?.into())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn as_ptrs(&mut self) -> [*mut u8; MAX_ENTRIES] {
|
||||
let mut ptrs: [*mut u8; MAX_ENTRIES] = [core::ptr::null_mut(); MAX_ENTRIES];
|
||||
for (i, buf) in self.0.iter_mut().enumerate() {
|
||||
ptrs[i] = buf.as_mut_ptr();
|
||||
}
|
||||
ptrs
|
||||
}
|
||||
}
|
||||
|
||||
pub fn list_dir(path: &str, entries: &mut Entries) -> usize {
|
||||
abi_sys::list_dir(
|
||||
path.as_ptr(),
|
||||
path.len(),
|
||||
entries.as_ptrs().as_mut_ptr(),
|
||||
MAX_ENTRIES,
|
||||
MAX_ENTRY_NAME_LEN,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn file_len(str: &str) -> usize {
|
||||
|
||||
@@ -12,7 +12,6 @@ defmt = ["dep:defmt"]
|
||||
strum = { version = "0.27.2", default-features = false, features = ["derive"] }
|
||||
bitflags = "2.9.4"
|
||||
embedded-graphics = "0.8.1"
|
||||
embedded-sdmmc = { version = "0.9.0", default-features = false }
|
||||
defmt = { version = "0.3", optional = true }
|
||||
|
||||
[build-dependencies]
|
||||
|
||||
@@ -1,14 +1,13 @@
|
||||
#![no_std]
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
use core::alloc::Layout;
|
||||
|
||||
use core::ffi::c_char;
|
||||
use embedded_graphics::{
|
||||
Pixel,
|
||||
pixelcolor::{Rgb565, raw::RawU16},
|
||||
prelude::{IntoStorage, Point},
|
||||
};
|
||||
use embedded_sdmmc::DirEntry;
|
||||
use strum::{EnumCount, EnumIter};
|
||||
|
||||
pub type EntryFn = fn();
|
||||
@@ -396,21 +395,23 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
|
||||
pub type ListDir = extern "C" fn(
|
||||
str: *const u8,
|
||||
len: usize,
|
||||
files: *mut Option<DirEntry>,
|
||||
entries: *mut *mut c_char,
|
||||
file_len: usize,
|
||||
max_entry_str_len: usize,
|
||||
) -> usize;
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn list_dir(
|
||||
str: *const u8,
|
||||
len: usize,
|
||||
files: *mut Option<DirEntry>,
|
||||
file_len: usize,
|
||||
entries: *mut *mut c_char,
|
||||
entry_count: usize,
|
||||
max_entry_str_len: usize,
|
||||
) -> usize {
|
||||
unsafe {
|
||||
let ptr = CALL_ABI_TABLE[CallTable::ListDir as usize];
|
||||
let f: ListDir = core::mem::transmute(ptr);
|
||||
f(str, len, files, file_len)
|
||||
f(str, len, entries, entry_count, max_entry_str_len)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
1
justfile
1
justfile
@@ -17,4 +17,3 @@ userapps: cbindgen
|
||||
just userapp snake
|
||||
just userapp gallery
|
||||
just userapp gif
|
||||
just userapp doom
|
||||
|
||||
@@ -3,11 +3,11 @@ use abi_sys::{
|
||||
PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
|
||||
};
|
||||
use alloc::{string::ToString, vec::Vec};
|
||||
use core::{alloc::GlobalAlloc, sync::atomic::Ordering};
|
||||
use core::{alloc::GlobalAlloc, ffi::c_char, ptr, sync::atomic::Ordering};
|
||||
use embassy_rp::clocks::{RoscRng, clk_sys_freq};
|
||||
use embassy_time::Instant;
|
||||
use embedded_graphics::draw_target::DrawTarget;
|
||||
use embedded_sdmmc::{DirEntry, LfnBuffer};
|
||||
use embedded_sdmmc::LfnBuffer;
|
||||
use heapless::spsc::Queue;
|
||||
|
||||
use crate::{
|
||||
@@ -116,11 +116,27 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
|
||||
}
|
||||
}
|
||||
|
||||
fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
|
||||
unsafe fn copy_entry_to_user_buf(name: &[u8], dest: *mut c_char, max_str_len: usize) {
|
||||
if !dest.is_null() {
|
||||
let len = name.len().min(max_str_len - 1);
|
||||
unsafe {
|
||||
ptr::copy_nonoverlapping(name.as_ptr(), dest as *mut u8, len);
|
||||
*dest.add(len) = 0; // nul terminator
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn get_dir_entries(dir: &Dir, entries: &mut [*mut c_char], max_str_len: usize) -> usize {
|
||||
let mut b = [0; 25];
|
||||
let mut buf = LfnBuffer::new(&mut b);
|
||||
let mut i = 0;
|
||||
dir.iterate_dir(|entry| {
|
||||
if i < files.len() {
|
||||
files[i] = Some(entry.clone());
|
||||
dir.iterate_dir_lfn(&mut buf, |entry, lfn_name| {
|
||||
if i < entries.len() {
|
||||
if let Some(name) = lfn_name {
|
||||
unsafe { copy_entry_to_user_buf(name.as_bytes(), entries[i], max_str_len) };
|
||||
} else {
|
||||
unsafe { copy_entry_to_user_buf(entry.name.base_name(), entries[i], max_str_len) };
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
})
|
||||
@@ -128,24 +144,30 @@ fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
|
||||
i
|
||||
}
|
||||
|
||||
fn recurse_dir(dir: &Dir, dirs: &[&str], files: &mut [Option<DirEntry>]) -> usize {
|
||||
unsafe fn recurse_dir(
|
||||
dir: &Dir,
|
||||
dirs: &[&str],
|
||||
entries: &mut [*mut c_char],
|
||||
max_str_len: usize,
|
||||
) -> usize {
|
||||
if dirs.is_empty() {
|
||||
return get_dir_entries(dir, files);
|
||||
return unsafe { get_dir_entries(dir, entries, max_str_len) };
|
||||
}
|
||||
|
||||
let dir = dir.open_dir(dirs[0]).unwrap();
|
||||
recurse_dir(&dir, &dirs[1..], files)
|
||||
unsafe { recurse_dir(&dir, &dirs[1..], entries, max_str_len) }
|
||||
}
|
||||
|
||||
const _: ListDir = list_dir;
|
||||
pub extern "C" fn list_dir(
|
||||
dir: *const u8,
|
||||
len: usize,
|
||||
files: *mut Option<DirEntry>,
|
||||
entries: *mut *mut c_char,
|
||||
files_len: usize,
|
||||
max_entry_str_len: usize,
|
||||
) -> usize {
|
||||
// SAFETY: caller guarantees `ptr` is valid for `len` bytes
|
||||
let files = unsafe { core::slice::from_raw_parts_mut(files, files_len) };
|
||||
let files = unsafe { core::slice::from_raw_parts_mut(entries, files_len) };
|
||||
// SAFETY: caller guarantees `ptr` is valid for `len` bytes
|
||||
let dir = unsafe { core::str::from_raw_parts(dir, len) };
|
||||
let dirs: Vec<&str> = dir.split('/').collect();
|
||||
@@ -156,10 +178,12 @@ pub extern "C" fn list_dir(
|
||||
let mut wrote = 0;
|
||||
sd.access_root_dir(|root| {
|
||||
if dirs[0] == "" && dirs.len() >= 2 {
|
||||
if dir == "/" {
|
||||
wrote = get_dir_entries(&root, files);
|
||||
} else {
|
||||
wrote = recurse_dir(&root, &dirs[1..], files);
|
||||
unsafe {
|
||||
if dir == "/" {
|
||||
wrote = get_dir_entries(&root, files, max_entry_str_len);
|
||||
} else {
|
||||
wrote = recurse_dir(&root, &dirs[1..], files, max_entry_str_len);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -84,7 +84,7 @@ pub async fn display_handler(mut display: DISPLAY) {
|
||||
FRAMEBUFFER
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.safe_draw(&mut display)
|
||||
.partial_draw(&mut display)
|
||||
.await
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use crate::display::{SCREEN_HEIGHT, SCREEN_WIDTH};
|
||||
use core::sync::atomic::{AtomicBool, Ordering};
|
||||
use embassy_sync::lazy_lock::LazyLock;
|
||||
use embedded_graphics::{
|
||||
draw_target::DrawTarget,
|
||||
pixelcolor::{
|
||||
@@ -14,32 +13,33 @@ use embedded_hal_2::digital::OutputPin;
|
||||
use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
|
||||
use st7365p_lcd::ST7365P;
|
||||
|
||||
pub const TILE_SIZE: usize = 16; // 16x16 tile
|
||||
pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
|
||||
const TILE_SIZE: usize = 16; // 16x16 tile
|
||||
const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
|
||||
const NUM_TILE_ROWS: usize = SCREEN_WIDTH / TILE_SIZE;
|
||||
const NUM_TILE_COLS: usize = SCREEN_WIDTH / TILE_SIZE;
|
||||
|
||||
// Group of tiles for batching
|
||||
pub const MAX_META_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2; // max number of meta tiles in buffer
|
||||
type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
|
||||
const MAX_BATCH_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2;
|
||||
type BatchTileBuf = [u16; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE];
|
||||
|
||||
pub const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
|
||||
|
||||
pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
|
||||
let mut tiles = heapless::Vec::new();
|
||||
for _ in 0..TILE_COUNT {
|
||||
tiles.push(AtomicBool::new(true)).unwrap();
|
||||
}
|
||||
tiles
|
||||
});
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub struct AtomicFrameBuffer<'a>(&'a mut [u16]);
|
||||
pub struct AtomicFrameBuffer<'a> {
|
||||
fb: &'a mut [u16],
|
||||
dirty_tiles: [AtomicBool; TILE_COUNT],
|
||||
batch_tile_buf: BatchTileBuf,
|
||||
}
|
||||
|
||||
impl<'a> AtomicFrameBuffer<'a> {
|
||||
pub fn new(buffer: &'a mut [u16]) -> Self {
|
||||
assert!(buffer.len() == SIZE);
|
||||
Self(buffer)
|
||||
Self {
|
||||
fb: buffer,
|
||||
dirty_tiles: core::array::from_fn(|_| AtomicBool::new(true)),
|
||||
batch_tile_buf: [0; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE],
|
||||
}
|
||||
}
|
||||
|
||||
fn mark_tiles_dirty(&mut self, rect: Rectangle) {
|
||||
@@ -52,7 +52,7 @@ impl<'a> AtomicFrameBuffer<'a> {
|
||||
for ty in start_ty..=end_ty {
|
||||
for tx in start_tx..=end_tx {
|
||||
let tile_idx = ty * tiles_x + tx;
|
||||
unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Release) };
|
||||
self.dirty_tiles[tile_idx].store(true, Ordering::Release);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -78,7 +78,7 @@ impl<'a> AtomicFrameBuffer<'a> {
|
||||
for y in sy..=ey {
|
||||
for x in sx..=ex {
|
||||
if let Some(color) = color_iter.next() {
|
||||
self.0[(y as usize * SCREEN_WIDTH) + x as usize] = color;
|
||||
self.fb[(y as usize * SCREEN_WIDTH) + x as usize] = color;
|
||||
} else {
|
||||
return Err(()); // Not enough data
|
||||
}
|
||||
@@ -93,60 +93,17 @@ impl<'a> AtomicFrameBuffer<'a> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
|
||||
fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
|
||||
let mut meta_tiles: MetaTileVec = heapless::Vec::new();
|
||||
// Checks if a full draw would be faster than individual tile batches
|
||||
fn should_full_draw(&self) -> bool {
|
||||
let threshold_pixels = SIZE * 80 / 100;
|
||||
let mut dirty_pixels = 0;
|
||||
|
||||
for ty in 0..tiles_y {
|
||||
let mut tx = 0;
|
||||
while tx < tiles_x {
|
||||
let idx = ty * tiles_x + tx;
|
||||
if !unsafe { DIRTY_TILES.get()[idx].load(Ordering::Acquire) } {
|
||||
tx += 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Start meta-tile at this tile
|
||||
let mut width_tiles = 1;
|
||||
let height_tiles = 1;
|
||||
|
||||
// Grow horizontally, but keep under MAX_TILES_PER_METATILE
|
||||
while tx + width_tiles < tiles_x
|
||||
&& unsafe {
|
||||
DIRTY_TILES.get()[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
|
||||
}
|
||||
&& (width_tiles + height_tiles) <= MAX_META_TILES
|
||||
{
|
||||
width_tiles += 1;
|
||||
}
|
||||
|
||||
// TODO: for simplicity, skipped vertical growth
|
||||
|
||||
for x_off in 0..width_tiles {
|
||||
unsafe {
|
||||
DIRTY_TILES.get()[ty * tiles_x + tx + x_off]
|
||||
.store(false, Ordering::Release);
|
||||
};
|
||||
}
|
||||
|
||||
// new meta-tile pos
|
||||
let rect = Rectangle::new(
|
||||
Point::new((tx * TILE_SIZE) as i32, (ty * TILE_SIZE) as i32),
|
||||
Size::new(
|
||||
(width_tiles * TILE_SIZE) as u32,
|
||||
(height_tiles * TILE_SIZE) as u32,
|
||||
),
|
||||
);
|
||||
|
||||
if meta_tiles.push(rect).is_err() {
|
||||
return meta_tiles;
|
||||
};
|
||||
|
||||
tx += width_tiles;
|
||||
self.dirty_tiles.iter().any(|tile| {
|
||||
if tile.load(Ordering::Acquire) {
|
||||
dirty_pixels += TILE_SIZE * TILE_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
meta_tiles
|
||||
dirty_pixels >= threshold_pixels
|
||||
})
|
||||
}
|
||||
|
||||
/// Sends the entire framebuffer to the display
|
||||
@@ -165,71 +122,40 @@ impl<'a> AtomicFrameBuffer<'a> {
|
||||
0,
|
||||
self.size().width as u16 - 1,
|
||||
self.size().height as u16 - 1,
|
||||
&self.0[..],
|
||||
&self.fb[..],
|
||||
)
|
||||
.await?;
|
||||
|
||||
unsafe {
|
||||
for tile in DIRTY_TILES.get_mut().iter() {
|
||||
tile.store(false, Ordering::Release);
|
||||
}
|
||||
};
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn safe_draw<SPI, DC, RST, DELAY>(
|
||||
&mut self,
|
||||
display: &mut ST7365P<SPI, DC, RST, DELAY>,
|
||||
) -> Result<(), ()>
|
||||
where
|
||||
SPI: SpiDevice,
|
||||
DC: OutputPin,
|
||||
RST: OutputPin,
|
||||
DELAY: DelayNs,
|
||||
{
|
||||
let tiles_x = SCREEN_WIDTH / TILE_SIZE;
|
||||
let _tiles_y = SCREEN_HEIGHT / TILE_SIZE;
|
||||
|
||||
let tiles = unsafe { DIRTY_TILES.get_mut() };
|
||||
let mut pixel_buffer: heapless::Vec<u16, { TILE_SIZE * TILE_SIZE }> = heapless::Vec::new();
|
||||
|
||||
for tile_idx in 0..TILE_COUNT {
|
||||
if tiles[tile_idx].swap(false, Ordering::AcqRel) {
|
||||
let tx = tile_idx % tiles_x;
|
||||
let ty = tile_idx / tiles_x;
|
||||
|
||||
let x_start = tx * TILE_SIZE;
|
||||
let y_start = ty * TILE_SIZE;
|
||||
|
||||
let x_end = (x_start + TILE_SIZE).min(SCREEN_WIDTH);
|
||||
let y_end = (y_start + TILE_SIZE).min(SCREEN_HEIGHT);
|
||||
|
||||
pixel_buffer.clear();
|
||||
|
||||
for y in y_start..y_end {
|
||||
let start = y * SCREEN_WIDTH + x_start;
|
||||
let end = y * SCREEN_WIDTH + x_end;
|
||||
pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
|
||||
}
|
||||
|
||||
display
|
||||
.set_pixels_buffered(
|
||||
x_start as u16,
|
||||
y_start as u16,
|
||||
(x_end - 1) as u16,
|
||||
(y_end - 1) as u16,
|
||||
&pixel_buffer,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
for tile in self.dirty_tiles.iter() {
|
||||
tile.store(false, Ordering::Release);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Sends only dirty tiles (16x16px) in batches to the display
|
||||
// copy N tiles horizontally to the right into batch tile buf
|
||||
fn append_tiles_to_batch(
|
||||
&mut self,
|
||||
tile_x: u16,
|
||||
tile_y: u16,
|
||||
total_tiles: u16, // number of tiles being written to buf
|
||||
) {
|
||||
debug_assert!(total_tiles as usize <= NUM_TILE_COLS);
|
||||
for batch_row_num in 0..TILE_SIZE {
|
||||
let batch_row_offset = batch_row_num * total_tiles as usize * TILE_SIZE;
|
||||
let batch_row = &mut self.batch_tile_buf
|
||||
[batch_row_offset..batch_row_offset + (total_tiles as usize * TILE_SIZE)];
|
||||
|
||||
let fb_row_offset = (tile_y as usize * TILE_SIZE + batch_row_num) * SCREEN_WIDTH
|
||||
+ tile_x as usize * TILE_SIZE;
|
||||
let fb_row =
|
||||
&self.fb[fb_row_offset..fb_row_offset + (total_tiles as usize * TILE_SIZE)];
|
||||
|
||||
batch_row.copy_from_slice(fb_row);
|
||||
}
|
||||
}
|
||||
|
||||
// Pushes tiles to the display in batches to avoid full frame pushes (unless needed)
|
||||
pub async fn partial_draw<SPI, DC, RST, DELAY>(
|
||||
&mut self,
|
||||
display: &mut ST7365P<SPI, DC, RST, DELAY>,
|
||||
@@ -240,55 +166,53 @@ impl<'a> AtomicFrameBuffer<'a> {
|
||||
RST: OutputPin,
|
||||
DELAY: DelayNs,
|
||||
{
|
||||
if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
|
||||
let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
|
||||
let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
|
||||
if self.should_full_draw() {
|
||||
return self.draw(display).await;
|
||||
}
|
||||
|
||||
let meta_tiles = self.find_meta_tiles(tiles_x, tiles_y);
|
||||
for tile_row in 0..NUM_TILE_ROWS {
|
||||
let row_start_idx = tile_row * NUM_TILE_COLS;
|
||||
let mut col = 0;
|
||||
|
||||
// buffer for copying meta tiles before sending to display
|
||||
let mut pixel_buffer: heapless::Vec<u16, { MAX_META_TILES * TILE_SIZE * TILE_SIZE }> =
|
||||
heapless::Vec::new();
|
||||
while col < NUM_TILE_COLS {
|
||||
// Check for dirty tile
|
||||
if self.dirty_tiles[row_start_idx + col].swap(false, Ordering::Acquire) {
|
||||
let run_start = col;
|
||||
let mut run_len = 1;
|
||||
|
||||
for rect in meta_tiles {
|
||||
let rect_width = rect.size.width as usize;
|
||||
let rect_height = rect.size.height as usize;
|
||||
let rect_x = rect.top_left.x as usize;
|
||||
let rect_y = rect.top_left.y as usize;
|
||||
|
||||
pixel_buffer.clear();
|
||||
|
||||
for row in 0..rect_height {
|
||||
let y = rect_y + row;
|
||||
let start = y * SCREEN_WIDTH + rect_x;
|
||||
let end = start + rect_width;
|
||||
|
||||
// Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
|
||||
pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
|
||||
}
|
||||
|
||||
display
|
||||
.set_pixels_buffered(
|
||||
rect_x as u16,
|
||||
rect_y as u16,
|
||||
(rect_x + rect_width - 1) as u16,
|
||||
(rect_y + rect_height - 1) as u16,
|
||||
&pixel_buffer,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// walk the meta-tile and set as clean
|
||||
let start_tx = rect_x / TILE_SIZE;
|
||||
let start_ty = rect_y / TILE_SIZE;
|
||||
let end_tx = (rect_x + rect_width - 1) / TILE_SIZE;
|
||||
let end_ty = (rect_y + rect_height - 1) / TILE_SIZE;
|
||||
|
||||
for ty in start_ty..=end_ty {
|
||||
for tx in start_tx..=end_tx {
|
||||
let tile_idx = ty * tiles_x + tx;
|
||||
unsafe { DIRTY_TILES.get_mut()[tile_idx].store(false, Ordering::Release) };
|
||||
// Extend run while contiguous dirty tiles and within MAX_BATCH_TILES
|
||||
while col + 1 < NUM_TILE_COLS
|
||||
&& self.dirty_tiles[row_start_idx + col + 1].load(Ordering::Acquire)
|
||||
&& run_len < MAX_BATCH_TILES
|
||||
{
|
||||
col += 1;
|
||||
run_len += 1;
|
||||
}
|
||||
|
||||
// Copy the whole horizontal run into the batch buffer in one call
|
||||
let tile_x = run_start;
|
||||
let tile_y = tile_row;
|
||||
self.append_tiles_to_batch(tile_x as u16, tile_y as u16, run_len as u16);
|
||||
|
||||
// Compute coordinates for display write
|
||||
let start_x = tile_x * TILE_SIZE;
|
||||
let end_x = start_x + run_len * TILE_SIZE - 1;
|
||||
let start_y = tile_y * TILE_SIZE;
|
||||
let end_y = start_y + TILE_SIZE - 1;
|
||||
|
||||
// Send batch to display
|
||||
display
|
||||
.set_pixels_buffered(
|
||||
start_x as u16,
|
||||
start_y as u16,
|
||||
end_x as u16,
|
||||
end_y as u16,
|
||||
&self.batch_tile_buf[..run_len * TILE_SIZE * TILE_SIZE],
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
|
||||
col += 1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -309,14 +233,14 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
|
||||
|
||||
for Pixel(coord, color) in pixels {
|
||||
if coord.x >= 0 && coord.y >= 0 {
|
||||
let x = coord.x as i32;
|
||||
let y = coord.y as i32;
|
||||
let x = coord.x;
|
||||
let y = coord.y;
|
||||
|
||||
if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
|
||||
let idx = (y as usize) * SCREEN_WIDTH + (x as usize);
|
||||
let raw_color = RawU16::from(color).into_inner();
|
||||
if self.0[idx] != raw_color {
|
||||
self.0[idx] = raw_color;
|
||||
if self.fb[idx] != raw_color {
|
||||
self.fb[idx] = raw_color;
|
||||
changed = true;
|
||||
}
|
||||
|
||||
@@ -365,8 +289,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
|
||||
if let Some(color) = colors.next() {
|
||||
let idx = (p.y as usize * SCREEN_WIDTH) + (p.x as usize);
|
||||
let raw_color = RawU16::from(color).into_inner();
|
||||
if self.0[idx] != raw_color {
|
||||
self.0[idx] = raw_color;
|
||||
if self.fb[idx] != raw_color {
|
||||
self.fb[idx] = raw_color;
|
||||
changed = true;
|
||||
}
|
||||
} else {
|
||||
@@ -404,7 +328,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
|
||||
.take((self.size().width * self.size().height) as usize),
|
||||
)?;
|
||||
|
||||
for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
|
||||
for tile in self.dirty_tiles.iter() {
|
||||
tile.store(true, Ordering::Release);
|
||||
}
|
||||
|
||||
|
||||
@@ -12,8 +12,10 @@ mod abi;
|
||||
mod display;
|
||||
mod elf;
|
||||
mod framebuffer;
|
||||
#[allow(unused)]
|
||||
mod heap;
|
||||
mod peripherals;
|
||||
#[allow(unused)]
|
||||
mod psram;
|
||||
mod scsi;
|
||||
mod storage;
|
||||
@@ -27,6 +29,7 @@ use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi};
|
||||
use crate::{
|
||||
abi::{KEY_CACHE, MS_SINCE_LAUNCH},
|
||||
display::{FRAMEBUFFER, display_handler, init_display},
|
||||
heap::HEAP,
|
||||
peripherals::{
|
||||
conf_peripherals,
|
||||
keyboard::{KeyState, read_keyboard_fifo},
|
||||
@@ -225,6 +228,7 @@ struct Sd {
|
||||
cs: Peri<'static, PIN_17>,
|
||||
det: Peri<'static, PIN_22>,
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
struct Psram {
|
||||
pio: Peri<'static, PIO0>,
|
||||
sclk: Peri<'static, PIN_21>,
|
||||
@@ -328,10 +332,14 @@ async fn kernel_task(
|
||||
|
||||
setup_mcu(mcu).await;
|
||||
|
||||
defmt::info!("setting up psram");
|
||||
Timer::after_millis(100).await;
|
||||
|
||||
// setup_psram(psram).await;
|
||||
#[cfg(feature = "pimoroni2w")]
|
||||
setup_qmi_psram().await;
|
||||
|
||||
Timer::after_millis(100).await;
|
||||
setup_display(display, spawner).await;
|
||||
setup_sd(sd).await;
|
||||
|
||||
|
||||
@@ -549,13 +549,13 @@ pub fn init_psram_qmi(
|
||||
let min_deselect: u32 = ((18 * 1_000_000 + (clock_period_fs - 1)) / clock_period_fs
|
||||
- u64::from(divisor + 1) / 2) as u32;
|
||||
|
||||
#[cfg(feature = "defmt")]
|
||||
defmt::info!(
|
||||
"clock_period_fs={} max_select={} min_deselect={}",
|
||||
clock_period_fs,
|
||||
max_select,
|
||||
min_deselect
|
||||
);
|
||||
// #[cfg(feature = "defmt")]
|
||||
// defmt::info!(
|
||||
// "clock_period_fs={} max_select={} min_deselect={}",
|
||||
// clock_period_fs,
|
||||
// max_select,
|
||||
// min_deselect
|
||||
// );
|
||||
|
||||
qmi.direct_csr().write(|w| {
|
||||
w.set_clkdiv(10);
|
||||
|
||||
10
selection_ui/Cargo.toml
Normal file
10
selection_ui/Cargo.toml
Normal file
@@ -0,0 +1,10 @@
|
||||
[package]
|
||||
name = "selection_ui"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
abi = { path = "../abi" }
|
||||
embedded-graphics = "0.8.1"
|
||||
embedded-layout = "0.4.2"
|
||||
embedded-text = "0.7.3"
|
||||
119
selection_ui/src/lib.rs
Normal file
119
selection_ui/src/lib.rs
Normal file
@@ -0,0 +1,119 @@
|
||||
#![no_std]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
use abi::{
|
||||
display::Display,
|
||||
get_key,
|
||||
keyboard::{KeyCode, KeyState},
|
||||
print, sleep,
|
||||
};
|
||||
use alloc::vec::Vec;
|
||||
use embedded_graphics::{
|
||||
Drawable,
|
||||
mono_font::{MonoTextStyle, ascii::FONT_10X20},
|
||||
pixelcolor::Rgb565,
|
||||
prelude::{Dimensions, Point, Primitive, RgbColor, Size},
|
||||
primitives::{PrimitiveStyle, Rectangle},
|
||||
text::Text,
|
||||
};
|
||||
use embedded_layout::{
|
||||
align::{horizontal, vertical},
|
||||
layout::linear::{FixedMargin, LinearLayout},
|
||||
prelude::*,
|
||||
};
|
||||
use embedded_text::TextBox;
|
||||
|
||||
pub struct SelectionUi<'a> {
|
||||
selection: usize,
|
||||
items: &'a [&'a str],
|
||||
error: &'a str,
|
||||
last_bounds: Option<Rectangle>,
|
||||
}
|
||||
|
||||
impl<'a> SelectionUi<'a> {
|
||||
pub fn new(items: &'a [&'a str], error: &'a str) -> Self {
|
||||
Self {
|
||||
selection: 0,
|
||||
items,
|
||||
error,
|
||||
last_bounds: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_selection_ui(&mut self, display: &mut Display) -> Result<Option<usize>, ()> {
|
||||
self.draw(display)?;
|
||||
let selection;
|
||||
loop {
|
||||
let key = get_key();
|
||||
if key.state == KeyState::Pressed {
|
||||
print!("Got Key press: {:?}", key.key);
|
||||
if let Some(s) = self.update(display, key.key)? {
|
||||
selection = Some(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(selection)
|
||||
}
|
||||
|
||||
/// updates the display with a new keypress.
|
||||
/// returns selection idx if selected
|
||||
pub fn update(&mut self, display: &mut Display, key: KeyCode) -> Result<Option<usize>, ()> {
|
||||
match key {
|
||||
KeyCode::JoyUp => {
|
||||
self.selection = self.selection.saturating_sub(1);
|
||||
}
|
||||
KeyCode::JoyDown => {
|
||||
self.selection = self.selection.saturating_add(1);
|
||||
}
|
||||
KeyCode::Enter | KeyCode::JoyRight => return Ok(Some(self.selection)),
|
||||
_ => return Ok(Some(self.selection)),
|
||||
};
|
||||
self.draw(display)?;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn draw(&mut self, display: &mut Display) -> Result<(), ()> {
|
||||
let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
|
||||
let display_area = display.bounding_box();
|
||||
|
||||
if self.items.is_empty() {
|
||||
TextBox::new(
|
||||
&self.error,
|
||||
Rectangle::new(
|
||||
Point::new(25, 25),
|
||||
Size::new(display_area.size.width - 50, display_area.size.width - 50),
|
||||
),
|
||||
text_style,
|
||||
)
|
||||
.draw(display)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
let mut views: Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
|
||||
|
||||
for i in self.items {
|
||||
views.push(Text::new(i, Point::zero(), text_style));
|
||||
}
|
||||
|
||||
let views_group = Views::new(views.as_mut_slice());
|
||||
|
||||
let layout = LinearLayout::vertical(views_group)
|
||||
.with_alignment(horizontal::Center)
|
||||
.with_spacing(FixedMargin(5))
|
||||
.arrange()
|
||||
.align_to(&display_area, horizontal::Center, vertical::Center);
|
||||
|
||||
// draw selected box
|
||||
let selected_bounds = layout.inner().get(self.selection).ok_or(())?.bounding_box();
|
||||
Rectangle::new(selected_bounds.top_left, selected_bounds.size)
|
||||
.into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
|
||||
.draw(display)?;
|
||||
|
||||
self.last_bounds = Some(layout.bounds());
|
||||
|
||||
layout.draw(display)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
[package]
|
||||
name = "doom"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
abi = { path = "../../abi" }
|
||||
embedded-graphics = "0.8.1"
|
||||
|
||||
[build-dependencies]
|
||||
bindgen = "0.71.0"
|
||||
cc = "1.0"
|
||||
@@ -1,126 +0,0 @@
|
||||
//! This build script copies the `memory.x` file from the crate root into
|
||||
//! a directory where the linker can always find it at build time.
|
||||
//! For many projects this is optional, as the linker always searches the
|
||||
//! project root directory -- wherever `Cargo.toml` is. However, if you
|
||||
//! are using a workspace or have a more complicated build setup, this
|
||||
//! build script becomes required. Additionally, by requesting that
|
||||
//! Cargo re-run the build script whenever `memory.x` is changed,
|
||||
//! updating `memory.x` ensures a rebuild of the application with the
|
||||
//! new memory settings.
|
||||
|
||||
use std::env;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
fn main() {
|
||||
build_newlib();
|
||||
build_doom();
|
||||
|
||||
// Put `memory.x` in our output directory and ensure it's
|
||||
// on the linker search path.
|
||||
let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
|
||||
File::create(out.join("memory.x"))
|
||||
.unwrap()
|
||||
.write_all(include_bytes!("memory.x"))
|
||||
.unwrap();
|
||||
println!("cargo:rustc-link-search={}", out.display());
|
||||
|
||||
println!("cargo:rerun-if-changed=memory.x");
|
||||
println!("cargo:rustc-link-arg-bins=-Tmemory.x");
|
||||
}
|
||||
|
||||
// TODO: use target to change newlib build - only workds for rp2350 right now
|
||||
fn build_newlib() {
|
||||
let out_dir = std::env::var("OUT_DIR").unwrap();
|
||||
let picolibc_dir = format!("{}/picolibc", out_dir);
|
||||
|
||||
if !Path::new(&picolibc_dir).exists() {
|
||||
let status = Command::new("git")
|
||||
.args(&[
|
||||
"clone",
|
||||
"https://github.com/picolibc/picolibc",
|
||||
&picolibc_dir,
|
||||
])
|
||||
.status()
|
||||
.expect("Failed to clone picolibc");
|
||||
assert!(status.success());
|
||||
}
|
||||
|
||||
let build_dir = format!("{}/build", picolibc_dir);
|
||||
std::fs::create_dir_all(&build_dir).unwrap();
|
||||
|
||||
let status = Command::new(&format!("{picolibc_dir}/scripts/do-configure"))
|
||||
.current_dir(&build_dir)
|
||||
.args(&[
|
||||
"thumbv8m_main_fp-none-eabi",
|
||||
"--buildtype=minsize",
|
||||
"-Dtests=true",
|
||||
"-Dtinystdio=false",
|
||||
"-Dsingle-thread=true",
|
||||
"-Db_pie=true",
|
||||
"-Ddefault_library=static",
|
||||
"-Dtinystdio=false",
|
||||
"-Dmultilib=false",
|
||||
".",
|
||||
])
|
||||
.status()
|
||||
.expect("Failed to run Meson configure");
|
||||
assert!(status.success());
|
||||
|
||||
let status = Command::new("ninja")
|
||||
.current_dir(&build_dir)
|
||||
.status()
|
||||
.expect("Failed to run Ninja build");
|
||||
assert!(status.success());
|
||||
|
||||
println!("cargo:rustc-link-search={}/newlib", build_dir);
|
||||
println!("cargo:rustc-link-lib=c");
|
||||
println!("cargo:rustc-link-lib=m");
|
||||
}
|
||||
|
||||
fn build_doom() {
|
||||
let ref dg_src_dir = std::path::PathBuf::from("doomgeneric/doomgeneric");
|
||||
let mut dg_c_paths = vec![];
|
||||
let mut dg_h_paths = vec![];
|
||||
|
||||
// Find most c and h files
|
||||
for entry in std::fs::read_dir(dg_src_dir).unwrap() {
|
||||
let entry = entry.unwrap();
|
||||
if let Some(filename) = entry.file_name().to_str() {
|
||||
if filename.starts_with("doomgeneric")
|
||||
|| filename.contains("_allegro")
|
||||
|| filename.contains("_sdl")
|
||||
|| filename.contains("net_")
|
||||
|| filename == "i_main.c"
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if filename.ends_with(".h") {
|
||||
dg_h_paths.push(dg_src_dir.join(filename));
|
||||
} else if filename.ends_with(".c") {
|
||||
dg_c_paths.push(dg_src_dir.join(filename));
|
||||
}
|
||||
}
|
||||
}
|
||||
dg_c_paths
|
||||
.iter()
|
||||
.chain(dg_h_paths.iter())
|
||||
.for_each(|path| println!("cargo:rerun-if-changed={}", path.to_str().unwrap()));
|
||||
|
||||
cc::Build::new()
|
||||
.compiler("arm-none-eabi-gcc")
|
||||
.flag("-w") // silence warnings
|
||||
.flag("-Os") // optimize for size
|
||||
.flag("-ffunction-sections")
|
||||
.flag("-fdata-sections")
|
||||
.define("CMAP256", None)
|
||||
.define("DOOMGENERIC_RESX", Some("320"))
|
||||
.define("DOOMGENERIC_RESY", Some("200"))
|
||||
.flag_if_supported("-std=gnu99")
|
||||
.define("_POSIX_C_SOURCE", Some("200809L"))
|
||||
.files(dg_c_paths)
|
||||
.compile("doomgeneric");
|
||||
}
|
||||
Submodule user-apps/doom/doomgeneric deleted from fc60163949
@@ -1,31 +0,0 @@
|
||||
MEMORY
|
||||
{
|
||||
RAM : ORIGIN = 0x0, LENGTH = 400K
|
||||
}
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
.text : ALIGN(4)
|
||||
{
|
||||
*(.text .text.*);
|
||||
*(.rodata .rodata.*);
|
||||
} > RAM
|
||||
|
||||
.data : ALIGN(4)
|
||||
{
|
||||
*(.data .data.*);
|
||||
} > RAM
|
||||
|
||||
.bss : ALIGN(4)
|
||||
{
|
||||
*(.bss .bss.*);
|
||||
*(COMMON);
|
||||
} > RAM
|
||||
|
||||
.syscall_table (NOLOAD) : ALIGN(4)
|
||||
{
|
||||
__user_reloc_start = .;
|
||||
KEEP(*(.user_reloc*));
|
||||
__user_reloc_end = .;
|
||||
} > RAM
|
||||
}
|
||||
@@ -1,112 +0,0 @@
|
||||
use abi::{
|
||||
abi_sys::{get_ms, sleep},
|
||||
display::Display,
|
||||
};
|
||||
use core::ffi::{c_int, c_uchar};
|
||||
use embedded_graphics::{
|
||||
Drawable, Pixel,
|
||||
draw_target::DrawTarget,
|
||||
pixelcolor::Rgb565,
|
||||
prelude::{Point, RgbColor},
|
||||
};
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
#[allow(non_snake_case)]
|
||||
static mut DG_ScreenBuffer: *const u8 = core::ptr::null();
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct RGBA {
|
||||
pub b: u8,
|
||||
pub g: u8,
|
||||
pub r: u8,
|
||||
pub a: u8,
|
||||
}
|
||||
|
||||
unsafe extern "C" {
|
||||
fn D_DoomMain();
|
||||
fn doomgeneric_Tick();
|
||||
fn M_FindResponseFile();
|
||||
|
||||
pub static colors: [RGBA; 256];
|
||||
}
|
||||
|
||||
pub fn tick() {
|
||||
unsafe { doomgeneric_Tick() };
|
||||
}
|
||||
|
||||
pub struct ScreenBuffer<const RESX: usize, const RESY: usize, const SIZE: usize>(pub [u8; SIZE]);
|
||||
|
||||
impl<const RESX: usize, const RESY: usize, const SIZE: usize> ScreenBuffer<RESX, RESY, SIZE> {
|
||||
#[allow(dead_code)]
|
||||
const NA: () = assert!(SIZE == RESX * RESY);
|
||||
|
||||
pub const fn new() -> Self {
|
||||
Self([0_u8; SIZE])
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn DG_SetWindowTitle() {}
|
||||
|
||||
pub fn create<const RESX: usize, const RESY: usize, const SIZE: usize>(
|
||||
screenbuffer: &ScreenBuffer<RESX, RESY, SIZE>,
|
||||
) {
|
||||
unsafe {
|
||||
M_FindResponseFile();
|
||||
|
||||
DG_ScreenBuffer = screenbuffer.0.as_ptr();
|
||||
|
||||
D_DoomMain();
|
||||
}
|
||||
}
|
||||
|
||||
const X: usize = 320;
|
||||
const Y: usize = 200;
|
||||
const SIZE: usize = X * Y;
|
||||
|
||||
pub static mut DISPLAY: Option<Display> = None;
|
||||
pub static mut SCREEN_BUFFER: ScreenBuffer<X, Y, SIZE> = ScreenBuffer::new();
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn DG_DrawFrame() {
|
||||
let palette565: [Rgb565; 256] = unsafe {
|
||||
colors.map(|c| {
|
||||
Rgb565::new(
|
||||
((c.r as u16 * 31) / 255) as u8, // red 5 bits
|
||||
((c.g as u16 * 63) / 255) as u8, // green 6 bits
|
||||
((c.b as u16 * 31) / 255) as u8, // blue 5 bits
|
||||
)
|
||||
})
|
||||
};
|
||||
let buf = unsafe { &SCREEN_BUFFER.0 };
|
||||
|
||||
let display = unsafe { DISPLAY.as_mut().unwrap() };
|
||||
display.clear(Rgb565::BLACK).unwrap();
|
||||
|
||||
for y in 0..Y {
|
||||
for x in 0..X {
|
||||
let idx = y * X + x;
|
||||
let color = palette565[buf[idx] as usize];
|
||||
|
||||
Pixel(Point::new(x as i32, y as i32), color)
|
||||
.draw(display)
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn DG_GetTicksMs() -> u32 {
|
||||
get_ms() as u32
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn DG_GetKey(pressed: *mut c_int, key: *mut c_uchar) -> c_int {
|
||||
0
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn DG_SleepMs(ms: u32) {
|
||||
sleep(ms.into());
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
use core::ffi::{c_char, c_int, c_uchar, c_void};
|
||||
use core::ptr;
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub static _ctype_: [c_uchar; 256] = [0u8; 256];
|
||||
|
||||
#[repr(C)]
|
||||
pub struct Reent {
|
||||
pub errno: c_int,
|
||||
_reserved: [u8; 32],
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub static mut _reent_data: Reent = Reent {
|
||||
errno: 0,
|
||||
_reserved: [0; 32],
|
||||
};
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub static mut _impure_ptr: *mut Reent = unsafe { &mut _reent_data as *mut Reent };
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn __errno() -> *mut c_int {
|
||||
unsafe { &mut (*_impure_ptr).errno as *mut c_int }
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn exit(_status: i32) -> ! {
|
||||
loop {}
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn close(_file: i32) -> i32 {
|
||||
-1
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct Stat {
|
||||
st_mode: u32,
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn fstat(_file: i32, st: *mut Stat) -> i32 {
|
||||
unsafe {
|
||||
if !st.is_null() {
|
||||
(*st).st_mode = 0x2000; // S_IFCHR
|
||||
}
|
||||
}
|
||||
0
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn isatty(_file: i32) -> i32 {
|
||||
1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn lseek(_file: i32, _ptr: i32, _dir: i32) -> i32 {
|
||||
0
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn lseek64(_fd: c_int, _offset: i64, _whence: c_int) -> i64 {
|
||||
0
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn open(_name: *const u8, _flags: i32, _mode: i32) -> i32 {
|
||||
-1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn read(_file: i32, _ptr: *mut u8, len: usize) -> i32 {
|
||||
len as i32
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn write(_file: i32, _ptr: *const u8, len: usize) -> i32 {
|
||||
len as i32
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn rename(_old: *const c_char, _new: *const c_char) -> c_int {
|
||||
-1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn kill(_pid: i32, _sig: i32) -> i32 {
|
||||
-1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn getpid() -> i32 {
|
||||
1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn link(_old: *const u8, _new: *const u8) -> i32 {
|
||||
-1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn unlink(_name: *const u8) -> i32 {
|
||||
-1
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn mkdir(_path: *const u8, _mode: u32) -> i32 {
|
||||
0
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn sbrk(incr: isize) -> *mut c_void {
|
||||
core::ptr::null_mut()
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "C" fn fini() {}
|
||||
@@ -1,43 +0,0 @@
|
||||
#![no_std]
|
||||
#![no_main]
|
||||
#![allow(static_mut_refs)]
|
||||
#![feature(c_variadic)]
|
||||
|
||||
extern crate alloc;
|
||||
use abi::{
|
||||
display::Display,
|
||||
fs::{file_len, read_file},
|
||||
get_key, get_ms,
|
||||
keyboard::{KeyCode, KeyState},
|
||||
print, sleep,
|
||||
};
|
||||
use alloc::vec;
|
||||
use core::panic::PanicInfo;
|
||||
use embedded_graphics::{pixelcolor::Rgb565, prelude::Point};
|
||||
|
||||
mod doom;
|
||||
use crate::doom::{DISPLAY, SCREEN_BUFFER, create, tick};
|
||||
mod libc;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic(info: &PanicInfo) -> ! {
|
||||
print!("user panic: {} @ {:?}", info.message(), info.location(),);
|
||||
loop {}
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub extern "Rust" fn _start() {
|
||||
main()
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
print!("Starting Doom app");
|
||||
let display = Display;
|
||||
unsafe { DISPLAY = Some(display) };
|
||||
|
||||
unsafe { create(&SCREEN_BUFFER) };
|
||||
|
||||
loop {
|
||||
tick();
|
||||
}
|
||||
}
|
||||
@@ -5,12 +5,12 @@
|
||||
extern crate alloc;
|
||||
use abi::{
|
||||
display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
|
||||
fs::{list_dir, read_file},
|
||||
fs::{Entries, list_dir, read_file},
|
||||
get_key,
|
||||
keyboard::{KeyCode, KeyState},
|
||||
print,
|
||||
};
|
||||
use alloc::{format, string::ToString, vec};
|
||||
use alloc::{format, vec};
|
||||
use core::panic::PanicInfo;
|
||||
use embedded_graphics::{
|
||||
Drawable, image::Image, mono_font::MonoTextStyle, mono_font::ascii::FONT_6X10,
|
||||
@@ -34,7 +34,6 @@ pub fn main() {
|
||||
let mut bmp_buf = vec![0_u8; 100_000];
|
||||
let mut display = Display;
|
||||
|
||||
// Grid parameters
|
||||
let grid_cols = 3;
|
||||
let grid_rows = 3;
|
||||
let cell_width = SCREEN_WIDTH as i32 / grid_cols;
|
||||
@@ -42,50 +41,44 @@ pub fn main() {
|
||||
|
||||
let mut images_drawn = 0;
|
||||
|
||||
let mut files = [const { None }; 18];
|
||||
let files_num = list_dir("/images", &mut files);
|
||||
let mut entries = Entries::new();
|
||||
let files_num = list_dir("/images", &mut entries);
|
||||
|
||||
for file in &files[2..files_num] {
|
||||
for file in &entries.entries()[2..files_num] {
|
||||
if images_drawn >= grid_cols * grid_rows {
|
||||
break; // only draw 3x3
|
||||
}
|
||||
|
||||
if let Some(f) = file {
|
||||
print!("file: {}", f.name);
|
||||
if f.name.extension() == b"bmp" || f.name.extension() == b"BMP" {
|
||||
let file = format!("/images/{}", f.name);
|
||||
print!("file: {}", file);
|
||||
if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" {
|
||||
let file_path = format!("/images/{}", file);
|
||||
|
||||
let read = read_file(&file, 0, &mut &mut bmp_buf[..]);
|
||||
if read > 0 {
|
||||
let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
|
||||
let read = read_file(&file_path, 0, &mut &mut bmp_buf[..]);
|
||||
if read > 0 {
|
||||
let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
|
||||
|
||||
let row = images_drawn / grid_cols;
|
||||
let col = images_drawn % grid_cols;
|
||||
let cell_x = col * cell_width;
|
||||
let cell_y = row * cell_height;
|
||||
let row = images_drawn / grid_cols;
|
||||
let col = images_drawn % grid_cols;
|
||||
let cell_x = col * cell_width;
|
||||
let cell_y = row * cell_height;
|
||||
|
||||
// Center image inside cell
|
||||
let bmp_w = bmp.size().width as i32;
|
||||
let bmp_h = bmp.size().height as i32;
|
||||
let x = cell_x + (cell_width - bmp_w) / 2;
|
||||
let y = cell_y + 5; // 5px top margin
|
||||
// Center image inside cell
|
||||
let bmp_w = bmp.size().width as i32;
|
||||
let bmp_h = bmp.size().height as i32;
|
||||
let x = cell_x + (cell_width - bmp_w) / 2;
|
||||
let y = cell_y + 5; // 5px top margin
|
||||
|
||||
Image::new(&bmp, Point::new(x, y))
|
||||
.draw(&mut display)
|
||||
.unwrap();
|
||||
|
||||
let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
|
||||
let text_y = y + bmp_h + 2; // 2px gap under image
|
||||
Text::new(
|
||||
f.name.to_string().as_str(),
|
||||
Point::new(cell_x + 2, text_y),
|
||||
text_style,
|
||||
)
|
||||
Image::new(&bmp, Point::new(x, y))
|
||||
.draw(&mut display)
|
||||
.unwrap();
|
||||
|
||||
images_drawn += 1;
|
||||
}
|
||||
let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
|
||||
let text_y = y + bmp_h + 2; // 2px gap under image
|
||||
Text::new(&file.base(), Point::new(cell_x + 2, text_y), text_style)
|
||||
.draw(&mut display)
|
||||
.unwrap();
|
||||
|
||||
images_drawn += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,4 +6,5 @@ edition = "2024"
|
||||
[dependencies]
|
||||
abi = { path = "../../abi" }
|
||||
embedded-graphics = "0.8.1"
|
||||
selection_ui = { path = "../../selection_ui" }
|
||||
tinygif = { git = "https://github.com/LegitCamper/tinygif" }
|
||||
|
||||
@@ -4,16 +4,17 @@
|
||||
extern crate alloc;
|
||||
use abi::{
|
||||
display::Display,
|
||||
fs::{file_len, read_file},
|
||||
fs::{Entries, file_len, list_dir, read_file},
|
||||
get_key, get_ms,
|
||||
keyboard::{KeyCode, KeyState},
|
||||
print, sleep,
|
||||
};
|
||||
use alloc::vec;
|
||||
use alloc::{format, vec, vec::Vec};
|
||||
use core::panic::PanicInfo;
|
||||
use embedded_graphics::{
|
||||
image::ImageDrawable, pixelcolor::Rgb565, prelude::Point, transform::Transform,
|
||||
};
|
||||
use selection_ui::SelectionUi;
|
||||
use tinygif::Gif;
|
||||
|
||||
#[panic_handler]
|
||||
@@ -31,13 +32,27 @@ pub fn main() {
|
||||
print!("Starting Gif app");
|
||||
let mut display = Display;
|
||||
|
||||
let size = file_len("/gifs/bad_apple.gif");
|
||||
let mut entries = Entries::new();
|
||||
list_dir("/gifs", &mut entries);
|
||||
|
||||
let mut files = entries.entries();
|
||||
files.retain(|e| e.extension().unwrap_or("") == "gif");
|
||||
let gifs = &files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
|
||||
|
||||
let mut selection_ui = SelectionUi::new(&gifs, "No Gif files found in /gifs");
|
||||
let selection = selection_ui
|
||||
.run_selection_ui(&mut display)
|
||||
.expect("failed to draw")
|
||||
.expect("Failed to get user selection");
|
||||
|
||||
let file_name = format!("/gifs/{}", gifs[selection]);
|
||||
let size = file_len(&file_name);
|
||||
let mut buf = vec![0_u8; size];
|
||||
let read = read_file("/gifs/bad_apple.gif", 0, &mut buf);
|
||||
let read = read_file(&file_name, 0, &mut buf);
|
||||
print!("read: {}, file size: {}", read, size);
|
||||
assert!(read == size);
|
||||
|
||||
let gif = Gif::<Rgb565>::from_slice(&buf).unwrap();
|
||||
let gif = Gif::<Rgb565>::from_slice(&buf).expect("Failed to parse gif");
|
||||
let height = gif.height();
|
||||
|
||||
let mut frame_num = 0;
|
||||
@@ -51,11 +66,14 @@ pub fn main() {
|
||||
.unwrap();
|
||||
frame_num += 1;
|
||||
|
||||
if frame_num % 100 == 0 {
|
||||
if frame_num % 5 == 0 {
|
||||
let event = get_key();
|
||||
if event.state != KeyState::Idle {
|
||||
match event.key {
|
||||
KeyCode::Esc => return,
|
||||
KeyCode::Esc => {
|
||||
drop(buf);
|
||||
return;
|
||||
}
|
||||
_ => (),
|
||||
};
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user