Crate piston_window [−] [src]
The official Piston window wrapper for the Piston game engine
The purpose of this library is to provide an easy-to-use, simple-to-get-started and convenient-for-applications API for Piston.
Sets up:
- Gfx with an OpenGL back-end.
- gfx_graphics for 2D rendering.
- glutin_window as default window back-end, but this can be swapped (see below).
Example
extern crate piston_window; use piston_window::*; fn main() { let mut window: PistonWindow = WindowSettings::new("Hello World!", [512; 2]) .build().unwrap(); while let Some(e) = window.next() { window.draw_2d(&e, |c, g| { clear([0.5, 0.5, 0.5, 1.0], g); rectangle([1.0, 0.0, 0.0, 1.0], // red [0.0, 0.0, 100.0, 100.0], // rectangle c.transform, g); }); } }
Swap to another window back-end
Change the second generic parameter to the window back-end you want to use.
extern crate piston_window; extern crate sdl2_window; use piston_window::*; use sdl2_window::Sdl2Window; let window: PistonWindow<(), Sdl2Window> = WindowSettings::new("title", [512; 2]) .build().unwrap();
Change application state
PistonWindow
has an app
method that changes application state.
When you call app
, it returns PistonWindow<App>
.
By default, the application state is ()
.
The idea is to cleanly separate the states of the application from each other. Many kind of programs on high level can be described as a finite state machine. Piston's design is focused at external control, where the programmer decides the flow of the program.
For example, an adventure game can use different types of event loops for various rooms. The event loops can vary whether you want to display animations, have a dialogue or navigate.
For example, a game engine can use one event loop for gameplay, another for editor mode, and yet another for the game menu.
For a demonstration of this pattern, see the "hello_piston" example.
sRGB
The impl of BuildFromWindowSettings
in this library turns on
WindowSettings::srgb
, because it is required by gfx_graphics.
Most images such as those found on the internet uses sRGB,
that has a non-linear gamma corrected space.
When rendering 3D, make sure textures and colors are in linear gamma space.
Alternative is to use Srgb8
and Srgba8
formats for textures.
For more information about sRGB, see https://github.com/PistonDevelopers/piston/issues/1014
Library dependencies
This library is meant to be used in applications only. It is not meant to be depended on by generic libraries. Instead, libraries should depend on the lower abstractions, such as the Piston core.
Reexports
pub use graphics::*; |
pub use piston::window::*; |
pub use piston::input::*; |
pub use piston::event_loop::*; |
Structs
PistonWindow |
Contains everything required for controlling window, graphics, event loop. |
Texture |
Represents a texture. |
TextureSettings |
Texture creation parameters. |
Enums
Error |
An enum to represent various possible run-time errors that may occur. |
Flip |
Flip settings. |
OpenGL |
Type Definitions
G2d |
2D graphics. |
G2dTexture |
Texture type compatible with |
GfxEncoder |
Actual gfx::Stream implementation carried by the window. |
Glyphs |
Glyph cache. |