Struct ggez::graphics::ImageGeneric

pub struct ImageGeneric<B> where
    B: BackendSpec,  { /* fields omitted */ }

Generic in-GPU-memory image data available to be drawn on the screen. You probably just want to look at the Image type.

Implementations

impl<B> ImageGeneric<B> where
    B: BackendSpec, 

pub fn get_raw_texture_handle(&self) -> RawTexture<B::Resources>

A helper function to get the raw gfx texture handle

pub fn get_raw_texture_view(&self) -> RawShaderResourceView<B::Resources>

A helper function to get the raw gfx texture view

pub fn width(&self) -> u16

Return the width of the image.

pub fn height(&self) -> u16

Return the height of the image.

pub fn filter(&self) -> FilterMode

Get the filter mode for the image.

pub fn set_filter(&mut self, mode: FilterMode)

Set the filter mode for the image.

pub fn dimensions(&self) -> Rect

Returns the dimensions of the image.

pub fn wrap(&self) -> (WrapMode, WrapMode)

Gets the Image’s WrapMode along the X and Y axes.

pub fn set_wrap(&mut self, wrap_x: WrapMode, wrap_y: WrapMode)

Sets the Image’s WrapMode along the X and Y axes.

impl ImageGeneric<GlBackendSpec>

pub fn new<P: AsRef<Path>>(context: &mut Context, path: P) -> GameResult<Self>

Load a new image from the file at the given path. The documentation for the filesystem module explains how the path must be specified.

pub fn from_bytes(context: &mut Context, bytes: &[u8]) -> GameResult<Self>

Creates a new Image from the given buffer, which should contain an image encoded in a supported image file format.

pub fn from_bytes_with_format(
    context: &mut Context,
    bytes: &[u8],
    format: ImageFormat
) -> GameResult<Self>

Creates a new Image from the given buffer, which should contain an image encoded in the given image file format.

pub fn from_rgba8(
    context: &mut Context,
    width: u16,
    height: u16,
    rgba: &[u8]
) -> GameResult<Self>

Creates a new Image from the given buffer of u8 RGBA values.

The pixel layout is row-major. That is, the first 4 u8 values make the top-left pixel in the Image, the next 4 make the next pixel in the same row, and so on to the end of the row. The next width * 4 values make up the second row, and so on.

pub fn to_rgba8(&self, ctx: &mut Context) -> GameResult<Vec<u8>>

Dumps the Image’s data to a Vec of u8 RGBA values.

pub fn encode<P: AsRef<Path>>(
    &self,
    ctx: &mut Context,
    format: ImageFormat,
    path: P
) -> GameResult

Encode the Image to the given file format and write it out to the given path.

See the filesystem module docs for where exactly the file will end up.

pub fn solid(context: &mut Context, size: u16, color: Color) -> GameResult<Self>

A little helper function that creates a new Image that is just a solid square of the given size and color. Mainly useful for debugging.

Trait Implementations

impl<B: Clone> Clone for ImageGeneric<B> where
    B: BackendSpec,
    B::Resources: Clone,
    B::Resources: Clone, 

fn clone(&self) -> ImageGeneric<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B> Debug for ImageGeneric<B> where
    B: BackendSpec, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: PartialEq> PartialEq<ImageGeneric<B>> for ImageGeneric<B> where
    B: BackendSpec,
    B::Resources: PartialEq,
    B::Resources: PartialEq, 

fn eq(&self, other: &ImageGeneric<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ImageGeneric<B>) -> bool

This method tests for !=.

impl<B> StructuralPartialEq for ImageGeneric<B> where
    B: BackendSpec,