Crate simple_game_engine[][src]

A minimal game engine that’s really easy to get started with.

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.

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][canvas::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.1"
features = ["unifont"]

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

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.

Re-exports

pub use canvas::WindowCanvas;

Modules

canvas

Provides the Canvas struct, which allows the screen to be manipulated, such as by drawing points, lines, rectangles, text, or textures to it.

input

Data structures for inspecting user input.

prelude

Commonly used types.

Structs

Color
Engine

The main game engine, which manages the display and input.

Point

Immutable point type, consisting of x and y.

Rect

A (non-empty) rectangle.

Traits

Application

An application using this framework.

Type Definitions

ApplicationResult

The return type of Application::on_create and Application::on_update.