Struct Graphics 

pub struct Graphics {
    pub canvas: Canvas<Window>,
    pub sdl_context: Sdl,
    pub texture_creator: Rc<TextureCreator<WindowContext>>,
    pub ttf_context: Sdl3TtfContext,
}

Owned SDL variables used for rendering

• canvas: the drawing surface for the window
• sdl_context: the SDL context

Fields

canvas: Canvas<Window>

The SDL3 canvas, required to draw

sdl_context: Sdl

SDL3 contaxt

texture_creator: Rc<TextureCreator<WindowContext>>

SDL3 texture creator

ttf_context: Sdl3TtfContext

SDL3 TTF context required for text rendering

Implementations

impl Graphics

pub fn new( name: String, dimensions: (u32, u32), ) -> Result<Graphics, Box<dyn Error>>

Initialize SDL3, create a centered, resizable window and return a Graphics container with the canvas and SDL context.

Parameters

• name: Window title.
• dimensions: (width, height) in pixels (u32).

Returns

• Ok(Graphics) on success.
• Err(Box<dyn std::error::Error>) on failure (window/canvas build error).

Example

let graphics = graphics::new(String::from("my cool game"), (500, 500))?;

Examples found in repository

examples/hello.rs (line 62)

async fn main() {
    let graphics = graphics::Graphics::new(String::from("my cool game"), (500, 500));
    let mut game = fennel_engine::Game::new(
        String::from("my cool game"),
        String::from("wiltshire"),
        graphics.unwrap(),
    );
    load_font("examples/terminus.ttf".into(), &mut game.resource_manager, &mut game.graphics, 32.0);
    events::run(&mut game, Box::new(State {})).await;
}

pub fn draw_image( &mut self, path: String, position: (f32, f32), manager: &mut ResourceManager, ) -> Result<()>

Cache an image if it isn’t cached and draw it on the canvas

Parameters

• path: Path to the image
• position: Where to draw the image in the window (x,y) in pixels (f32).

Returns

• Ok(()) on success.
• Err(Box<dyn std::error::Error>) on failure

Example

graphics.draw_image(String::from("examples/example.png"), (0.0, 0.0)).await;

Examples found in repository

examples/hello.rs (lines 19-23)

    async fn draw(&self, game: &mut Game) -> anyhow::Result<()> {
        game.graphics.canvas.set_draw_color(Color::RGB(0, 0, 0));
        game.graphics.canvas.clear();
        game.graphics
            .draw_image(
                "examples/example.png".to_string(),
                (0.0, 0.0),
                &mut game.resource_manager,
            )
            .expect("failed to draw an image");
        game.graphics.draw_text("hi".to_string(), (64.0, 64.0), "Terminus (TTF) 32".to_string(), Color::RGBA(255, 0, 0, 0), &mut game.resource_manager)?;
        game.graphics.canvas.present();
        Ok(())
    }

pub fn draw_text( &mut self, text: String, position: (f32, f32), font_family: String, color: Color, manager: &mut ResourceManager, ) -> Result<()>

Create a texture from font + text and render it on the canvas

This does not cache the font, so you have the load all the fonts you’ll be using in your initiaization function (like main). This does cache the texture created from supplied font and text.

Examples found in repository

examples/hello.rs (line 25)

    async fn draw(&self, game: &mut Game) -> anyhow::Result<()> {
        game.graphics.canvas.set_draw_color(Color::RGB(0, 0, 0));
        game.graphics.canvas.clear();
        game.graphics
            .draw_image(
                "examples/example.png".to_string(),
                (0.0, 0.0),
                &mut game.resource_manager,
            )
            .expect("failed to draw an image");
        game.graphics.draw_text("hi".to_string(), (64.0, 64.0), "Terminus (TTF) 32".to_string(), Color::RGBA(255, 0, 0, 0), &mut game.resource_manager)?;
        game.graphics.canvas.present();
        Ok(())
    }