Enum Modifier

pub enum Modifier {
    Coded(u8),
    Colour(Colour),
    None,
}

The Modifier enum is used for adding modifications to text such as colour, bold/italic/underline and others. Modifier should be used through ColChar.

Variants

Coded(u8)

Coded(u8) unwraps to \x1b[{x}m, where x is the code.

For example, Coded(0) (available as Modifier::END) clears all previously applied modifiers. When displayed, Modifier::Coded(31) writes \x1b[31m.

See https://prirai.github.io/blogs/ansi-esc/#colors-graphics-mode for a guide to available code

Colour(Colour)

Colour(Colour) unwraps to \x1b[38;2;{r};{g};{b}m, where (r, g, b) together represent a 24 bit RGB value

Not all terminals support RGB ANSI escape codes, in which case you will have to resort to Modifier::Coded for colours. Some Coded colours are available as constants, e.g. Modifier::RED

None

None unwraps to nothing. It does not change the current applied modifiers.

Implementations

impl Modifier

pub const END: Self

An END code, which clears all previously applied modifiers. You should never have to use this yourself as View makes use of it between pixels where necessary

pub const RED: Self

A red ANSI escape code

pub const GREEN: Self

A green ANSI escape code

pub const YELLOW: Self

A yellow ANSI escape code

pub const BLUE: Self

A blue ANSI escape code

pub const PURPLE: Self

A purple ANSI escape code

pub const CYAN: Self

A cyan ANSI escape code

pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self

Create a Modifier::Colour from an RGB value

Examples found in repository

examples/complex-scene.rs (line 37)

fn main() {
    let mut view = View::new(60, 10, BACKGROUND_CHAR);

    let mut pixel = Pixel::new(Vec2D::new(5, 9), FILL_CHAR);

    let mut line = Line::new(Vec2D::new(2, 8), Vec2D::new(28, 7), FILL_CHAR);
    let mut line1_direction = -1;

    let rect = Rect::new(
        Vec2D { x: 11, y: 1 },
        Vec2D { x: 9, y: 3 },
        ColChar::SOLID.with_rgb(200, 30, 0),
    );

    let test_image = r"
  ______
 /|_||_\`.__
(   _    _ _\
=`-(_)--(_)-'   ";
    let mut sprite = Sprite::new(
        Vec2D::new(30, 1),
        test_image,
        Modifier::from_rgb(20, 200, 0),
    );

    let mut draw_elapsed = Duration::default();
    let mut render_elapsed = Duration::default();
    fps_gameloop!(
        {
            pixel.pos.x += 2;
            // loop the position back to the other side. This can be done with `Wrapping::Wrap` but it won't change the element's actual position, so the pixel position being printed would continue to increase without looping
            pixel.pos %= view.size();

            line.pos1.y += line1_direction;
            line.pos0.y = 10 - line.pos1.y;
            if line.pos1.y > 7 {
                line1_direction = -1;
            } else if line.pos1.y < 3 {
                line1_direction = 1;
            }

            sprite.pos.x += 1;
        },
        {
            view.clear();

            let now = Instant::now();
            view.wrapping_mode = WrappingMode::Panic;
            view.draw(&pixel);
            view.draw(&line);
            view.draw(&rect);
            view.wrapping_mode = WrappingMode::Wrap;
            view.draw(&sprite);
            draw_elapsed = now.elapsed();

            let now = Instant::now();
            let _ = view.display_render();
            render_elapsed = now.elapsed();
        },
        FPS,
        |total_elapsed: Duration, _frame_skip| {
            println!(
                "Drawing: {:.2?} microseconds | Rendering: {:.2?} microseconds| Total: {:.2?}",
                draw_elapsed.as_micros(),
                render_elapsed.as_micros(),
                total_elapsed.as_micros()
            );
            println!("Pixel position: {}", pixel.pos);
        }
    );
}

pub fn from_hsv(h: u8, s: u8, v: u8) -> Self

Create a Modifier::Colour from an HSV value

Trait Implementations

impl Clone for Modifier

fn clone(&self) -> Modifier

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Modifier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Modifier

fn default() -> Modifier

Returns the “default value” for a type.

impl Display for Modifier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Modifier

fn eq(&self, other: &Modifier) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Modifier

impl Eq for Modifier

impl StructuralPartialEq for Modifier