Simple Game Engine

This project aims to create a minimal, yet usable, game engine. It is heavily inspired by the Pixel Game Engine, with the goal of creating something that abstracts away the complexities of creating graphical, interactive apps and games. Right now, it's a thin wrapper around SDL2 (using the sdl2 crate) for visuals.

This is highly experimental so far, so if you have any ideas or would like to contribute, please sub mit an issue.

Features

• Very simple to use: Just implement the `Application trait on a type of your choice, then pass an instance of this type to Engine::new().
• Powerful: Anything you can do with sdl2 from Rust, you can do with this library, and we provide thin abstractions over some of the more convoluted sdl2 interfaces.
• Built-in text rendering: No need to find a TTF font and distribute it with your application, just call the Canvas::draw_text() method. (see below)

Caveats With Text Rendering

This crate uses the GNU Unifont for built-in text rendering. As such, if you wish to use this feature, you must distribute your project under the GPL. As this is not desirable for many projects, this feature is only enabled if this crate is built with the "unifont" cargo feature.

[dependencies.simple-game-engine]
version = "0.8.2"
features = ["unifont"]

If you'd like to render text without using this font, consider checking out the SDL2 TTF module

Install

Add the following to your Cargo.toml:

[dependencies]
simple-game-engine = "0.8.2"

This crate depends on sdl2, which can be built and linked in several ways:

• By default, the system version of sdl is used if it exists.
• With the "bundled_sdl" feature, the latest version of sdl2 will be downloaded, compiled and dynamically linked to your program. This requires you install cmake.
• With the "static_sdl" feature, sdl2 will be linked statically.

Please see the sdl2 crate README for installation instructions for each platform.

Example

The simplest SGE program looks like this:

use simple_game_engine::{self as sge, prelude::*};
use std::error::Error;

struct App {}

impl sge::Application for App {
    fn on_create(
        &mut self,
        canvas: &mut WindowCanvas,
        input: &InputState,
    ) -> sge::ApplicationResult {
        // Do one-time initialisation here
        Ok(true) // `true` indicates to continue running the application
    }

    fn on_update(
        &mut self,
        canvas: &mut WindowCanvas,
        input: &InputState,
        elapsed_time: f64,
    ) -> sge::ApplicationResult {
        // Handle user input, update the canvas, and perform any other tasks to be ran on each frame
        Ok(true) // `true` indicates to continue running the application
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut app = App {};
    let mut engine = sge::Engine::new(
        &mut app,   // Application instance
        "Test App", // Window title
        640,        // Window width
        480,        // Window height
    )?;
    engine.start(true) // `true` starts the app with vsync enabled
}

on_create and on_update are optional, but their default implementation does nothing, so you'll probably want to define some logic for at least on_update, which is called for every frame.