stash to hold stuff till cargo fix

This commit is contained in:
Able 2022-01-22 00:01:16 -06:00
parent bbe2a0183a
commit b47e8bd64c
28 changed files with 773 additions and 11602 deletions

164
ableos/Cargo.lock generated
View file

@ -35,15 +35,22 @@ dependencies = [
"lliw",
"log",
"pic8259",
"picorand",
"pretty-hex",
"rkyv",
"serde",
"serde_json",
"shadeable",
"smoltcp",
"spin",
"uart_16550",
"unicode-width",
"vga",
"volatile 0.2.7",
"wasmi",
"watson",
"x86_64",
"y-compositor-protocol",
]
[[package]]
@ -82,6 +89,12 @@ version = "0.9.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a62c8f6168cd106687ee36a2b71a46c4144d73399f72814104d33094b8092fd2"
[[package]]
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
[[package]]
name = "cfg-if"
version = "1.0.0"
@ -176,6 +189,15 @@ dependencies = [
"wasi",
]
[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
dependencies = [
"ahash",
]
[[package]]
name = "instant"
version = "0.1.12"
@ -185,6 +207,12 @@ dependencies = [
"cfg-if",
]
[[package]]
name = "itoa"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
[[package]]
name = "lazy_static"
version = "1.4.0"
@ -239,6 +267,12 @@ dependencies = [
"cfg-if",
]
[[package]]
name = "managed"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d"
[[package]]
name = "memory_units"
version = "0.3.0"
@ -312,6 +346,12 @@ dependencies = [
"x86_64",
]
[[package]]
name = "picorand"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6fc30519d2508c7e20e01da371cd27b1d4533fdb98e279955cb636b50210688"
[[package]]
name = "pretty-hex"
version = "0.2.1"
@ -333,6 +373,26 @@ dependencies = [
"unicode-xid",
]
[[package]]
name = "ptr_meta"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
dependencies = [
"ptr_meta_derive",
]
[[package]]
name = "ptr_meta_derive"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "quote"
version = "1.0.14"
@ -370,17 +430,84 @@ dependencies = [
"syn",
]
[[package]]
name = "rkyv"
version = "0.7.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49a37de5dfc60bae2d94961dacd03c7b80e426b66a99fa1b17799570dbdd8f96"
dependencies = [
"hashbrown",
"ptr_meta",
"rkyv_derive",
"seahash",
]
[[package]]
name = "rkyv_derive"
version = "0.7.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "719d447dd0e84b23cee6cb5b32d97e21efb112a3e3c636c8da36647b938475a1"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "ryu"
version = "1.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
[[package]]
name = "scopeguard"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "seahash"
version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
[[package]]
name = "serde"
version = "1.0.133"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97565067517b60e2d1ea8b268e59ce036de907ac523ad83a0475da04e818989a"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.133"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed201699328568d8d08208fdd080e3ff594e6c422e438b6705905da01005d537"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.75"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c059c05b48c5c0067d4b4b2b4f0732dd65feb52daf7e0ea09cd87e7dadc1af79"
dependencies = [
"itoa",
"ryu",
"serde",
]
[[package]]
name = "shadeable"
version = "0.1.0"
dependencies = [
"libm",
"log",
"rhai",
"vga",
]
@ -400,6 +527,18 @@ dependencies = [
"static_assertions",
]
[[package]]
name = "smoltcp"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2308a1657c8db1f5b4993bab4e620bdbe5623bd81f254cf60326767bb243237"
dependencies = [
"bitflags",
"byteorder",
"log",
"managed",
]
[[package]]
name = "spin"
version = "0.5.2"
@ -531,6 +670,22 @@ dependencies = [
"parity-wasm",
]
[[package]]
name = "watson"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1cea7ead78c402dbf14e7f11911b0b48955ea13d46e012e2d98775e23c65d4ef"
dependencies = [
"serde",
"webassembly",
]
[[package]]
name = "webassembly"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d1a10e1dedffff9cfcbdd33c289c65b87da634259a460a3f23d513649fa7a8c"
[[package]]
name = "x86_64"
version = "0.14.7"
@ -541,3 +696,12 @@ dependencies = [
"bitflags",
"volatile 0.4.4",
]
[[package]]
name = "y-compositor-protocol"
version = "0.1.1"
source = "git+https://git.ablecorp.us/able/y-compositor-protocol.git#d3bcd0d41c712bfc4b4f0f9e7b5dd470e00c04a2"
dependencies = [
"rkyv",
"serde",
]

View file

@ -9,6 +9,8 @@ panic = "abort"
[package.metadata.bootimage]
run-args = [
"-cpu",
"kvm64-v1",
"-serial",
"stdio",
"-smp",
@ -36,15 +38,45 @@ spin = "0.5.2"
vga = "*"
log= "*"
pretty-hex = "0.2.1"
unicode-width = "0.1.7"
picorand = "*"
watson = "0.4"
[dependencies.serde]
version = "*"
default-features = false
features = ["derive", "alloc"]
[dependencies.serde_json]
version = "*"
default-features = false
features = ["alloc"]
[dependencies.rkyv]
version = "0.7.29"
default-features = false
features = ["size_64", "alloc"]
[dependencies.smoltcp]
version = "0.8.0"
default-features = false
features = ["log", "proto-ipv4"]
[dependencies.y-compositor-protocol]
git = "https://git.ablecorp.us:443/able/y-compositor-protocol.git"
[dependencies.shadeable]
path = "../shadeable"
[dependencies.ab_glyph]
default-features = false
features = ["libm"]

View file

@ -1,5 +1,5 @@
[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
&[255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,

View file

@ -0,0 +1,6 @@
{
"logging_level": "Trace",
"run_tests": false,
"run_demos": false,
"run_shader_tests": true
}

View file

@ -1,8 +1,9 @@
#![allow(clippy::print_literal)]
// #![allow(clippy::print_literal)]
use crate::logger;
use super::{gdt, interrupts};
/// x86_64 initialization
pub fn init() {
let result = logger::init();
match result {
@ -13,5 +14,4 @@ pub fn init() {
interrupts::init_idt();
unsafe { interrupts::PICS.lock().initialize() };
x86_64::instructions::interrupts::enable();
info!("Initialized");
}

52
ableos/src/boot_conf.rs Normal file
View file

@ -0,0 +1,52 @@
use log::LevelFilter;
use serde::{de::value::BoolDeserializer, Deserialize, Serialize};
#[derive(Serialize, Debug, Deserialize)]
pub enum LogLevel {
/// A level lower than all log levels.
Off,
/// Corresponds to the `Error` log level.
Error,
/// Corresponds to the `Warn` log level.
Warn,
/// Corresponds to the `Info` log level.
Info,
/// Corresponds to the `Debug` log level.
Debug,
/// Corresponds to the `Trace` log level.
Trace,
}
#[derive(Serialize, Debug, Deserialize)]
pub struct BootConfig {
pub logging_level: LogLevel,
pub run_tests: bool,
pub run_demos: bool,
pub run_shader_tests: bool,
}
impl BootConfig {
pub fn new() -> Self {
let data = include_str!("../assets/kernel_config.json");
// Parse the string of data into a Person object. This is exactly the
// same function as the one that produced serde_json::Value above, but
// now we are asking it for a Person as output.
let p: BootConfig = serde_json::from_str(data).unwrap();
info!("{:?}", p);
p
}
pub fn log_level(&self) -> LevelFilter {
use LevelFilter::*;
match self.logging_level {
LogLevel::Off => Off,
LogLevel::Error => Error,
LogLevel::Warn => Warn,
LogLevel::Info => Info,
LogLevel::Debug => Debug,
LogLevel::Trace => Trace,
}
}
}

View file

@ -1,14 +1,23 @@
use alloc::{boxed::Box, vec, vec::Vec};
use shadeable::pixel_format::{new_rgba64, Rgba64};
use vga::{colors::Color16, writers::GraphicsWriter};
use crate::vga_e::VGAE;
use alloc::{boxed::Box, vec, vec::Vec};
use shadeable::{
evaluate_shader,
pixel_format::{new_rgba64, Rgba64},
};
use spin;
use vga::{colors::Color16, writers::GraphicsWriter};
#[derive(Debug)]
pub struct ScreenSize {
pub x: usize,
pub y: usize,
}
lazy_static::lazy_static! {
pub static ref SCREEN_BUFFER: spin::Mutex<ScreenBuffer> = spin::Mutex::new(ScreenBuffer::new(640, 480));
}
impl ScreenSize {
pub fn new(x: usize, y: usize) -> Self {
Self { x, y }
@ -35,6 +44,20 @@ impl ScreenBuffer {
buff: vec![0u64; x * y].into_boxed_slice(),
}
}
pub fn draw_filled_circle(&mut self, cx: i32, cy: i32, radius: usize, color: Rgba64) {
let r = radius as i32 * 2;
for y in 0..640 {
for x in 0..480 {
let dx = cx - x as i32 * 2 - 1;
let dy = cy - y as i32 * 2 - 1;
if dx * dx + dy * dy <= r * r {
self.set_pixel(x, y, color);
};
}
}
}
#[inline]
pub fn set_pixel(&mut self, x: usize, y: usize, color: Rgba64) {
self.buff[y * self.size.x + x] = color;
@ -45,7 +68,67 @@ impl ScreenBuffer {
}
pub fn blit(&mut self, _width: usize, _height: usize) {}
pub fn draw_filled_rect(&mut self, x1: usize, y1: usize, x2: usize, y2: usize, color: Rgba64) {
for y in y1..y2 {
for x in x1..x2 {
self.set_pixel(x, y, color);
}
}
}
pub fn draw_unfilled_rect(
&mut self,
x1: usize,
y1: usize,
x2: usize,
y2: usize,
color: Rgba64,
) {
// x1 y1 => x2 y1 => x2 y2 => x1 y2 => x1 y1
self.draw_line(x1, y1, x2, y1, color);
self.draw_line(x2, y1, x2, y2, color);
self.draw_line(x2, y2, x1, y2, color);
self.draw_line(x1, y2, x1, y1, color);
}
#[inline]
pub fn draw_line(&mut self, x1: usize, y1: usize, x2: usize, y2: usize, color: Rgba64) {
let x = crate::graphics::get_coordinates(
x1.try_into().unwrap(),
y1.try_into().unwrap(),
x2.try_into().unwrap(),
y2.try_into().unwrap(),
);
for coord in x {
self.set_pixel(coord.0, coord.1, color);
}
}
pub fn shade(&mut self) {
for y in 0..100 {
for x in 0..100 {
let rgba_ret = evaluate_shader(x, y, self.buff[y * self.size.x + x]);
match rgba_ret {
Ok(pixel) => {
// info!("{:?}", pixel);
self.set_pixel(x, y, pixel);
}
Err(err) => error!("{}", err),
}
}
}
info!("Shaders done");
}
// TODO force clear
pub fn force_redraw(&mut self) {
use shadeable::pixel_format::into_vga_16;
VGAE.lock().clear_screen(into_vga_16(self.clear_color));
}
}
pub trait VgaBuffer {
fn copy_to_buffer(&self) -> GraphicsReturn;
}
@ -55,12 +138,58 @@ impl VgaBuffer for ScreenBuffer {
for y in 0..self.size.y {
for x in 0..self.size.x {
use shadeable::pixel_format::{get_color16, into_vga_16};
let vga_color = get_color16(self.buff[y * self.size.x + x]);
// let vga_color = into_vga_16(self.buff[y * self.size.x + x]);
mode.set_pixel(x, y, vga_color);
// let vga_color = get_color16(self.buff[y * self.size.x + x]);
let vga_color = into_vga_16(self.buff[y * self.size.x + x]);
if into_vga_16(self.clear_color) != vga_color {
mode.set_pixel(x, y, vga_color);
}
}
}
GraphicsReturn::Ok
}
}
pub fn get_coordinates(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec<(usize, usize)> {
let mut coordinates: Vec<(usize, usize)> = vec![];
let dx: i32 = i32::abs(x2 - x1);
let dy: i32 = i32::abs(y2 - y1);
let sx: i32 = {
if x1 < x2 {
1
} else {
-1
}
};
let sy: i32 = {
if y1 < y2 {
1
} else {
-1
}
};
let mut error: i32 = (if dx > dy { dx } else { -dy }) / 2;
let mut current_x: i32 = x1;
let mut current_y: i32 = y1;
loop {
coordinates.push((current_x as usize, current_y as usize));
// info!("0 {:?}", (current_x, current_y));
if current_x == x2 && current_y == y2 {
break;
}
let error2: i32 = error;
if error2 > -dx {
error -= dy;
current_x += sx;
}
if error2 < dy {
error += dx;
current_y += sy;
}
}
coordinates
}

View file

@ -1,40 +1,32 @@
#![allow(clippy::empty_loop)]
// use std::println;
use alloc::format;
use shadeable::pixel_format::{from_vga_16, into_vga_16, new_rgba64};
use vga::{colors::Color16, writers::GraphicsWriter};
use crate::{
graphics::VgaBuffer,
relib::network::socket::{SimpleSock, SocketReturns},
vga_e::{self, num_to_vga16, VGAE},
};
use log::*;
use {
crate::{
arch::{drivers::graphics::GraphicsBuffer, init, sloop},
driver_traits::graphics::Graphics,
arch::{init, sloop},
boot_conf,
experiments::{
info::master,
systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
},
graphics::ScreenBuffer,
// log::LOG_STATE,
graphics::{VgaBuffer, SCREEN_BUFFER},
relib::math::rand::RAND_HANDLE,
relib::network::socket::Socket,
relib::network::socket::{SimpleSock, SocketReturns},
scheduler::{test_fn, Thread, ThreadList},
vga_e::{self, num_to_vga16},
},
alloc::{
format,
string::{String, ToString},
vec,
},
core::sync::atomic::{AtomicU64, Ordering::*},
lazy_static::lazy_static,
log::*,
picorand::PicoRandGenerate,
rkyv::{ser::serializers::AllocSerializer, Deserialize},
shadeable::pixel_format::from_vga_16,
y_compositor_protocol::Version,
};
#[no_mangle]
@ -48,99 +40,82 @@ pub extern "C" fn stack_overflow() -> u8 {
lazy_static! {
pub static ref KEY_BUFFER: spin::Mutex<String> = spin::Mutex::new("".to_string());
pub static ref THREAD_LIST: spin::Mutex<ThreadList> = spin::Mutex::new(vec![]);
pub static ref TICK: spin::Mutex<u64> = spin::Mutex::new(0);
pub static ref TICK: AtomicU64 = AtomicU64::new(0);
}
#[no_mangle]
pub fn kernel_main() -> ! {
let boot_conf = boot_conf::BootConfig::new();
init::init();
log::set_max_level(boot_conf.log_level());
// info!("Initialized");
log::set_max_level(LevelFilter::Trace);
// crate::wasm::evaluate();
graphics_pipe_startup();
let mut abcde = ScreenBuffer::new(640, 480);
// abcde.clear();
// abcde.copy_to_buffer();
/*
VGAE.lock().clear_screen(Color16::Black);
{
let mut proc_1 = SimpleSock::new();
proc_1.register_protocol("ProcSpawner".to_string());
trace!("length of screen buffer {}", abcde.buff.len());
trace!("Screen size {:?}", abcde.size);
let version = 0;
use rkyv::ser::Serializer;
let mut serializer = AllocSerializer::<0>::default();
serializer.serialize_value(&version).unwrap();
for y in 0..480 {
for x in 0..640 {
let segment_x = x * 4 / 640;
let segment_y = y * 4 / 480;
let segment = segment_x + segment_y * 4;
abcde.set_pixel(x, y, from_vga_16(num_to_vga16(segment as u8)));
}
}
// abcde.copy_to_buffer();
{
let mut xyz = SimpleSock::new();
xyz.peek();
xyz.write(vec![0, 1, 2, 3]);
let x = "simple 🧦".to_string().into_bytes();
xyz.write(x);
info!("{:?}", &xyz.read(4).unwrap());
match &xyz.peek() {
SocketReturns::ReadOk(strr) => {
let out = String::from_utf8_lossy(strr);
info!("{}", out);
let bytes = serializer.into_serializer().into_inner();
proc_1.write(bytes.into_vec());
unsafe {
let the_bytes = proc_1.read(3).unwrap();
let archived = rkyv::archived_root::<Version>(&the_bytes);
let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
// trace!("{:?}", deserialized);
}
SocketReturns::ReadIndexOutOfBounds => todo!(),
SocketReturns::WriteOk => todo!(),
}
*/
let mut graphics = SCREEN_BUFFER.lock();
graphics.force_redraw();
graphics.clear();
graphics.draw_filled_circle(100, 100, 5, 0x9900ff00);
screen_writer_test();
graphics.copy_to_buffer();
if boot_conf.run_tests {
// quick and dirty testing framework
socket_test();
graphics_pipe_test();
socket_startup_rng();
socket_test_rng();
}
let mut sock_print_id = SimpleSock::new();
{
sock_print_id.write(format!("a原b画cフdァeイfル 集").into());
// sock_print_id.write(format!("simple sockets are based").into());
// sock_print_id.write(format!("1....2....3....4....5....6....7....8....9").into());
}
// crate::relib::image::mono_bitmap::bruh();
if true {
let mut prev = None;
for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
vga_e::draw_char(prev, current, 0);
prev = Some(current);
}
if boot_conf.run_demos {
graphics_api_demo();
}
if false {
draw_filled_circle(400, 350, 99, Color16::Black);
// let _ = shadeable::evaluate_shader(1);
if boot_conf.run_shader_tests {
shader_tests();
}
// abcde.clear();
// abcde.copy_to_buffer();
// graphics.copy_to_buffer();
// stack_overflow();
// info!("buffer copied");
sloop()
}
/// called by arch specific timers to tick up all kernel related functions
pub fn tick() {
let mut data = TICK.lock();
*data += 1;
RAND_HANDLE.lock().seed_entropy_timer(*data);
let mut data = TICK.load(Relaxed);
data += 1;
RAND_HANDLE.lock().seed_entropy_timer(data);
// println!("{}", *data);
crate::kernel_state::KERNEL_STATE.lock().update_state();
TICK.store(data, Relaxed)
}
pub fn key_entropy(key: u8) {
@ -155,20 +130,12 @@ pub fn test_threads() {
THREAD_LIST.lock().push(a_thread);
}
fn draw_filled_circle(cx: i32, cy: i32, radius: usize, color: Color16) {
let vga = VGAE.lock();
pub fn cpu_socket_startup() {
let mut cpu_info_socket = SimpleSock::new();
cpu_info_socket.register_protocol("CPU_INFO".to_string());
let r = radius as i32 * 2;
for y in 0..640 {
for x in 0..480 {
let dx = cx - x as i32 * 2 - 1;
let dy = cy - y as i32 * 2 - 1;
if dx * dx + dy * dy <= r * r {
vga.set_pixel(x, y, color);
};
}
}
let x = master().unwrap();
let xyz = x.brand_string().unwrap();
}
pub fn log_version_data() {
@ -178,3 +145,142 @@ pub fn log_version_data() {
master().unwrap().brand_string().unwrap()
);
}
pub fn socket_test() {
let mut xyz = SimpleSock::new();
xyz.peek();
xyz.write(vec![0, 1, 2, 3]);
let x = "simple 🧦".to_string().into_bytes();
xyz.write(x);
info!("{:?}", &xyz.read(4).unwrap());
match &xyz.peek() {
SocketReturns::ReadOk(strr) => {
let out = String::from_utf8_lossy(strr);
info!("{}", out);
}
SocketReturns::ReadIndexOutOfBounds => todo!(),
SocketReturns::WriteOk => todo!(),
}
}
pub fn socket_test_rng() {
let mut test_sock = SimpleSock::grab_socket("RNGProvider".to_string()).unwrap();
info!(
"Recieving {} from protocol {}",
test_sock.read(1).unwrap()[0],
test_sock.protocol().unwrap()
);
}
pub fn socket_startup_rng() {
use picorand::{WyRand, RNG};
let mut random_socket = SimpleSock::new();
random_socket.register_protocol("RNGProvider".to_string());
let bruh = TICK.load(core::sync::atomic::Ordering::Relaxed);
let mut rng = RNG::<WyRand, u8>::new(bruh);
for _ in 0..512 {
let x = rng.generate();
random_socket.write(vec![x]);
}
}
pub fn screen_writer_test() {
let mut sock_print_id = SimpleSock::new();
sock_print_id.register_protocol("Screen Printer".to_string());
// sock_print_id.write(format!("a原 b画 cフ dァ eイ fル 集").into());
sock_print_id.write(format!("λ³ Half Life 3 booting up ㎣").into());
// sock_print_id.write(format!("Happy birthday 🎉").into());
// sock_print_id.write(format!("1....2....3....4....5....6....7....8....9").into());
let mut prev = None;
// let mut graphics = SCREEN_BUFFER.lock();
// graphics.clear();
// graphics.copy_to_buffer();
for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
vga_e::draw_char(prev, current, 0);
prev = Some(current);
}
}
pub fn vga_boot_screen() {
let mut abcde = SCREEN_BUFFER.lock();
for y in 0..480 {
for x in 0..640 {
let segment_x = x * 4 / 640;
let segment_y = y * 4 / 480;
let segment = segment_x + segment_y * 4;
abcde.set_pixel(x, y, from_vga_16(num_to_vga16(segment as u8)));
}
}
}
pub fn graphics_pipe_test() {
let mut graphics_pipe = SimpleSock::grab_socket("YCompositor".to_string()).unwrap();
let version = Version {
major: 13,
minor: 123,
patch: 0,
};
use rkyv::ser::Serializer;
let mut serializer = AllocSerializer::<0>::default();
serializer.serialize_value(&version).unwrap();
// let bytes = serializer.into_serializer().into_inner();
// info!("{:?}", bytes);
let bytes = serializer.into_serializer().into_inner();
graphics_pipe.write(bytes.into_vec());
unsafe {
let the_bytes = graphics_pipe.read(3).unwrap();
let archived = rkyv::archived_root::<Version>(&the_bytes);
let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
trace!("{:?}", deserialized);
}
}
pub fn graphics_pipe_startup() {
let mut graphics_pipe = SimpleSock::new();
graphics_pipe.register_protocol("YCompositor".to_string());
}
pub fn graphics_api_demo() {
let mut abcde = SCREEN_BUFFER.lock();
abcde.force_redraw();
abcde.draw_filled_circle(100, 100, 300, 0x0000ff00);
abcde.draw_unfilled_rect(100, 100, 400, 200, 0xff000000);
abcde.draw_filled_rect(300, 300, 400, 400, 0xff000000);
abcde.draw_line(100, 100, 400, 200, 0xff000000);
abcde.copy_to_buffer();
}
pub fn shader_tests() {
let mut graphics = SCREEN_BUFFER.lock();
graphics.clear();
graphics.force_redraw();
graphics.draw_filled_rect(25, 25, 50, 50, 0xff000000);
graphics.set_pixel(50, 50, 0xffffff00);
graphics.shade();
graphics.copy_to_buffer();
// drop(graphics)
}

View file

@ -33,6 +33,7 @@ pub mod print;
pub extern crate log;
pub mod allocator;
pub mod boot_conf;
pub mod driver_traits;
pub mod experiments;
pub mod graphics;
@ -40,10 +41,9 @@ pub mod keyboard;
pub mod kmain;
pub mod logger;
pub mod panic;
pub mod proc;
pub mod relib;
pub mod scheduler;
pub mod wasm;
mod unicode_utils;
pub mod utils;

View file

@ -21,13 +21,14 @@ impl log::Log for SimpleLogger {
log::Level::Debug => color = (Fg::Blue, "$BLUE$"),
log::Level::Trace => color = (Fg::Yellow, "$YELLOW$"),
}
/*
println!(
"[{}{}$RESET$][$GREEN$FakeTempTime$RESET$] {}",
color.1,
record.level(),
record.args()
);
*/
serial_println!(
"[{}{}{}][{}FakeTempTime{}] {}",
color.0,

5
ableos/src/proc.rs Normal file
View file

@ -0,0 +1,5 @@
use crate::relib::clparse::Command;
pub struct ProccessStart {
command: Command,
}

View file

@ -0,0 +1,6 @@
use alloc::{boxed::Box, vec::Vec};
use core::result;
pub struct BinCodeWriter {
pub stream: Box<u8>,
}

View file

@ -1 +1,2 @@
pub mod bin;
pub mod rle;

File diff suppressed because one or more lines are too long

View file

@ -1,11 +1,25 @@
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
pub type Stream = Vec<u8>;
#[derive(Debug)]
pub struct SocketID {
pub id: usize,
}
impl SocketID {
pub fn protocol(self) -> Option<String> {
let x = SOCKETS.lock()[self.id].protocol.clone();
match x {
Some(protocol_name) => Some(protocol_name),
None => None,
}
}
}
impl Socket for SocketID {
fn peek(&mut self) -> SocketReturns {
SOCKETS.lock()[self.id].peek()
@ -18,6 +32,13 @@ impl Socket for SocketID {
fn write(&mut self, stream: Stream) -> SocketReturns {
SOCKETS.lock()[self.id].write(stream)
}
fn register_protocol(&mut self, protocol_name: String) {
SOCKETS.lock()[self.id].protocol = Some(protocol_name);
}
fn check_protocol(&mut self, protocol_name: String) -> bool {
SOCKETS.lock()[self.id].check_protocol(protocol_name)
}
}
pub type SocketState = Vec<SimpleSock>;
@ -25,7 +46,6 @@ pub type SocketState = Vec<SimpleSock>;
lazy_static::lazy_static! {
pub static ref SOCKETS: spin::Mutex<SocketState> = spin::Mutex::new(vec![]);
}
pub trait Socket {
fn peek(&mut self) -> SocketReturns;
@ -33,6 +53,9 @@ pub trait Socket {
fn read(&mut self, length: usize) -> SocketReturns;
fn write(&mut self, stream: Stream) -> SocketReturns;
fn register_protocol(&mut self, protocol_name: String);
fn check_protocol(&mut self, protocol_name: String) -> bool;
fn close(&mut self) {}
}
#[derive(Debug)]
@ -54,11 +77,15 @@ impl SocketReturns {
pub struct SimpleSock {
stream: Vec<u8>,
protocol: Option<String>,
}
impl SimpleSock {
pub fn new() -> SocketID {
let sock = SimpleSock { stream: vec![] };
let sock = SimpleSock {
stream: vec![],
protocol: None,
};
let mut sock_lock = SOCKETS.lock();
sock_lock.push(sock);
@ -69,6 +96,23 @@ impl SimpleSock {
pub fn regrab_sock(id: usize) -> SocketID {
SocketID { id }
}
pub fn grab_socket(protocol_name: String) -> Option<SocketID> {
let socket_handle = SOCKETS.lock();
let socket_count = socket_handle.len();
drop(socket_handle);
let return_sock = None;
for socket_id in 0..socket_count {
let mut id = SimpleSock::regrab_sock(socket_id);
if id.check_protocol(protocol_name.clone()) {
return Some(id);
}
}
return_sock
}
}
impl Socket for SimpleSock {
@ -92,6 +136,16 @@ impl Socket for SimpleSock {
SocketReturns::ReadOk(return_vec)
}
}
fn register_protocol(&mut self, protocol_name: String) {
self.protocol = Some(protocol_name);
}
fn check_protocol(&mut self, protocol_name: String) -> bool {
if self.protocol == Some(protocol_name) {
return true;
}
false
}
fn write(&mut self, stream: Stream) -> SocketReturns {
for byte in stream {
self.stream.push(byte);

View file

@ -1,6 +1,3 @@
use alloc::string::ToString;
use unicode_width::UnicodeWidthStr;
use {
ab_glyph::{Font, FontRef, Glyph},
vga::{
@ -19,10 +16,6 @@ lazy_static::lazy_static! {
pub static ref VGAE_BUFF_OFFSET_Y: spin::Mutex<u8> = spin::Mutex::new(0);
}
pub trait GraphicsAPI {
fn add_shader() {}
}
pub fn draw_char(previous_character: Option<char>, character: char, _offset: usize) {
let mode = *VGAE.lock();
let mut offset_x = VGAE_BUFF_OFFSET_X.lock();
@ -82,7 +75,7 @@ pub fn draw_char(previous_character: Option<char>, character: char, _offset: usi
{
// figure it our latter bruh
let spacing = used_font.kern_unscaled(previous_glyph.id, q_glyph.id);
info!("{spacing} {:?} {:?}", previous_glyph.id, q_glyph.id);
// info!("{spacing} {:?} {:?}", previous_glyph.id, q_glyph.id);
q_glyph.position.x += spacing * font_scale;
}

Binary file not shown.

Binary file not shown.

View file

@ -1,117 +0,0 @@
use alloc::string::String;
use {
alloc::format,
wasm_sys::SysCall,
wasmi::{
Error, Externals, FuncInstance, FuncRef, ImportsBuilder, ModuleImportResolver,
ModuleInstance, RuntimeArgs, RuntimeValue, Signature, Trap, TrapKind, ValueType,
},
};
mod wasm_sys;
struct HostFunctions;
impl HostFunctions {
fn check_signature(&self, index: usize, signature: &Signature) -> bool {
let (params, ret_ty): (&[ValueType], Option<ValueType>) = match index.into() {
SysCall::KILL => (&[], None),
SysCall::EMPTY => (&[], None),
_ => return false,
};
signature.params() == params && signature.return_type() == ret_ty
}
}
impl Externals for HostFunctions {
fn invoke_index(
&mut self,
index: usize,
args: RuntimeArgs,
) -> Result<Option<RuntimeValue>, Trap> {
match index.into() {
// Take in one arg discard the rest
SysCall::KILL => {
info!("Program run at runtime called a system call");
debug!("Runtime arguments: {:?}", args);
Ok(None)
}
// Do nothing
SysCall::EMPTY => Ok(None),
SysCall::EXIT => Ok(None),
SysCall::CONSOLE_RESET => Ok(None),
SysCall::CONSOLE_IN => {
info!("In");
Ok(None)
}
SysCall::CONSOLE_OUT => {
// Eventually change this to 2- ptr and len
if args.len() != 1 {
return Err(Trap::new(TrapKind::UnexpectedSignature));
}
let arg: u64 = args.nth(0);
let buf = unsafe { String::from_utf8_unchecked(arg.to_le_bytes().to_vec()) };
println!["{}", buf];
Ok(None)
}
SysCall::CONSOLE_GET_TITLE => Ok(None),
SysCall::CONSOLE_SET_TITLE => Ok(None),
_ => panic!("Unimplemented function at {}", index),
}
}
}
impl ModuleImportResolver for HostFunctions {
fn resolve_func(&self, field_name: &str, signature: &Signature) -> Result<FuncRef, Error> {
let index = match field_name {
"kill" => SysCall::KILL as usize,
"empty" => SysCall::EMPTY as usize,
"exit" => SysCall::EXIT as usize,
"console_out" => SysCall::CONSOLE_OUT as usize,
_ => {
return Err(Error::Instantiation(format!(
"Export {} not found",
field_name
)))
}
};
if !self.check_signature(index, signature) {
return Err(Error::Instantiation(format!(
"Export {} has a bad signature",
field_name
)));
}
Ok(FuncInstance::alloc_host(
Signature::new(&[][..], None),
index,
))
}
}
pub fn evaluate() {
// let wasm_binary = include_bytes!("bin/console_out_test.wasm");
let wasm_binary = include_bytes!("bin/rust.wasm");
// Load wasm binary and prepare it for instantiation.
let module = wasmi::Module::from_buffer(&wasm_binary).expect("failed to load wasm");
let imports = ImportsBuilder::new().with_resolver("env", &HostFunctions);
// Instantiate a module with empty imports and
// assert that there is no `start` function.
let instance = ModuleInstance::new(&module, &imports)
// .expect("failed to instantiate wasm module")
.unwrap()
.assert_no_start();
// Finally, invoke the exported function "test" with no parameters
// and empty external function executor.
let result: i32 = instance
.invoke_export("_start", &[], &mut HostFunctions)
.expect("failed to execute export")
.unwrap()
.try_into()
.unwrap();
println!("{:?}", result);
}

View file

@ -1,94 +0,0 @@
#![allow(non_camel_case_types)]
macro_rules! syscall_enum {
() => {};
(@get_last $Variant:ident) => {
Self::$Variant
};
(@get_last $Variant:ident, $($VariantTail:ident),*) => {
syscall_enum![@get_last $($VariantTail),*]
};
($($Variant:ident=$Value:expr,)*) => {
#[allow(clippy::upper_case_acronyms)]
#[repr(usize)]
pub enum SysCall {
$($Variant = $Value),*
}
impl core::convert::From<usize> for SysCall {
fn from(n: usize) -> Self {
match n {
$($Value => Self::$Variant),*,
_ => syscall_enum![@get_last $($Variant),*]
}
}
}
};
($($Variant:ident=$Value:expr),* ) => {
syscall_enum!($($Variant=$Value,)* );
};
}
syscall_enum! {
KILL=0, // Provide a PID
CONSOLE_RESET=1, // Reset the console
CONSOLE_IN=2, // Console Input
CONSOLE_OUT=3, // Console output
CONSOLE_GET_TITLE=4, // Get the console title
CONSOLE_SET_TITLE=5, // Set the console title
CONSOLE_GET_BAR=6,
CONSOLE_SET_BAR=7,
//
GET_HOSTNAME=10,
SET_HOSTNAME=11,
NEW_THREAD=12,
NEW_TASK=13,
KILL_THREAD=14,
KILL_TASK=15,
GET_THREAD=16,
GET_TASK=17,
SEND= 18,
RECEIVE = 19,
RESPOND = 20,
//File Related syscalls
//
MAKE_DIRECTORY=22, //
DELETE_DIRECTORY=23, //
RENAME_DIRECTORY=24, //
SET_DIRECTORY_ACCESS=25, //
//
MAKE_FILE=26, //
DELETE_FILE=27, //
RENAME_FILE=28, //
SET_FILE_ACCESS=29, //
FILE_READ=30,
FILE_WRITE=31,
SLEEP=32, // Sleep in milliseconds
SLEEP_UNTIL=33, // Sleep until this time in milliseconds (if this is below the current time return)
NANOSLEEP=34, // Sleep in nanoseconds
NANOSLEEP_UNTIL=35, // Sleep until this time nanoseconds (if this is below the current time return)
GET_TIME=36, // Gets the system time (some derivitive of seconds)
SET_TIME=37, // Sets the system time (some derivitive of seconds)
// Socket SysCall
SOCKET_BIND=39, // Used by servers to lock a port
SOCKET_CONNECT=40,
SOCKET_DISCONNECT=41,
SOCKET_SEND=42,
SOCKET_RECEIVE=43,
GET_PID=44, // Get the proccess ID
PROCESS_INFO=45, // Get information about the process
//scheduler Related Syscals
GET_PRIORITY=46, // Get scheduler priority
SET_PRIORITY=47, // Set scheduler priority
EXIT=50,
EMPTY=0xFFFF,
}

10
shadeable/Cargo.lock generated
View file

@ -143,6 +143,15 @@ dependencies = [
"scopeguard",
]
[[package]]
name = "log"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
dependencies = [
"cfg-if",
]
[[package]]
name = "no-std-compat"
version = "0.4.1"
@ -228,6 +237,7 @@ name = "shadeable"
version = "0.1.0"
dependencies = [
"libm",
"log",
"rhai",
"vga",
]

View file

@ -9,6 +9,7 @@ edition = "2021"
vga = "*"
libm = "*"
log ="*"
[dependencies.rhai]
version = "*"

View file

@ -2,10 +2,17 @@ const VERSION = 0.5;
fn main(){
let abcd = RGBA(0, 33, 0, 0);
let abcd = RGBA(255, 255, 0, 0);
//print("hi");
// print(rand_float());
//debug("hi part 2");
PIXEL_RGBA;
if PIXEL_X == 30 {
PIXEL_RGBA;
}
else if PIXEL_X == 10 {
RGBA(0, 0, 0, 0);
} else {
abcd;
}
}

View file

@ -1,18 +1,58 @@
use crate::pixel_format::{rgba_add, rgba_div, rgba_mult, rgba_sub, RGBA};
use crate::pixel_format::{get_a, get_b, get_g, get_r, set_a, set_b, set_g, set_r};
use crate::pixel_format::{new_rgba64, rgba_div, Rgba64};
use log::{debug, info};
use rhai::Engine;
pub fn engine_startup() -> Engine {
let mut engine = Engine::new();
// engine.on_print(|x| info!("PRINTED FROM SHADER: {}", x));
// Any function or closure that takes a '&str', an 'Option<&str>' and a 'Position' argument
// can be used to override 'debug'.
engine.on_debug(|x, src, pos| {
let src = src.unwrap_or("unknown");
// debug!("SHADER DEBUG of {} at {:?}: {}", src, pos, x)
});
engine
.register_type::<RGBA>()
.register_fn("RGBA", RGBA::new)
.register_fn("*", rgba_mult)
.register_type::<Rgba64>()
.register_fn("RGBA", get_rgba_rhai)
.register_fn("RGBA", get_rgba_from_int)
.register_fn("RGBA", get_rgba_from_int)
.register_fn("/", rgba_div)
.register_fn("+", rgba_add)
.register_fn("-", rgba_sub);
// .register_fn("*", rgba_mult)
// .register_fn("+", rgba_add)
// .register_fn("-", rgba_sub)
;
// engine.register_global_module(RandomPackage::new().as_shared_module());
engine
}
use rhai::INT;
pub fn get_rgba_rhai(r: INT, g: INT, b: INT, a: INT) -> Rgba64 {
let mut pixel = 0;
pixel |= set_r(pixel, r as u8);
pixel |= set_g(pixel, g as u8);
pixel |= set_b(pixel, b as u8);
pixel |= set_a(pixel, a as u8);
pixel
}
pub fn get_rgba_from_int(pixel: INT) -> Rgba64 {
let mut pixel = pixel as u64;
let r = get_r(pixel.try_into().unwrap());
let g = get_g(pixel.try_into().unwrap());
let b = get_b(pixel.try_into().unwrap());
let a = get_a(pixel.try_into().unwrap());
pixel |= set_r(pixel, r as u8);
pixel |= set_g(pixel, g as u8);
pixel |= set_b(pixel, b as u8);
pixel |= set_a(pixel, a as u8);
pixel
}

View file

@ -1,8 +1,8 @@
#![no_std]
extern crate alloc;
use alloc::{boxed::Box, vec, vec::Vec};
use alloc::boxed::Box;
use engine_internals::engine_startup;
use pixel_format::{Rgba64, RGBA};
use pixel_format::Rgba64;
// use core::fmt::Result;
use core::result::Result;
use rhai::{EvalAltResult, Scope};
@ -12,70 +12,17 @@ pub mod pixel_format;
pub const SHADER: &str = include_str!("../shaders/simple.shade");
pub fn rhai_test() -> Result<Vec<RGBA>, Box<EvalAltResult>>
// ^^^^^^^^^^^^^^^^^^
// Rhai API error type
{
// Create an 'Engine'
let engine = engine_startup();
let ast = engine.compile(SHADER)?;
let mut scope = Scope::new();
let a = vec![
RGBA {
r: 255,
g: 0,
b: 0,
a: 0,
},
RGBA {
r: 0,
g: 255,
b: 0,
a: 0,
},
RGBA {
r: 0,
g: 0,
b: 255,
a: 0,
},
RGBA {
r: 0,
g: 0,
b: 0,
a: 255,
},
];
let mut result_rgba = vec![];
for pixel in a {
/*
scope.push("PIXEL_X", 0);
scope.push("PIXEL_Y", index);
*/
scope.push("PIXEL_RGBA", pixel);
let result: RGBA = engine.call_fn(&mut scope, &ast, "main", ())?;
result_rgba.push(result);
}
// Done!
Ok(result_rgba)
}
pub fn evaluate_shader(pixel: u8) -> Result<Rgba64, Box<EvalAltResult>> {
pub fn evaluate_shader(x: usize, y: usize, pixel: Rgba64) -> Result<Rgba64, Box<EvalAltResult>> {
let engine = engine_startup();
let ast = engine.compile(SHADER)?;
let mut scope = Scope::new();
scope.push("PIXEL_RGBA", pixel);
scope.push("PIXEL_X", x);
scope.push("PIXEL_Y", y);
let result: RGBA = engine.call_fn(&mut scope, &ast, "main", ())?;
let result: Rgba64 = engine.call_fn(&mut scope, &ast, "main", ())?;
Ok(8)
Ok(result)
}

View file

@ -1,5 +1,5 @@
#![feature(exclusive_range_pattern)]
use log::*;
use rhai::INT;
use vga::colors::Color16;
pub type Rgba64 = u64;
@ -57,27 +57,14 @@ pub fn set_a(rgba: Rgba64, a: u8) -> Rgba64 {
return z | y;
}
#[derive(Debug, Clone)]
pub struct RGBA {
pub r: INT,
pub g: INT,
pub b: INT,
pub a: INT,
}
impl RGBA {
pub fn new(r: INT, g: INT, b: INT, a: INT) -> Self {
Self { r, g, b, a }
}
}
pub fn rgba_div(a: Rgba64, b: Rgba64) -> Rgba64 {
let mut fin: Rgba64 = 0;
// println!("{}", fin);
fin = set_r(fin, get_r(a) / get_r(b));
fin |= set_r(fin, get_r(a) / get_r(b));
// println!("{}", fin);
fin = set_g(fin, get_g(a) / get_g(b));
fin |= set_g(fin, get_g(a) / get_g(b));
/*
get_b(a) / get_b(b);
@ -87,31 +74,6 @@ pub fn rgba_div(a: Rgba64, b: Rgba64) -> Rgba64 {
return fin;
}
pub fn rgba_mult(a: RGBA, b: RGBA) -> RGBA {
RGBA {
r: a.r * b.r,
g: a.g * b.g,
b: a.b * b.b,
a: a.a * b.a,
}
}
pub fn rgba_add(a: RGBA, b: RGBA) -> RGBA {
RGBA {
r: a.r + b.r,
g: a.g + b.g,
b: a.b + b.b,
a: a.a + b.a,
}
}
pub fn rgba_sub(a: RGBA, b: RGBA) -> RGBA {
RGBA {
r: a.r - b.r,
g: a.g - b.g,
b: a.b - b.b,
a: a.a - b.a,
}
}
//
pub fn new_rgba64(r: u8, g: u8, b: u8, a: u8) -> Rgba64 {
let mut x = 0;
@ -141,6 +103,9 @@ pub fn into_vga_16(rgba_64: Rgba64) -> Color16 {
171..=255 => 0b1001,
_ => 0,
};
// trace!("{}", fourbit);
use Color16::*;
match fourbit {
0 => Black,