Module ggez::graphics

The graphics module performs the actual drawing of images, text, and other objects with the Drawable trait. It also handles basic loading of images and text.

This module also manages graphics state, coordinate systems, etc. The default coordinate system has the origin in the upper-left corner of the screen.

Modules

pipe
spritebatch	SpriteBatch type. A SpriteBatch is a way to efficiently draw a large number of copies of the same image, or part of the same image. It's useful for implementing tiled maps, spritesheets, particles, and other such things.

Structs

CanvasGeneric	A generic canvas independent of graphics backend. This type should probably never be used directly; use ggez::graphics::Canvas instead.
Color	A RGBA color in the sRGB color space represented as f32's in the range [0.0-1.0]
DrawParam	A struct containing all the necessary info for drawing a Drawable.
EmptyConst	A type for empty shader data for shaders that do not require any additional data to be sent to the GPU
GlBackendSpec	A backend specification for OpenGL. This is different from conf::Backend because this needs to be its own struct to implement traits upon, and because there may need to be a layer of translation between what the user specifies in the config, and what the graphics backend init code actually gets.
Globals	Internal structure containing global shader state.
ImageGeneric	Generic in-GPU-memory image data available to be drawn on the screen.
InstanceProperties	Internal structure containing values that are different for each rect.
Mesh	2D polygon mesh.
MeshBuilder	A builder for creating Meshes.
Rect	A simple 2D rectangle.
ShaderGeneric	A ShaderGeneric reprensents a handle user-defined shader that can be used with a ggez graphics context that is generic over gfx::Resources
ShaderLock	A lock for RAII shader regions. The shader automatically gets cleared once the lock goes out of scope, restoring the previous shader (if any).
Text	Drawable text created from a Font.
Vertex	Internal structure containing vertex data.

Enums

BlendMode	An enum for specifying default and custom blend modes
DrawMode	Specifies whether a shape should be drawn filled or as an outline.
FilterMode	Specifies what blending method to use when scaling up/down images.
Font	A font that defines the shape of characters drawn on the screen. Can be created from a .ttf file or from an image (bitmap fonts).

Constants

BLACK	Black
WHITE	White

Traits

BackendSpec	A marker trait saying that something is a label for a particular backend, with associated gfx-rs types for that backend.
Drawable	All types that can be drawn on the screen implement the Drawable trait.
ShaderHandle	A trait that is used to create trait objects to abstract away the Structure type of the constant data for drawing

Functions

apply_transformations	Calculates the new total transformation (Model-View-Projection) matrix based on the matrices at the top of the transform and view matrix stacks and sends it to the graphics card.
circle	Draw a circle.
clear	Clear the screen to the background color.
clear_shader	Clears the the current shader for the Context making use the default
draw	Draws the given Drawable object to the screen by calling its draw() method.
draw_ex	Draws the given Drawable object to the screen by calling its draw_ex() method.
ellipse	Draw an ellipse.
get_background_color	Returns the current background color.
get_color	Returns the current foreground color.
get_default_filter	Get the default filter mode for new images.
get_depth_view	EXPERIMENTAL function to get the gfx-rs depth view
get_device	EXPERIMENTAL function to get the gfx-rs Device object.
get_display_count	Returns the number of connected displays.
get_drawable_size	Returns the size of the window's underlying drawable in pixels as (height, width). This may return a different value than get_size() when run on a platform with high-DPI support
get_encoder	EXPERIMENTAL function to get the gfx-rs Encoder object.
get_factory	EXPERIMENTAL function to get the gfx-rs Factory object.
get_fullscreen_modes	Returns a Vec of (width, height) tuples describing what fullscreen resolutions are available for the given display.
get_gfx_objects	EXPERIMENTAL function to get gfx-rs objects Getting them one by one is awkward 'cause it tends to create double-borrows on the Context object.
get_projection	Gets a copy of the context's raw projection matrix
get_renderer_info	Returns a string that tells a little about the obtained rendering mode. It is supposed to be human-readable and will change; do not try to parse information out of it!
get_screen_coordinates	Returns a rectangle defining the coordinate system of the screen. It will be Rect { x: left, y: top, w: width, h: height }
get_screen_render_target	EXPERIMENTAL function to get the gfx-rs color view
get_size	Returns the size of the window in pixels as (height, width). TODO: Make sure it's the CURRENT size!
get_transform	Gets a copy of the context's current transform matrix
get_window	Returns a reference to the SDL window. Ideally you should not need to use this because ggez would provide all the functions you need without having to dip into SDL itself. But life isn't always ideal.
get_window_mut	Returns a mutable reference to the SDL window.
is_fullscreen	Queries the fullscreen state of the window subsystem. If true, then the game is running in fullscreen mode.
line	Draws a line of one or more connected segments.
origin	Sets the current model transform to the origin transform (no transformation)
points	Draws points (as rectangles)
polygon	Draws a closed polygon
pop_transform	Pops the transform matrix off the top of the transform (model) matrix stack of the Context.
present	Tells the graphics system to actually put everything on the screen. Call this at the end of your EventHandler's draw() method.
push_transform	Pushes a homogeneous transform matrix to the top of the transform (model) matrix stack of the Context. If no matrix is given, then pushes a copy of the current transform matrix to the top of the stack.
rectangle	Draws a rectangle.
set_background_color	Sets the background color. Default: blue.
set_blend_mode	Sets the blend mode of the currently active shader program
set_canvas	Set the canvas to render to. Specifying Option::None will cause all rendering to be done directly to the screen.
set_color	Sets the foreground color, which will be used for drawing rectangles, lines, etc. Default: white.
set_default_filter	Sets the default filter mode used to scale images.
set_fullscreen	Toggles the fullscreen state of the window subsystem
set_mode	Sets the window mode, such as the size and other properties.
set_projection	Sets the raw projection matrix to the given homogeneous transformation matrix.
set_resolution	Sets the window resolution based on the specified width and height
set_screen_coordinates	Sets the bounds of the screen viewport.
set_shader	Set the current shader for the Context to render with
set_transform	Sets the current model transformation to the given homogeneous transformation matrix.
transform	Premultiplies the given transform with the current model transform.
transform_projection	Premultiplies the given transformation matrix with the current projection matrix
use_shader	Use a shader until the returned lock goes out of scope

Type Definitions

Canvas	A canvas that can be rendered to instead of the screen (sometimes referred to as "render target" or "render to texture"). Set the canvas with the ggez::graphics::set_canvas() function.
Image	In-GPU-memory image data available to be drawn on the screen, using the OpenGL backend.
Matrix4	A 4 dimensional matrix representing an arbitrary 3d transformation
Point2	A 2 dimensional point representing a location
Shader	A Shader represents a handle to a user-defined shader that can be used with a ggez graphics context
ShaderId	An ID used by the GraphicsContext to uniquely identify a shader
Vector2	A 2 dimensional vector representing an offset of a location
WrapMode	Specifies how to wrap textures.