Crate thin_engine

Source
Expand description

A thin game engine (hence the name). Drawing done with glium, game variables done with glium-types, windowing done with winit and input done with winit-input-map. It has easy fxaa support and low boilerplate despite having lots of control.

use thin_engine::{prelude::*, meshes::screen};
use Action::*;

#[derive(Hash, PartialEq, Eq, Clone, Copy)]
enum Action {
    Left,
    Right,
    Jump,
    Exit
}
let (event_loop, window, display) = thin_engine::set_up().unwrap();
let mut input = {
    use thin_engine::input_map_setup::*;
    input_map!(
        (Left,  KeyA, MouseButton::Left,  ArrowLeft,  GamepadButton::DPadLeft),
        (Right, KeyD, MouseButton::Right, ArrowRight, GamepadButton::DPadRight),
        (Jump,  KeyW, ArrowUp, Space, GamepadButton::South),
        (Exit,  Escape, GamepadButton::Start)
    )
};
let (box_indices, box_verts) = mesh!(
    &display, &screen::INDICES, &screen::VERTICES
);
let box_shader = Program::from_source(
&display, shaders::VERTEX, 
"#version 140
out vec4 colour;
void main() {
    colour = vec4(1.0, 0.0, 0.0, 1.0);
}", None).unwrap();
 
let mut player_pos = Vec2::ZERO;
let mut player_gravity = 0.0;
let mut player_can_jump = true;

// camera matrix must be inverse
let camera = Mat4::from_scale(Vec3::splat(10.0)).inverse();
 
let settings = Settings::from_fps(60); // target of 60 fps
let mut frame_start = Instant::now();
thin_engine::run(event_loop, input, settings, |input, _settings, target| {
    // gets time between frames
    let delta_time = frame_start.elapsed().as_secs_f32();
    frame_start = Instant::now();

    // set up frame
    let size = window.inner_size().into();
    display.resize(size);
    let mut frame = display.draw();
    let view2d = Mat4::view_matrix_2d(size);
     
    if input.pressed(Exit) { target.exit() }

    // game logic
    player_pos.x += input.axis(Right, Left) * 10.0 * delta_time;
    player_gravity += delta_time * 50.0;
    player_pos.y -= player_gravity * delta_time;
    if player_pos.y < 0.0 {
        player_pos.y = 0.0;
        player_can_jump = true;
    }
    if player_can_jump && input.pressed(Jump) {
        player_gravity = -20.0;
        player_can_jump = false;
    }

    // draw
    frame.clear_color(0.0, 0.0, 0.0, 1.0);
    frame.draw(
        &box_verts, &box_indices, &box_shader, &uniform! {
            view: view2d, camera: camera,
            model: Mat4::from_pos(player_pos.extend(0.0)),
        }, &DrawParameters::default()
    );
    frame.finish().unwrap();
}).unwrap();

Re-exports§

Modules§

Structs§

  • ResizableDepthTexture2D
    resizable depth texture. use with gliums SimpleFrameBuffer::WithDepthTexture() to create a texture you can draw on! usefull for things like fog and fxaa.
  • ResizableTexture2D
    resizable depth texture. recomended to use with gliums SimpleFrameBuffer to draw onto a texture you can use in another shader! usefull for fxaa
  • Settings
    run time settings for thin engine including gamepad settings (through gilrs) and fps settings. when running default() the gamepads may fail to initialise and the program will continue running after printing the error. if this is undesirable use with_gamepads() instead.

Functions§

  • run
    used to quickly set up logic. handles closed and input events for you. the logic var will be run every frame.
  • run_with_event_handler
    used to quickly set up logic. handles closed and input events for you. the logic var will be run every frame. the event_handler var is for if you want more control over the event handling and is run multiple times before logic.
  • set_up
    used to quickly set up thin engine.

Type Aliases§