Crate piston_window

Expand description

The official Piston window wrapper for the Piston game engine

Notice! If this is your first time visiting Piston, start here.

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);
        });
    }
}

The draw_2d function calls the closure on render events. There is no need to filter events manually, and there is no overhead.

Swap to another window back-end

Change the 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();

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

circle_arc

Draw an arc

color

Helper methods for colors

context

Transformation context

controller

Back-end agnostic controller events.

Graphics draw state.

Draw ellipse

Event identifiers.

Trait for generic events

glyph_cache

Implementations of the CharacterCache trait.

grid

A flat grid with square cells.

image

Draw an image

keyboard

Back-end agnostic keyboard keys.

line

Draw Line

math

Various methods for computing with vectors.

modular_index

Helper functions for computing modular index safely.

mouse

Back-end agnostic mouse buttons.

polygon

Draw polygon

radians

Reexport radians helper trait from vecmath

Draw rectangle

Draw text

Texture packing.

Methods for converting shapes into triangles.

types

Contains type aliases used in this library

Structs

AfterRenderArgs

After render arguments.

Api

Stores graphics API version.

ButtonArgs

Button arguments.

Character

Holds rendered character data.

A curved line

Close arguments.

Drawing 2d context.

Components of a controller axis move event. Not guaranteed consistent across backends.

ControllerButton

Components of a controller button event. Not guaranteed consistent across backends.

ControllerHat

Components of a controller hat move event (d-Pad).

DrawState

Graphics draw state used for blending, clipping and stencil rendering.

Ellipse

An ellipse with filled color

EventSettings

Stores event loop settings.

Events

An event loop iterator

IdleArgs

Idle arguments, such as expected idle time in seconds.

Image

An image

Line

A colored line with a default border radius

NoWindow

A window without user interface, often used in server event loops.

PistonWindow

Contains everything required for controlling window, graphics, event loop.

Polygon

A polygon

Position

Structure to store the window position.

A filled rectangle

Render arguments.

Resize arguments.

Structure to store the window size.

Text

Renders text

Texture

Represents a texture.

TextureContext

Context required to create and update textures.

TextureSettings

Texture creation parameters.

TouchArgs

Touch arguments

UnsupportedGraphicsApiError

An error for when a graphics API is unsupported.

UpdateArgs

Update arguments, such as delta time in seconds.

Viewport

Stores viewport information.

WindowSettings

Settings structure for window behavior.

Enums

Button

Models different kinds of buttons.

ButtonState

Stores button state.

Event

Models all events.

FileDrag

Models dragging and dropping files.

Filter

Sampling filter

Flip

Flip settings.

HatState

Stores controller hat state.

Input

Models input events.

Key

Represent a keyboard key. Keycodes follows SDL http://wiki.libsdl.org/SDLKeycodeLookup

Loop

Models loop events.

Motion

Models different kinds of motion.

MouseButton

Represent a mouse button.

OpenGL

Touch

Stores the touch state.

Constants

BACK_END_MAX_VERTEX_COUNT

Any triangulation method called on the back-end never exceeds this number of vertices. This can be used to initialize buffers that fit the chunk size.

DEFAULT_MAX_FPS

The default maximum frames per second.

DEFAULT_UPS

The default updates per second.

DEFAULT_UPS_RESET

The default delayed updates reset.