coffee 0.1.1

An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

# Coffee

[![Build Status](https://travis-ci.org/hecrj/coffee.svg?branch=master)](https://travis-ci.org/hecrj/coffee)
[![Documentation](https://docs.rs/coffee/badge.svg)](https://docs.rs/coffee)
[![Crates.io](https://img.shields.io/crates/v/coffee.svg)](https://crates.io/crates/coffee)
[![License](https://img.shields.io/crates/l/coffee.svg)](https://github.com/hecrj/coffee/blob/master/LICENSE)

An opinionated 2D game engine for Rust focused on simplicity, explicitness, and
type-safety.

__Coffee is in a very early stage of development.__ Active development is
planned during 2019 (and hopefully beyond that!). Many [basic features are still
missing], some [dependencies are experimental], and there are probably _many_
bugs. [Feel free to contribute!]

[basic features are still missing]: https://github.com/hecrj/coffee/issues?q=is%3Aissue+is%3Aopen+label%3Afeature
[dependencies are experimental]: #implementation-details
[Feel free to contribute!]: #contributing--feedback

## Features
  * Declarative, type-safe asset loading
  * Loading screens with progress tracking
  * Built-in [debug view with performance metrics]
  * Fixed timestep
  * Explicit, easy to use, hardware-accelerated 2D graphics API
  * Multiplatform support leveraging OpenGL, Vulkan, Metal, D3D11, and D3D12
  * Texture array support
  * Explicit and efficient batched draws
  * Off-screen rendering
  * TrueType font rendering

[debug view with performance metrics]: https://github.com/hecrj/coffee/blob/master/images/debug.png

## Usage
Add `coffee` as a dependency in your `Cargo.toml` and enable a graphics backend
feature (`opengl`, `vulkan`, `metal`, `dx11`, or `dx12`):

```toml
coffee = { version = "0.1", features = ["opengl"] }
```

Rust is quite slow in debug mode. If you experience performance issues when
drawing hundreds of sprites, enable compiler optimizations in your `Cargo.toml`.
I recommend level 2 optimizations in order to stay closer to `--release`
performance:

```toml
[profile.dev]
opt-level = 2
```

## Overview
Here is a minimal example that will open a window:

```rust
use coffee::{Game, Result, Timer};
use coffee::graphics::{Color, Window, WindowSettings};

fn main() -> Result<()> {
    MyGame::run(WindowSettings {
        title: String::from("A caffeinated game"),
        size: (1280, 1024),
        resizable: true,
    })
}

struct MyGame {
    // Your game state goes here...
}

impl Game for MyGame {
    type View = (); // No view data.
    type Input = (); // No input data.

    const TICKS_PER_SECOND: u16 = 60; // Update rate

    fn new(_window: &mut Window) -> Result<(MyGame, Self::View, Self::Input)> {
        // Load your game assets here. Check out the `load` module!
        Ok((MyGame { /* ... */ }, (), ()))
    }

    fn update(&mut self, _view: &Self::View, _window: &Window) {
        // Update your game here
    }

    fn draw(&self, _view: &mut Self::View, window: &mut Window, _timer: &Timer) {
        // Clear the current frame
        let mut frame = window.frame();
        frame.clear(Color::BLACK);

        // Draw your game here. Check out the `graphics` module!
    }
}
```

Check out the [documentation] and the [examples] to learn more!

[documentation]: https://docs.rs/coffee
[examples]: https://github.com/hecrj/coffee/tree/master/examples

## Implementation details
Coffee builds upon

  * [`winit`] for windowing and mouse/keyboard events.
  * [`gfx` pre-ll] for OpenGL support, based heavily on the [`ggez`] codebase.
  * [`wgpu`] for _experimental_ Vulkan, Metal, D3D11 and D3D12 support.
  * [`glyph_brush`] for TrueType font rendering.
  * [`nalgebra`] for the `Point`, `Vector`, and `Transformation` types.
  * [`image`] for image loading and texture array building.

[`winit`]: https://github.com/rust-windowing/winit
[`gfx` pre-ll]: https://github.com/gfx-rs/gfx/tree/pre-ll
[`wgpu`]: https://github.com/gfx-rs/wgpu
[`glyph_brush`]: https://github.com/alexheretic/glyph-brush/tree/master/glyph-brush
[`nalgebra`]: https://github.com/rustsim/nalgebra
[`image`]: https://github.com/image-rs/image

## Contributing / Feedback
I am quite new to Rust, systems programming, and computer graphics. I am
learning along the way as I build the engine for a game I am currently
developing. I am always glad to to learn from anyone.

If you want to contribute, you are more than welcome to be a part of the
project! Check out the current [issues] if you want to find something to work
on. Try to share you thoughts first! Feel free to open a new issue if you want
to discuss new ideas.

Any kind of feedback is welcome! You can open an issue or, if you want to talk,
you can find me (and a bunch of awesome folks) over the `#game-dev` channel in
the [Rust Community Discord]. I go by `@lone_scientist` there.

[issues]: https://github.com/hecrj/coffee/issues
[Rust Community Discord]: https://bit.ly/rust-community

## Credits / Thank you
  * [`ggez`], an awesome, easy-to-use, good game engine that introduced me to
    Rust a month ago. Its graphics implementation served me as a guide to
    implement OpenGL support for Coffee.

[`ggez`]: https://github.com/ggez/ggez