Switch to workspace

16 files changed, 651 insertions, 0 deletions

diff --git a/crates/renderer/Cargo.toml b/crates/renderer/Cargo.toml
new file mode 100644
index 0000000..50e16ad
--- /dev/null
+++ b/crates/renderer/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "renderer"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[[bin]]
+name = "newton_renderer"
+path = "src/main.rs"
+
+[dependencies]
+# teleia = { path = "../teleia" } # engine
+teleia = { git = "https://github.com/lcolonq/teleia" } # engine
+throwshade = { path = "../throwshade" }
+glam = "*" # linear algebra
+glow = "*" # gl bindings
+bitflags = "*" # C-style bitwise flags
+rand = "=0.8.5" # rng
+log = "*" # logging
+env_logger = "*" # native logging
+lazy_static = "*" # global constants
+strum = {version = "*", features = ["derive"]} # utility macros for enums
+lexpr = "*" # s-expression parsing
+tokio = { version = "*", features = ["full"] } # async runtime
+clap = { version = "*", features = ["cargo"] } # cli arg parsing
+base64 = "0.22.1" # base64 encoding/decoding
+polling = "*" # polling sockets 
+termion = "*" # terminal escapes
\ No newline at end of file
diff --git a/crates/renderer/src/assets.rs b/crates/renderer/src/assets.rs
new file mode 100644
index 0000000..9a0cefc
--- /dev/null
+++ b/crates/renderer/src/assets.rs
@@ -0,0 +1,27 @@
+use teleia::*;
+
+pub struct Assets {
+    pub font: font::Bitmap,
+    pub shader_flat: shader::Shader,
+    pub shader_scene: shader::Shader,
+    pub mesh_square: mesh::Mesh,
+}
+
+impl Assets {
+    pub fn new(ctx: &context::Context) -> Self {
+        Self {
+            font: font::Bitmap::new(ctx),
+            shader_flat: shader::Shader::new(
+                ctx,
+                include_str!("assets/shaders/flat/vert.glsl"),
+                include_str!("assets/shaders/flat/frag.glsl"),
+            ),
+            shader_scene: shader::Shader::new(
+                ctx,
+                include_str!("assets/shaders/scene/vert.glsl"),
+                include_str!("assets/shaders/scene/frag.glsl")
+            ),
+            mesh_square: mesh::Mesh::from_obj(ctx, include_bytes!("assets/meshes/square.obj")),
+        }
+    }
+}
diff --git a/crates/renderer/src/assets/audio/test.wav b/crates/renderer/src/assets/audio/test.wav
new file mode 100644
index 0000000..0eabe85
--- /dev/null
+++ b/crates/renderer/src/assets/audio/test.wav
diff --git a/crates/renderer/src/assets/fonts/iosevka-comfy-regular.ttf b/crates/renderer/src/assets/fonts/iosevka-comfy-regular.ttf
new file mode 100644
index 0000000..b474adc
--- /dev/null
+++ b/crates/renderer/src/assets/fonts/iosevka-comfy-regular.ttf
diff --git a/crates/renderer/src/assets/fonts/terminus.png b/crates/renderer/src/assets/fonts/terminus.png
new file mode 100644
index 0000000..287810b
--- /dev/null
+++ b/crates/renderer/src/assets/fonts/terminus.png
diff --git a/crates/renderer/src/assets/fonts/terminus.ttf b/crates/renderer/src/assets/fonts/terminus.ttf
new file mode 100644
index 0000000..d125e63
--- /dev/null
+++ b/crates/renderer/src/assets/fonts/terminus.ttf
diff --git a/crates/renderer/src/assets/meshes/square.obj b/crates/renderer/src/assets/meshes/square.obj
new file mode 100644
index 0000000..7328a6c
--- /dev/null
+++ b/crates/renderer/src/assets/meshes/square.obj
@@ -0,0 +1,15 @@
+# Blender 3.6.2
+# www.blender.org
+o Cube
+v -1.000000 -1.000000 0.000000
+v 1.000000 -1.000000 0.000000
+v -1.000000 1.000000 0.000000
+v 1.000000 1.000000 0.000000
+vn -0.0000 -0.0000 -1.0000
+vt 0.0 1.0
+vt 1.0 0.0
+vt 0.0 0.0
+vt 1.0 1.0
+s 0
+f 3/1/1 2/2/1 1/3/1
+f 3/1/1 4/4/1 2/2/1
diff --git a/crates/renderer/src/assets/scenes/lcolonq.vrm b/crates/renderer/src/assets/scenes/lcolonq.vrm
new file mode 100644
index 0000000..49fa4a4
--- /dev/null
+++ b/crates/renderer/src/assets/scenes/lcolonq.vrm
diff --git a/crates/renderer/src/assets/shaders/flat/frag.glsl b/crates/renderer/src/assets/shaders/flat/frag.glsl
new file mode 100644
index 0000000..7006a2b
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/flat/frag.glsl
@@ -0,0 +1,11 @@
+uniform sampler2D texture_data;
+
+void main()
+{
+    vec2 tcfull = vec2(vertex_texcoord.x, 1.0 - vertex_texcoord.y);
+    vec4 texel = texture(texture_data, tcfull);
+    if (texel.a != 1.0) {
+        discard;
+    }
+    frag_color = texel;
+} 
diff --git a/crates/renderer/src/assets/shaders/flat/vert.glsl b/crates/renderer/src/assets/shaders/flat/vert.glsl
new file mode 100644
index 0000000..e324f7e
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/flat/vert.glsl
@@ -0,0 +1,4 @@
+void main()
+{
+    default_main();
+}
\ No newline at end of file
diff --git a/crates/renderer/src/assets/shaders/scene/frag.glsl b/crates/renderer/src/assets/shaders/scene/frag.glsl
new file mode 100644
index 0000000..81e08b9
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/scene/frag.glsl
@@ -0,0 +1,11 @@
+uniform sampler2D texture_data;
+
+void main()
+{
+    vec4 texel = texture(texture_data, vertex_texcoord);
+    if (texel.a != 1.0) {
+        discard;
+    }
+
+    frag_color = vec4(texel.rgb, texel.a);
+} 
diff --git a/crates/renderer/src/assets/shaders/scene/vert.glsl b/crates/renderer/src/assets/shaders/scene/vert.glsl
new file mode 100644
index 0000000..64f400c
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/scene/vert.glsl
@@ -0,0 +1,18 @@
+in vec4 joint;
+in vec4 weight;
+
+uniform mat4 joint_matrices[128];
+
+void main()
+{
+    vertex_texcoord = texcoord;
+    vertex_normal = (normal_matrix * vec4(normal, 1.0)).xyz;
+    mat4 skin
+        = weight.x * joint_matrices[int(joint.x)]
+        + weight.y * joint_matrices[int(joint.y)]
+        + weight.z * joint_matrices[int(joint.z)]
+        + weight.w * joint_matrices[int(joint.w)];
+    vec3 pos = (position * skin * vec4(vertex, 1.0)).xyz;
+    vertex_view_vector = camera_pos - pos;
+    gl_Position = projection * view * vec4(pos, 1.0);
+}
diff --git a/crates/renderer/src/assets/textures/test.png b/crates/renderer/src/assets/textures/test.png
new file mode 100644
index 0000000..1f1edca
--- /dev/null
+++ b/crates/renderer/src/assets/textures/test.png
diff --git a/crates/renderer/src/fig.rs b/crates/renderer/src/fig.rs
new file mode 100644
index 0000000..b60f8e9
--- /dev/null
+++ b/crates/renderer/src/fig.rs
@@ -0,0 +1,40 @@
+use std::io::{BufRead, Write};
+
+#[derive(Debug, Clone)]
+pub struct Message {
+    pub event: lexpr::Value,
+    pub data: lexpr::Value,
+}
+
+pub struct Client {
+    reader: std::io::BufReader<std::net::TcpStream>,
+}
+impl Client {
+    pub fn new(addr: &str, subs: &[lexpr::Value]) -> Self {
+        let mut socket = std::net::TcpStream::connect(addr).expect("failed to connect to message bus");
+        socket.set_nonblocking(true).expect("failed to set message bus socket nonblocking");
+        for s in subs {
+            write!(socket, "(sub {})\n", s).expect("failed to send subscribe message to bus");
+        }
+        let reader = std::io::BufReader::new(socket);
+        Self { reader, }
+    }
+    pub fn pump(&mut self) -> Option<Message> {
+        let mut buf = String::new();
+        match self.reader.read_line(&mut buf) {
+            Ok(l) => match lexpr::from_str(&buf) {
+                Ok(v) => {
+                    match v.as_cons() {
+                        Some(cs) => {
+                            Some(Message { event: cs.car().clone(), data: cs.cdr().clone() })
+                        },
+                        _ => { log::error!("malformed message bus input s-expression: {}", v); None },
+                    }
+                },
+                Err(e) => { log::error!("malformed message bus input line: {}", e); None },
+            },
+            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => None,
+            Err(e) => panic!("IO error on message bus: {}", e),
+        }
+    }
+}
diff --git a/crates/renderer/src/main.rs b/crates/renderer/src/main.rs
new file mode 100644
index 0000000..09ed5cf
--- /dev/null
+++ b/crates/renderer/src/main.rs
@@ -0,0 +1,262 @@
+#![allow(dead_code, unused_variables)]
+mod assets;
+mod terminal;
+mod fig;
+
+use teleia::*;
+use termion::raw::IntoRawMode;
+use clap::{command, Command};
+
+use std::{collections::HashMap, f32::consts::PI};
+use lexpr::sexp;
+use base64::prelude::*;
+
+pub enum RenderMode {
+    Overlay,
+    Terminal(termion::raw::RawTerminal<std::io::Stdout>),
+}
+
+pub struct Overlay {
+    mode: RenderMode,
+    assets: assets::Assets,
+    model: scene::Scene,
+    model_neck_base: glam::Mat4,
+    model_fb: framebuffer::Framebuffer,
+    terminal: terminal::Terminal,
+    fig: fig::Client,
+    tracking_eyes: (f32, f32),
+    tracking_mouth: f32,
+    tracking_neck: glam::Quat,
+    throwshade: throwshade::ThrowShade,
+    chat_msg: String,
+    chat_time: f64,
+    chat_biblicality: f32,
+}
+
+impl Overlay {
+    pub async fn new(ctx: &context::Context, mode: RenderMode) -> Self {
+        let model = scene::Scene::from_gltf(ctx, include_bytes!("assets/scenes/lcolonq.vrm")); 
+        let model_neck_base = model.nodes_by_name.get("J_Bip_C_Neck")
+            .and_then(|i| model.nodes.get(*i))
+            .expect("failed to find neck joint")
+            .transform;
+        Self {
+            mode,
+            assets: assets::Assets::new(ctx),
+            model,
+            model_neck_base,
+            model_fb: framebuffer::Framebuffer::new(
+                ctx,
+                &glam::Vec2::new(terminal::WIDTH as _, terminal::HEIGHT as _),
+                &glam::Vec2::ZERO
+            ),
+            terminal: terminal::Terminal::new(ctx),
+            fig: fig::Client::new("shiro:32050", &[
+                sexp!((avatar toggle)),
+                sexp!((avatar text)),
+                sexp!((avatar frame)),
+                sexp!((avatar reset)),
+                sexp!((avatar tracking)),
+                sexp!((avatar overlay shader)),
+                sexp!((avatar overlay chat)),
+            ]),
+            tracking_eyes: (1.0, 1.0),
+            tracking_mouth: 0.0,
+            tracking_neck: glam::Quat::IDENTITY,
+            throwshade: throwshade::ThrowShade::new(),
+            chat_msg: format!(""),
+            chat_time: 0.0,
+            chat_biblicality: 0.0,
+        }
+    }
+    pub async fn overlay(ctx: &context::Context) -> Self {
+        Self::new(ctx, RenderMode::Overlay).await
+    }
+    pub async fn terminal(ctx: &context::Context) -> Self {
+        let raw_stdout = std::io::stdout().into_raw_mode().expect("failed to set raw mode");
+        Self::new(ctx, RenderMode::Terminal(raw_stdout)).await
+    }
+    pub fn handle_reset(&mut self, ctx: &context::Context ) {
+        // TODO also reset terminal
+        if let Some(s) = &mut self.throwshade.shader { s.delete(ctx); }
+        self.throwshade.shader = None;
+    }
+    pub fn handle_tracking(&mut self, msg: fig::Message) -> Option<()> {
+        let eyes = msg.data.get(0)?;
+        let eye_left = eyes.get(0)?.as_str()?.parse::<f32>().ok()?;
+        let eye_right = eyes.get(1)?.as_str()?.parse::<f32>().ok()?;
+        let mouth = msg.data.get(1)?.as_str()?.parse::<f32>().ok()?;
+        let euler = msg.data.get(2)?;
+        let euler_x = euler.get(0)?.as_str()?.parse::<f32>().ok()?.to_radians();
+        let euler_y = PI - euler.get(1)?.as_str()?.parse::<f32>().ok()?.to_radians();
+        let euler_z = euler.get(2)?.as_str()?.parse::<f32>().ok()?.to_radians() + PI/2.0;
+        self.tracking_eyes = (eye_left, eye_right);
+        self.tracking_mouth = mouth;
+        self.tracking_neck = glam::Quat::from_euler(glam::EulerRot::XYZ, euler_x, euler_y, euler_z);
+        Some(())
+    }
+    pub fn handle_text(&mut self, msg: fig::Message) -> Option<()> {
+        let s = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
+        self.terminal.fill_string(std::str::from_utf8(&s).ok()?);
+        Some(())
+    }
+    pub fn handle_frame(&mut self, msg: fig::Message) -> Option<()> {
+        let data = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
+        for (i, c) in data.chunks_exact(3).enumerate() {
+            if let [r, g, b] = c {
+                let ii = i as i32;
+                let p = terminal::Pos::new(ii % 64, ii / 64);
+                self.terminal.base_color.set(
+                    p,
+                    glam::Vec3::new(*r as f32 / 255.0, *g as f32 / 255.0, *b as f32 / 255.0)
+                );
+            }
+        }
+        Some(())
+    }
+    pub fn handle_overlay_shader(
+        &mut self,
+        ctx: &context::Context, st: &state::State,
+        msg: fig::Message
+    ) -> Option<()> {
+        let bs = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
+        let s = String::from_utf8_lossy(&bs);
+        if let Err(e) = self.throwshade.set(ctx, st, &s) {
+            log::warn!("error compiling shader: {}", e);
+            self.throwshade.shader = None;
+        }
+        Some(())
+    }
+    pub fn handle_overlay_chat(&mut self, msg: fig::Message) -> Option<()> {
+        let bs = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
+        let s = String::from_utf8_lossy(&bs);
+        let time = msg.data.get(1)?.as_str()?.parse::<f64>().ok()?;
+        let biblicality = msg.data.get(2)?.as_str()?.parse::<f32>().ok()?;
+        log::info!("received chat message: {} {} {}", s, time, biblicality);
+        self.chat_msg = s.to_string();
+        self.chat_time = time;
+        self.chat_biblicality = biblicality;
+        Some(())
+    }
+    fn render_model_terminal(&mut self, ctx: &context::Context, st: &mut state::State) -> Option<()> {
+        self.model_fb.bind(ctx);
+        ctx.clear_color(glam::Vec4::new(0.0, 0.0, 0.0, 0.0));
+        ctx.clear();
+        st.bind_3d(ctx, &self.assets.shader_scene);
+        self.assets.shader_scene.set_position_3d(
+            ctx,
+            &glam::Mat4::from_translation(
+                glam::Vec3::new(0.0, -1.63, 0.42),
+            ),
+        );
+        self.model.render(ctx, &self.assets.shader_scene);
+        st.render_framebuffer.bind(ctx);
+        self.terminal.update(ctx, &self.model_fb);
+        match &mut self.mode {
+            RenderMode::Overlay => {
+                ctx.clear_color(glam::Vec4::new(0.0, 0.0, 0.0, 0.0));
+                ctx.clear();
+                self.terminal.render(ctx, &glam::Vec2::new(12.0, 250.0));
+            },
+            RenderMode::Terminal(stdout) => if st.tick % 6 == 0 {
+                self.terminal.write_tty(stdout);
+            },
+        }
+        // self.model_fb.blit(
+        //     ctx, &st.render_framebuffer,
+        //     &glam::Vec2::new(ctx.render_width / 2.0 - 512.0, ctx.render_height / 2.0 - 512.0),
+        //     &glam::Vec2::new(128.0, 128.0)
+        // );
+        Some(())
+    }
+}
+
+impl teleia::state::Game for Overlay {
+    fn initialize_audio(&self, ctx: &context::Context, st: &state::State, actx: &audio::Context) -> HashMap<String, audio::Audio> {
+        HashMap::new()
+    }
+    fn finish_title(&mut self, _st: &mut state::State) {}
+    fn mouse_press(&mut self, _ctx: &context::Context, _st: &mut state::State) {}
+    fn mouse_move(&mut self, _ctx: &context::Context, _st: &mut state::State, _x: i32, _y: i32) {}
+    fn update(&mut self, ctx: &context::Context, st: &mut state::State) -> Option<()> {
+        st.projection = glam::Mat4::perspective_lh(
+            PI / 4.0,
+            terminal::WIDTH as f32 / terminal::HEIGHT as f32,
+            0.1, 10.0
+        );
+        st.move_camera(
+            ctx,
+            &glam::Vec3::new(0.0, 0.0, 1.0),
+            &glam::Vec3::new(0.0, 0.0, -1.0),
+            &glam::Vec3::new(0.0, 1.0, 0.0),
+        );
+        while let Some(msg) = self.fig.pump() {
+            let malformed = format!("malformed {} data: {}", msg.event, msg.data);
+            if msg.event == sexp!((avatar tracking)) {
+                if self.handle_tracking(msg).is_none() { log::warn!("{}", malformed) }
+            } else if msg.event == sexp!((avatar reset)) {
+                self.handle_reset(ctx);
+            } else if msg.event == sexp!((avatar text)) {
+                if self.handle_text(msg).is_none() { log::warn!("{}", malformed) }
+            } else if msg.event == sexp!((avatar frame)) {
+                if self.handle_frame(msg).is_none() { log::warn!("{}", malformed) }
+            } else if msg.event == sexp!((avatar overlay shader)) {
+                if self.handle_overlay_shader(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
+            } else if msg.event == sexp!((avatar overlay chat)) {
+                if self.handle_overlay_chat(msg).is_none() { log::warn!("{}", malformed) }
+            } else {
+                log::info!("received unhandled event {} with data: {}", msg.event, msg.data);
+            }
+        }
+        if let Some(n) = self.model.nodes_by_name.get("J_Bip_C_Neck").and_then(|i| self.model.nodes.get_mut(*i)) {
+            n.transform = self.model_neck_base * glam::Mat4::from_quat(self.tracking_neck);
+        }
+        Some(())
+    }
+    fn render(&mut self, ctx: &context::Context, st: &mut state::State) -> Option<()> {
+        if let Some(s) = &self.throwshade.shader {
+            s.bind(ctx);
+            s.set_vec2(ctx, "resolution", &glam::Vec2::new(ctx.render_width, ctx.render_height));
+            let elapsed = (st.tick - self.throwshade.tickset) as f32 / 60.0;
+            s.set_f32(ctx, "time", elapsed);
+            s.set_f32(ctx, "chat_time", (self.chat_time - self.throwshade.timeset) as f32);
+            ctx.render_no_geometry();
+        }
+        self.render_model_terminal(ctx, st);
+        Some(())
+    }
+}
+
+#[tokio::main]
+pub async fn main() {
+    let matches = command!()
+        .propagate_version(true)
+        .subcommand_required(true)
+        .arg_required_else_help(true)
+        .subcommand(
+            Command::new("overlay")
+                .about("Run the LCOLONQ model renderer in a full-screen transparent overlay")
+        )
+        .subcommand(
+            Command::new("terminal")
+                .about("Run the LCOLONQ model renderer in a terminal")
+        )
+        .subcommand(
+            Command::new("server")
+                .about("Run the LCOLONQ online websocket server")
+        )
+        .get_matches();
+    match matches.subcommand() {
+        Some(("overlay", _cm)) => {
+            teleia::run("LCOLONQ", 1920, 1080, teleia::Options::OVERLAY, Overlay::overlay).await;
+        },
+        Some(("terminal", _cm)) => {
+            teleia::run("LCOLONQ", 1920, 1080, teleia::Options::HIDDEN, Overlay::terminal).await;
+        },
+        Some(("server", _cm)) => {
+            env_logger::Builder::new().filter(None, log::LevelFilter::Info).init();
+            log::info!("starting LCOLONQ server...");
+        },
+        _ => unreachable!("no subcommand"),
+    }
+}
diff --git a/crates/renderer/src/terminal.rs b/crates/renderer/src/terminal.rs
new file mode 100644
index 0000000..15f6d45
--- /dev/null
+++ b/crates/renderer/src/terminal.rs
@@ -0,0 +1,235 @@
+use std::{collections::HashMap, io::Write};
+
+use teleia::*;
+
+pub const WIDTH: usize = 64;
+pub const HEIGHT: usize = 64;
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
+pub struct Pos {
+    pub x: i32, pub y: i32,
+}
+impl Pos {
+    pub fn new(x: i32, y: i32) -> Self { Self { x, y } }
+}
+impl std::ops::Add for Pos {
+    type Output = Pos;
+    fn add(self, rhs: Self) -> Self { Self {x: self.x + rhs.x, y: self.y + rhs.y } }
+}
+
+#[derive(Debug, Clone)]
+pub struct CharPair {
+    pub first: char,
+    pub second: Option<char>,
+}
+impl Default for CharPair {
+    fn default() -> Self {
+        Self {
+            first: 'a',
+            second: Some('b'),
+        }
+    }
+}
+
+pub struct Layer<T> {
+    pub data: [T; WIDTH * HEIGHT],
+}
+impl<T> Layer<T> {
+    pub fn new() -> Self where T: Default {
+        Self {
+            data: [(); WIDTH * HEIGHT].map(|_| T::default()),
+        }
+    }
+    pub fn get(&self, p: Pos) -> Option<&T> {
+        if p.x < 0 || p.x >= WIDTH as _ || p.y < 0 || p.y >= HEIGHT as _ { return None }
+        let idx = p.x as usize + p.y as usize * WIDTH;
+        Some(&self.data[idx])
+    }
+    pub fn set(&mut self, p: Pos, x: T) {
+        if p.x < 0 || p.x >= WIDTH as _ || p.y < 0 || p.y >= HEIGHT as _ { return }
+        let idx = p.x as usize + p.y as usize * WIDTH;
+        self.data[idx] = x;
+    }
+}
+impl Layer<CharPair> {
+    pub fn from_str(&mut self, s: &str) {
+        let chars: Vec<char> = s.chars().collect();
+        if chars.is_empty() { return }
+        let mut i: usize = 0;
+        for row in 0..64 {
+            for col in 0..64 {
+                let first = chars[i]; i += 1; i %= chars.len();
+                let second = Some(chars[i]); i += 1; i %= chars.len();
+                self.set(Pos::new(col, row), CharPair { first, second });
+            }
+        }
+    }
+}
+impl Layer<glam::Vec3> {
+    pub fn from_framebuffer(&mut self, ctx: &context::Context, fb: &framebuffer::Framebuffer) {
+        fb.get_pixels(ctx, &mut self.data);
+    }
+    pub fn get_surrounding(&self, pos: Pos, bgcolor: &glam::Vec3) -> u8 {
+        let offs = [
+            Pos::new(-1, -1),
+            Pos::new(0, -1),
+            Pos::new(1, -1),
+            Pos::new(-1, 0),
+            Pos::new(1, 0),
+            Pos::new(-1, 1),
+            Pos::new(0, 1),
+            Pos::new(1, 1),
+        ];
+        let mut ret = 0;
+        for o in offs {
+            ret <<= 1;
+            let v = (self.get(pos + o) != Some(bgcolor)) as u8;
+            ret |= v;
+        }
+        ret
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PaletteType {
+    Hair,
+    Eyes,
+    Skin,
+    Highlight,
+    Eyebags,
+}
+impl PaletteType {
+    pub fn from_string(s: &str) -> Option<Self> {
+        match s {
+            "hair" => Some(Self::Hair),
+            "eyes" => Some(Self::Eyes),
+            "skin" => Some(Self::Skin),
+            "highlight" => Some(Self::Highlight),
+            "eyebags" => Some(Self::Eyebags),
+            _ => None,
+        }
+    }
+    pub fn from_color(c: &glam::Vec3) -> Option<Self> {
+        let r = (c.x * 255.0) as u8;
+        let g = (c.y * 255.0) as u8;
+        let b = (c.z * 255.0) as u8;
+        if r >= 186 && r <= 188 && g >= 176 && g <= 178 && b >= 189 && b <= 191 {
+            Some(Self::Hair)
+        } else if r >= 158 && r <= 162 && g >= 148 && g <= 152 && b >= 159 && b <= 162 {
+            Some(Self::Highlight)
+        } else if g > r && g > b {
+            Some(Self::Eyes)
+        } else if r >= 242 && r <= 246 && g >= 238 && g <= 242 && b >= 234 && b <= 238 {
+            Some(Self::Skin)
+        } else if r == 182 && g == 142 && b == 139 {
+            Some(Self::Eyebags)
+        } else {
+            None
+        }
+    }
+}
+
+pub struct PaletteEntry {
+    pub color: Layer<glam::Vec3>,
+    pub char: Layer<CharPair>,
+}
+
+pub struct Terminal {
+    pub font: font::Bitmap,
+    pub base_color: Layer<glam::Vec3>,
+    pub base_char: Layer<CharPair>,
+    pub palette: HashMap<PaletteType, PaletteEntry>,
+}
+impl Terminal {
+    pub fn new(ctx: &context::Context) -> Self {
+        let mut base_char = Layer::new();
+        base_char.from_str("lcolonq");
+        Self {
+            font: font::Bitmap::from_image(ctx, 6, 12, 96, 72, include_bytes!("assets/fonts/terminus.png")),
+            base_color: Layer::new(),
+            base_char,
+            palette: HashMap::new(),
+        }
+    }
+    pub fn update(&mut self, ctx: &context::Context, fb: &framebuffer::Framebuffer) {
+        self.base_color.from_framebuffer(ctx, fb);
+    }
+    pub fn fill_string(&mut self, s: &str) {
+    }
+    pub fn outline_pattern(&self, pos: Pos) -> Option<String> {
+        let sur = self.base_color.get_surrounding(pos, &glam::Vec3::new(0.0, 0.0, 0.0));
+        let res = match sur {
+            0b01101011 | 0b01101111 => " |",
+            0b11010110 | 0b11010111 => "| ",
+            0b00101011 | 0b00101111 | 0b00101110 | 0b00101100 | 0b00001011 => " /",
+            0b10010110 | 0b10010111 | 0b10010011 | 0b10010001 | 0b00010110 => "\\ ",
+            0b00111111 => "-/", 0b10011111 => "\\-",
+            0b00011111 => "--", 0b00000111 => "__",
+            0b00001111 => " _", 0b00010111 => "_ ",
+            _ => return None,
+        };
+        Some(res.to_owned())
+    }
+    pub fn get(&self, pos: Pos) -> (CharPair, glam::Vec3) {
+        if let Some(c) = self.base_color.get(pos) {
+            // if the pixel is black, show background instead 
+            if *c != glam::Vec3::new(0.0, 0.0, 0.0) {
+                let defaultp = CharPair { first: '#', second: Some('#') };
+                // otherwise, identify the palettetype (hair, eyes, etc.) correspond to
+                // this base color, and retrieve the appropriate data from that palette
+                // entry (if set)
+                if let Some(pty) = PaletteType::from_color(c) {
+                    if let Some(entry) = self.palette.get(&pty) {
+                        return (
+                            entry.char.get(pos).unwrap_or(&defaultp).clone(),
+                            entry.color.get(pos).unwrap_or(c).clone(),
+                        );
+                    }
+                }
+                // if there is no palette entry, return the character from the base
+                // palette (just "lcolonq" by default). if it doesn't exist, use ##
+                return (self.base_char.get(pos).unwrap_or(&defaultp).clone(), *c);
+            }
+        }
+        return (CharPair { first: ' ', second: Some(' ') }, glam::Vec3::new(0.0, 0.0, 0.0));
+    }
+    pub fn render(&self, ctx: &context::Context, pos: &glam::Vec2) {
+        let mut s = String::new();
+        let mut colors = Vec::new();
+        for row in 0..64 {
+            for col in 0..64 {
+                let pos = Pos::new(col, row);
+                let (p, c) = self.get(pos);
+                colors.push(c); colors.push(c);
+                s += &format!("{}{}", p.first, if let Some(snd) = p.second { snd } else { ' ' });
+            }
+            s += "\n";
+            colors.push(glam::Vec3::new(1.0, 1.0, 1.0));
+        }
+        self.font.render_text_helper(ctx, pos, &s, &colors);
+    }
+    pub fn write_tty<W>(&self, out: &mut W)
+    where W: Write {
+        let mut output: Vec<u8> = Vec::new();
+        write!(output, "\x1b[2J\x1b[1;1H").expect("failed to write output");
+        for row in 0..64 {
+            for col in 0..64 {
+                let pos = Pos::new(col, row);
+                let (p, c) = self.get(pos);
+                let new = format!("{}{}", p.first, if let Some(snd) = p.second { snd } else { ' ' });
+                write!(
+                    output, "{}{}",
+                    termion::color::Fg(
+                        termion::color::Rgb(
+                            (c.x * 255.0) as u8,
+                            (c.y * 255.0) as u8,
+                            (c.z * 255.0) as u8),
+                    ),
+                    new
+                ).unwrap();
+            }
+            write!(output, "\r\n").unwrap();
+        }
+        out.write(&output).expect("failed to write to terminal");
+    }
+}