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. It’s essentially a wrapper for \x1b[{x}m, where {x} is a code or rgb value of some sort. Modifier is primarily used by ColChar as one of its properties

Variants

Coded(u8)

Represents a Modifier by an escape code. A Modifier::Coded(31) would return a \x1b[31m.

See https://prirai.github.io/blogs/ansi-esc/#colors-graphics-mode for codes you can use

Colour(Colour)

Represents a Modifier by a Colour, which itself is an RGB value

None

Represents a lack of Modifier, if you don’t want the pixel to be coloured or decorated in any way

Implementations

impl Modifier

pub const END: Self = _

An END code, this 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 Modifier with a red ANSI escape code

pub const GREEN: Self = _

A Modifier with a green ANSI escape code

pub const YELLOW: Self = _

A Modifier with a yellow ANSI escape code

pub const BLUE: Self = _

A Modifier with a blue ANSI escape code

pub const PURPLE: Self = _

A Modifier with a purple ANSI escape code

pub const CYAN: Self = _

A Modifier with 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 36)

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

    let mut pixel = Pixel::new(Vec2D::from((5u8, 9u8)), 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 blit_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.blit(&pixel, Wrapping::Panic);
            view.blit(&line, Wrapping::Panic);
            view.blit(&rect, Wrapping::Panic);
            view.blit(&sprite, Wrapping::Wrap);
            blit_elapsed = now.elapsed();

            let now = Instant::now();
            let _ = view.display_render();
            render_elapsed = now.elapsed();
        },
        FPS,
        |total_elapsed: Duration, _frame_skip| {
            println!(
                "Blitting: {:.2?} microseconds | Rendering: {:.2?} microseconds| Total: {:.2?}",
                blit_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