Struct gemini_engine::elements::view::Pixel

pub struct Pixel {
    pub pos: Vec2D,
    pub fill_char: ColChar,
}

The Pixel holds a single Vec2D (the coordinates at which it is printed when blit to a View) and a ColChar

Fields

pos: Vec2D

The position of the Pixel

fill_char: ColChar

The appearance/colour of the Pixel

Implementations

impl Pixel

pub const fn new(pos: Vec2D, fill_char: ColChar) -> Self

Create a new Point from a Vec2D and ColChar

Examples found in repository

examples/game-loop-root.rs (line 20)

    fn new() -> Game {
        Game {
            view: View::new(40, 8, ColChar::BACKGROUND),
            point: Pixel::new(Vec2D { x: 10, y: 5 }, ColChar::SOLID),
        }
    }

examples/quick-start.rs (line 11)

fn main() {
    let mut view = View::new(40, 8, ColChar::BACKGROUND);
    let mut point = Pixel::new(Vec2D { x: 10, y: 5 }, ColChar::SOLID);

    loop {
        view.clear();

        point.pos.x += 1;

        view.blit(&point, Wrapping::Wrap);
        view.display_render().unwrap();

        gameloop::sleep_fps(FPS, None);
    }
}

examples/complex-scene.rs (line 16)

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

    let mut point = 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!(
        {
            point.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 point position being printed would continue to increase without looping
            point.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(&point, 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();
            view.display_render().unwrap();
            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: {}", point.pos);
        }
    );
}

Trait Implementations

impl Clone for Pixel

fn clone(&self) -> Pixel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Pixel

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

Formats the value using the given formatter.

impl From<(Vec2D, ColChar)> for Pixel

fn from(value: (Vec2D, ColChar)) -> Self

Converts to this type from the input type.

impl PartialEq for Pixel

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ViewElement for Pixel

fn active_pixels(&self) -> Vec<Pixel>

Return a vector of every coordinate where a pixel should be placed and its respective ColChar. If your whole object is a solid colour, consider using utils::points_to_pixels() which will add the same ColChar to every point and can then be used as this function’s output

impl Copy for Pixel

impl Eq for Pixel

impl StructuralEq for Pixel

impl StructuralPartialEq for Pixel