Struct gemini_engine::elements::view::View

pub struct View {
    pub width: usize,
    pub height: usize,
    pub background_char: ColChar,
    /* private fields */
}

The View struct is the canvas on which you will print all of your ViewElements. In normal use, you would clear the View, blit all your ViewElements to it and then render. The following example demonstrates a piece of code that will render a View of width 9 and height 3, with a single Point in the middle

use gemini_engine::elements::{view::{Wrapping, ColChar}, View, Point, Vec2D};

fn main() {
    let mut view = View::new(9, 3, ColChar::BACKGROUND);
    let point = Point::new(Vec2D::new(4,1), ColChar::SOLID);

    view.blit(&point, Wrapping::Panic);

    view.display_render().unwrap();
}

Fields

width: usize

height: usize

background_char: ColChar

Implementations

impl View

pub fn new(width: usize, height: usize, background_char: ColChar) -> View

Examples found in repository

examples/quick-start.rs (line 10)

fn main() {
    let mut view = View::new(40, 8, ColChar::BACKGROUND);
    let mut point = Point::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/spinning-cube.rs (line 10)

fn main() {
    let mut frame_skip = false;
    let mut view = View::new(350, 90, ColChar::BACKGROUND);

    let mut viewport = Viewport::new(
        Vec3D::new(0.0, 0.0, 6.0),
        Vec3D::new(-0.5, 0.0, 0.0),
        FOV,
        Vec2D::new((view.width / 2) as isize, (view.height / 2) as isize),
    );

    let cube = Mesh3D::default_cube();

    loop {
        let now = gameloop::Instant::now();
        view.clear();

        viewport.rotation.y -= 0.05;

        match frame_skip {
            true => frame_skip = false,
            false => {
                viewport.blit_to(&mut view, vec![&cube], DisplayMode::Solid);
                view.display_render().unwrap();
            }
        }

        let elapsed = now.elapsed();
        println!(
            "Elapsed: {:.2?}µs | Frame skip: {}",
            elapsed.as_micros(),
            frame_skip
        );

        frame_skip = gameloop::sleep_fps(FPS, Some(elapsed));
    }
}

pub fn size(&self) -> Vec2D

pub fn center(&self) -> Vec2D

pub fn clear(&mut self)

Examples found in repository

examples/quick-start.rs (line 14)

fn main() {
    let mut view = View::new(40, 8, ColChar::BACKGROUND);
    let mut point = Point::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/spinning-cube.rs (line 23)

fn main() {
    let mut frame_skip = false;
    let mut view = View::new(350, 90, ColChar::BACKGROUND);

    let mut viewport = Viewport::new(
        Vec3D::new(0.0, 0.0, 6.0),
        Vec3D::new(-0.5, 0.0, 0.0),
        FOV,
        Vec2D::new((view.width / 2) as isize, (view.height / 2) as isize),
    );

    let cube = Mesh3D::default_cube();

    loop {
        let now = gameloop::Instant::now();
        view.clear();

        viewport.rotation.y -= 0.05;

        match frame_skip {
            true => frame_skip = false,
            false => {
                viewport.blit_to(&mut view, vec![&cube], DisplayMode::Solid);
                view.display_render().unwrap();
            }
        }

        let elapsed = now.elapsed();
        println!(
            "Elapsed: {:.2?}µs | Frame skip: {}",
            elapsed.as_micros(),
            frame_skip
        );

        frame_skip = gameloop::sleep_fps(FPS, Some(elapsed));
    }
}

pub fn plot(&mut self, pos: Vec2D, c: ColChar, wrapping: Wrapping)

pub fn blit<T: ViewElement>(&mut self, element: &T, wrapping: Wrapping)

Blit a ViewElement to the screen. This is usually done before rendering.

Examples found in repository

examples/quick-start.rs (line 18)

fn main() {
    let mut view = View::new(40, 8, ColChar::BACKGROUND);
    let mut point = Point::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);
    }
}

pub fn display_render(&self) -> Result<()>

Display the View. View implements the Display trait so you can display it how you wish, but this is intended to be the fastest way possible

Examples found in repository

examples/quick-start.rs (line 19)

fn main() {
    let mut view = View::new(40, 8, ColChar::BACKGROUND);
    let mut point = Point::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/spinning-cube.rs (line 31)

fn main() {
    let mut frame_skip = false;
    let mut view = View::new(350, 90, ColChar::BACKGROUND);

    let mut viewport = Viewport::new(
        Vec3D::new(0.0, 0.0, 6.0),
        Vec3D::new(-0.5, 0.0, 0.0),
        FOV,
        Vec2D::new((view.width / 2) as isize, (view.height / 2) as isize),
    );

    let cube = Mesh3D::default_cube();

    loop {
        let now = gameloop::Instant::now();
        view.clear();

        viewport.rotation.y -= 0.05;

        match frame_skip {
            true => frame_skip = false,
            false => {
                viewport.blit_to(&mut view, vec![&cube], DisplayMode::Solid);
                view.display_render().unwrap();
            }
        }

        let elapsed = now.elapsed();
        println!(
            "Elapsed: {:.2?}µs | Frame skip: {}",
            elapsed.as_micros(),
            frame_skip
        );

        frame_skip = gameloop::sleep_fps(FPS, Some(elapsed));
    }
}

Trait Implementations

impl Display for View

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

Formats the value using the given formatter.

impl From<&View> for Vec2D

fn from(value: &View) -> Self

Converts to this type from the input type.