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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
//! [](http://ggez.rs/)
//!
//! # What is this?
//!
//! 
//! [](https://docs.rs/ggez)
//! [](https://github.com/ggez/ggez/blob/master/LICENSE)
//! [](https://crates.io/crates/ggez)
//! [](https://crates.io/crates/ggez)
//! [](https://discord.gg/48VycPe2ZX)
//!
//! ggez is a Rust library to create a Good Game Easily.
//!
//! The current version is 0.9.3.
//!
//! More specifically, ggez is a lightweight cross-platform game framework
//! for making 2D games with minimum friction. It aims to implement an
//! API based on (a Rustified version of) the [LÖVE](https://love2d.org/)
//! game framework. This means it contains basic and portable 2D
//! drawing, sound, resource loading and event handling, but finer details
//! and performance characteristics may be different than LÖVE.
//!
//! ggez is not meant to be everything to everyone, but rather a good
//! base upon which to build. Thus it takes a fairly
//! batteries-included approach without needing a million additions
//! and plugins for everything imaginable, but also does not dictate
//! higher-level functionality such as physics engine or entity
//! component system. Instead the goal is to allow you to use
//! whichever libraries you want to provide these functions, or build
//! your own libraries atop ggez.
//!
//! ## Features
//!
//! * Filesystem abstraction that lets you load resources from folders or zip files
//! * Hardware-accelerated 2D rendering built on the `wgpu` graphics API
//! * Loading and playing .ogg, .wav and .flac files via the `rodio` crate
//! * TTF font rendering with `glyph_brush`.
//! * Interface for handling keyboard and mouse events easily through callbacks
//! * Config file for defining engine and game settings
//! * Easy timing and FPS measurement functions.
//! * Math library integration with `mint`.
//! * Some more advanced graphics options: shaders, instanced draws and render targets
//!
//! ### Supported platforms
//!
//! * Fully supported: Windows, Linux
//! * Not officially supported but might work anyway: Mac
//!
//! For details, see [docs/BuildingForEveryPlatform.md](https://github.com/ggez/ggez/blob/master/docs/BuildingForEveryPlatform.md)
//!
//! If you want to run ggez on Android, iOS or the web using WebAssembly take a look at [good-web-game](https://github.com/ggez/good-web-game).
//!
//! ## Who's using ggez?
//!
//! Check out the [projects list!](https://github.com/ggez/ggez/blob/master/docs/Projects.md)
//!
//! ## Usage
//!
//! ggez requires rustc >= 1.42 and is distributed on
//! crates.io. To include it in your project, just add the dependency
//! line to your `Cargo.toml` file:
//!
//! ```text
//! ggez = "0.9.3"
//! ```
//!
//! ggez consists of three main parts: A `Context` object which
//! contains all the state required to interface with the computer's
//! hardware, an `EventHandler` trait that the user implements to
//! register callbacks for events, and various sub-modules such as
//! `graphics` and `audio` that provide the functionality to actually
//! get stuff done. The general pattern is to create a struct holding
//! your game's data which implements the `EventHandler` trait.
//! Create a new `Context` object with default objects from a `ContextBuilder`
//! or `Conf` object, and then call `event::run()` with
//! the `Context` and an instance of your `EventHandler` to run your game's
//! main loop.
//!
//! See the [API docs](https://docs.rs/ggez/) for full documentation, or the [examples](https://github.com/ggez/ggez/tree/master/examples) directory for a number of commented examples of varying complexity. Most examples show off
//! a single feature of ggez, while `astroblasto` and `snake` are small but complete games.
//!
//! ## Getting started
//!
//! For a quick tutorial on ggez, see the [Hello ggez](https://github.com/ggez/ggez/blob/master/docs/guides/HelloGgez.md) guide in the `docs/` directory.
//!
//! ## Examples
//!
//! See the `examples/` directory in the source. Most examples show off
//! a single feature of ggez, while `astroblasto` is a small but
//! complete Asteroids-like game.
//!
//! To run the examples, just check out the source and execute `cargo run --example`
//! in the root directory:
//!
//! ```text
//! git clone https://github.com/ggez/ggez.git
//! cd ggez
//! cargo run --example 05_astroblasto
//! ```
//!
//! If this doesn't work, see the
//! [FAQ](https://github.com/ggez/ggez/blob/master/docs/FAQ.md) for solutions
//! to common problems.
//!
//! ### Basic Project Template
//!
//! ```rust,no_run
//! use ggez::{Context, ContextBuilder, GameResult};
//! use ggez::graphics::{self, Color};
//! use ggez::event::{self, EventHandler};
//!
//! fn main() {
//! // Make a Context.
//! let (mut ctx, event_loop) = ContextBuilder::new("my_game", "Cool Game Author")
//! .build()
//! .expect("aieee, could not create ggez context!");
//!
//! // Create an instance of your event handler.
//! // Usually, you should provide it with the Context object to
//! // use when setting your game up.
//! let my_game = MyGame::new(&mut ctx);
//!
//! // Run!
//! event::run(ctx, event_loop, my_game);
//! }
//!
//! struct MyGame {
//! // Your state here...
//! }
//!
//! impl MyGame {
//! pub fn new(_ctx: &mut Context) -> MyGame {
//! // Load/create resources such as images here.
//! MyGame {
//! // ...
//! }
//! }
//! }
//!
//! impl EventHandler for MyGame {
//! fn update(&mut self, _ctx: &mut Context) -> GameResult {
//! // Update code here...
//! Ok(())
//! }
//!
//! fn draw(&mut self, ctx: &mut Context) -> GameResult {
//! let mut canvas = graphics::Canvas::from_frame(ctx, Color::WHITE);
//! // Draw code here...
//! canvas.finish(ctx)
//! }
//! }
//! ```
//!
//! ## Implementation details
//!
//! ggez is built upon `winit` for windowing and events, `rodio` for
//! sound, and a 2D drawing engine implemented with `wgpu`. It is entirely
//! thread-safe (though platform constraints mean the event-handling loop
//! and drawing must be done in the main thread), and portable to Windows
//! and Linux.
//!
//! ggez is pure Rust™.
//!
//! ## Help!
//!
//! Sources of information:
//!
//! * The [FAQ](https://github.com/ggez/ggez/blob/master/docs/FAQ.md) has answers to common questions and problems.
//! * The [API docs](https://docs.rs/ggez/), a lot of design stuff is explained there.
//! * Check out the [examples](https://github.com/ggez/ggez/tree/master/examples).
//!
//! If you still have problems or questions, feel free to ask! Easiest ways are:
//!
//! * Open an issue on [the Github issue tracker](https://github.com/ggez/ggez/issues)
//! * Say hi on [our new Discord server](https://discord.gg/48VycPe2ZX)
//! * Or ask the wise people on the [unofficial Rust Discord server](http://bit.ly/rust-community), the [Rust Gamedev server](https://discord.gg/yNtPTb2) or the [good-web-game Discord server](https://discord.gg/jum3Fjek2A)
//!
//! License: MIT
#![doc(
html_logo_url = "https://raw.githubusercontent.com/ggez/ggez/master/docs/ggez-logo-maroon-logo-only.svg"
)]
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#![deny(unused_results)]
#![deny(unsafe_code)]
#![warn(bare_trait_objects)]
#![warn(missing_copy_implementations)]
#![allow(clippy::needless_doctest_main)]
#[macro_use]
extern crate log;
pub use glam;
pub use mint;
pub mod audio;
pub mod conf;
pub mod context;
pub mod error;
pub mod event;
pub mod filesystem;
pub mod graphics;
pub mod input;
pub mod timer;
mod vfs;
pub use crate::context::{winit, Context, ContextBuilder};
pub use crate::error::*;