Struct ColChar

Source

pub struct ColChar {
    pub text_char: char,
    pub modifier: Modifier,
}

Expand description

A coloured character. Made up of text_char, a single ascii character used as the “pixel” when drawn to a Canvas, and modifier, which gives that pixel a colour or makes it bold/italic

Fields§

§text_char: char

A single ascii character used as the “pixel” when drawn to a Canvas

§modifier: Modifier

Defines the appearance of the character - colour, bold/italic, etc.

Implementations§

Source §

impl ColChar

Source

pub const SOLID: Self

A solid █ character with no Modifier.

§Example

Using a sequence like this will create a red █ ColChar

ColChar::SOLID.with_rgb(255, 0, 0)

Source

pub const BACKGROUND: Self

A less solid ░ character with no Modifier

Source

pub const EMPTY: Self

A whitespace character with no Modifier

Source

pub const VOID: Self

An opaque whitespace character (\u{2008}) with no Modifier

ASCII Whitespaces are interpreted as transparent by ascii elements. If you want opacity, use this void character

Source

pub const fn new(text_char: char, modifier: Modifier) -> Self

Create a new ColChar with a text character and a Modifier

Source

pub const fn with_char(self, text_char: char) -> Self

Return a ColChar with the same modifier and new text_char

Source

pub const fn with_mod(self, modifier: Modifier) -> Self

Return a ColChar with the same text_char and new modifier

Source

pub const fn with_colour(self, colour: Colour) -> Self

Return a ColChar with the same text_char and new Modifier::Colour modifier

Source

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

Return a ColChar with the same text_char and new Modifier::Colour modifier from an RGB value

Examples found in repository ?

examples/complex-scene.rs (line 26)

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);
        }
    );
}