rocketsplash-rt 0.2.2

Runtime library for loading and rendering Rocketsplash assets (.rst, .rsf)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// <FILE>crates/rocketsplash-rt/src/render/cls_ansi_state.rs</FILE>
// <DESC>Stateful ANSI style/color transition writer</DESC>
// <VERS>VERSION: 1.0.0</VERS>
// <WCTX>Public release refactor audit</WCTX>
// <CLOG>Extract ANSI transition state from fnc_to_ansi</CLOG>

use std::io::{self, Write};

use rocketsplash_formats::Rgb;

use crate::{rgb_to_16_bg, rgb_to_16_fg, rgb_to_256, ColorMode, RenderCell, TextStyle};

const STYLE_CODES: [(TextStyle, u8, u8); 4] = [
    (TextStyle::BOLD, 1, 22),
    (TextStyle::ITALIC, 3, 23),
    (TextStyle::UNDERLINE, 4, 24),
    (TextStyle::REVERSE, 7, 27),
];

#[derive(Clone, Copy, Debug, Default)]
pub(super) struct AnsiState {
    fg: Option<Rgb>,
    bg: Option<Rgb>,
    style: TextStyle,
}

impl AnsiState {
    pub(super) fn is_default(&self) -> bool {
        self.fg.is_none() && self.bg.is_none() && self.style.is_empty()
    }

    pub(super) fn apply<W: Write>(
        &mut self,
        writer: &mut W,
        cell: &RenderCell,
        mode: ColorMode,
    ) -> io::Result<()> {
        let mut first = true;
        macro_rules! write_sep {
            () => {
                if first {
                    writer.write_all(b"\x1b[")?;
                    first = false;
                } else {
                    writer.write_all(b";")?;
                }
            };
        }

        let next_style = cell.style;
        if self.style != next_style {
            for (flag, on_code, off_code) in STYLE_CODES {
                let had = self.style.contains(flag);
                let has = next_style.contains(flag);
                if had && !has {
                    write_sep!();
                    write!(writer, "{}", off_code)?;
                } else if !had && has {
                    write_sep!();
                    write!(writer, "{}", on_code)?;
                }
            }
            self.style = next_style;
        }
        if self.fg != cell.fg {
            write_sep!();
            push_color_code(writer, cell.fg, mode, true)?;
            self.fg = cell.fg;
        }
        if self.bg != cell.bg {
            write_sep!();
            push_color_code(writer, cell.bg, mode, false)?;
            self.bg = cell.bg;
        }
        if !first {
            writer.write_all(b"m")?;
        }
        Ok(())
    }
}

fn push_color_code<W: Write>(
    writer: &mut W,
    color: Option<Rgb>,
    mode: ColorMode,
    is_fg: bool,
) -> io::Result<()> {
    match (color, mode) {
        (None, _) => write!(writer, "{}", if is_fg { "39" } else { "49" }),
        (Some(rgb), ColorMode::TrueColor) => {
            let prefix = if is_fg { "38" } else { "48" };
            write!(writer, "{};2;{};{};{}", prefix, rgb.r, rgb.g, rgb.b)
        }
        (Some(rgb), ColorMode::Color256) => {
            let prefix = if is_fg { "38" } else { "48" };
            write!(writer, "{};5;{}", prefix, rgb_to_256(rgb))
        }
        (Some(rgb), ColorMode::Color16) => {
            let code = if is_fg {
                rgb_to_16_fg(rgb)
            } else {
                rgb_to_16_bg(rgb)
            };
            write!(writer, "{}", code)
        }
        (Some(_), ColorMode::NoColor) => Ok(()),
    }
}

// <FILE>crates/rocketsplash-rt/src/render/cls_ansi_state.rs</FILE>
// <VERS>END OF VERSION: 1.0.0</VERS>