Struct sdl2::render::Texture

pub struct Texture<'r> { /* fields omitted */ }

A texture for a rendering context.

Every Texture is owned by a TextureCreator. Internally, a texture is destroyed via its Drop implementation. A texture can only be used by the Canvas it was originally created from, it is undefined behavior otherwise.

Methods

impl<'r> Texture<'r>

pub fn query(&self) -> TextureQuery

Queries the attributes of the texture.

pub fn set_color_mod(&mut self, red: u8, green: u8, blue: u8)

Sets an additional color value multiplied into render copy operations.

pub fn color_mod(&self) -> (u8, u8, u8)

Gets the additional color value multiplied into render copy operations.

pub fn set_alpha_mod(&mut self, alpha: u8)

Sets an additional alpha value multiplied into render copy operations.

pub fn alpha_mod(&self) -> u8

Gets the additional alpha value multiplied into render copy operations.

pub fn set_blend_mode(&mut self, blend: BlendMode)

Sets the blend mode used for drawing operations (Fill and Line).

pub fn blend_mode(&self) -> BlendMode

Gets the blend mode used for texture copy operations.

pub fn update<R>(
    &mut self,
    rect: R,
    pixel_data: &[u8],
    pitch: usize
) -> Result<(), UpdateTextureError> where
    R: Into<Option<Rect>>, 

Updates the given texture rectangle with new pixel data.

pitch is the number of bytes in a row of pixel data, including padding between lines

• If rect is None, the entire texture is updated.

pub fn update_yuv<R>(
    &mut self,
    rect: R,
    y_plane: &[u8],
    y_pitch: usize,
    u_plane: &[u8],
    u_pitch: usize,
    v_plane: &[u8],
    v_pitch: usize
) -> Result<(), UpdateTextureYUVError> where
    R: Into<Option<Rect>>, 

Updates a rectangle within a planar YV12 or IYUV texture with new pixel data.

pub fn with_lock<F, R, R2>(&mut self, rect: R2, func: F) -> Result<R, String> where
    F: FnOnce(&mut [u8], usize) -> R,
    R2: Into<Option<Rect>>, 

Locks the texture for write-only pixel access. The texture must have been created with streaming access.

F is a function that is passed the write-only texture buffer, and the pitch of the texture (size of a row in bytes).

Remarks

As an optimization, the pixels made available for editing don't necessarily contain the old texture data. This is a write-only operation, and if you need to keep a copy of the texture data you should do that at the application level.

pub unsafe fn gl_bind_texture(&mut self) -> (f32, f32)

Binds an OpenGL/ES/ES2 texture to the current context for use with when rendering OpenGL primitives directly.

pub unsafe fn gl_unbind_texture(&mut self)

Unbinds an OpenGL/ES/ES2 texture from the current context.

pub fn gl_with_bind<R, F: FnOnce(f32, f32) -> R>(&mut self, f: F) -> R

Binds and unbinds an OpenGL/ES/ES2 texture from the current context.

pub const fn raw(&self) -> *mut SDL_Texture

pub fn from_surface<'a, T>(
    surface: &Surface,
    texture_creator: &'a TextureCreator<T>
) -> Result<Texture<'a>, TextureValueError>

A convenience function for [TextureCreator::create_texture_from_surface].

use sdl2::pixels::PixelFormatEnum;
use sdl2::surface::Surface;
use sdl2::render::{Canvas, Texture};
use sdl2::video::Window;

// We init systems.
let sdl_context = sdl2::init().expect("failed to init SDL");
let video_subsystem = sdl_context.video().expect("failed to get video context");

// We create a window.
let window = video_subsystem.window("sdl2 demo", 800, 600)
    .build()
    .expect("failed to build window");

// We get the canvas from which we can get the `TextureCreator`.
let mut canvas: Canvas<Window> = window.into_canvas()
    .build()
    .expect("failed to build window's canvas");
let texture_creator = canvas.texture_creator();

let surface = Surface::new(512, 512, PixelFormatEnum::RGB24).unwrap();
let texture = Texture::from_surface(&surface, &texture_creator).unwrap();

Trait Implementations

impl<'r> Drop for Texture<'r>

fn drop(&mut self)

Executes the destructor for this type.