Struct beryllium::Renderer

#[repr(transparent)]
pub struct Renderer<'sdl, 'win> { /* fields omitted */ }

Handle to some SDL2 rendering state.

Helps you do things like upload data to the GPU and blit image data around.

To be clear: This is not a super fast renderer. It's easy to use and you can get an image on the screen, but if you want do much at all that's computationally expensive you'll need to use a proper hardware API (OpenGL, Vulkan, etc). Also, you cannot really mix this renderer with the hardware APIs. They both expect to have full control of the pixel process. Use this or a hardware API.

Methods

impl<'sdl, 'win> Renderer<'sdl, 'win>

pub fn create_texture_from_surface<'ren>(
    &'ren self,
    surf: &Surface
) -> Result<Texture<'sdl, 'win, 'ren>, String>

Makes a texture with the contents of the surface specified.

The TextureAccess hint for textures from this is "static".

The pixel format might be different from the surface's pixel format.

pub fn draw_color(&self) -> Result<Color, String>

Obtains the current draw color.

pub fn set_draw_color(&self, color: Color) -> Result<(), String>

Assigns the color used for drawing.

pub fn clear(&self) -> Result<(), String>

Clears the render target with the current draw color.

pub fn draw_line(
    &self,
    x1: i32,
    y1: i32,
    x2: i32,
    y2: i32
) -> Result<(), String>

Draws a line that includes both end points.

pub fn draw_lines(&self, points: &[Point]) -> Result<(), String>

Using the slice of n points, draws n-1 lines end to end.

pub fn copy(
    &self,
    t: &Texture,
    src: Option<Rect>,
    dst: Option<Rect>
) -> Result<(), String>

Blits the texture to the rendering target.

• src: Optional clip rect of where to copy from. If None, the whole texture is used.
• dst: Optional clip rect of where to copy data to. If None, the whole render target is used.

The image is stretched as necessary if the src and dst are different sizes. This is a GPU operation, so it's fast no matter how much upscale or downscale you do.

pub fn present(&self)

Presents the backbuffer to the user.

After a present, all backbuffer data should be assumed to be invalid, and you should also clear the backbuffer before doing the next render pass even if you intend to write to every pixel.

Trait Implementations

impl<'sdl, 'win> Drop for Renderer<'sdl, 'win>

fn drop(&mut self)

Executes the destructor for this type.

impl<'sdl, 'win> Debug for Renderer<'sdl, 'win>

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

Formats the value using the given formatter.