Struct Sprite 

pub struct Sprite<'s> { /* private fields */ }

Drawable representation of a texture

Sprite is a drawable type that allows to easily display a Texture (or a part of it) on a render target.

Note: Currently, it is not feasible to store sprites long term. A common pattern with rust-sfml is to create a Sprite right before you start drawing, and draw all the sprites you want with it. You can change its properties using set_texture, set_position, etc., before drawing it, as many times as you need to.

Implementations

impl<'s> Sprite<'s>

pub fn new() -> Sprite<'s>

Create a new sprite

Panics

Panics if a new Sprite can’t be created for some reason.

Examples found in repository

examples/shader.rs (line 30)

    fn new(texture: &'t Texture) -> SfResult<Self> {
        let mut sprite = Sprite::new();
        sprite.set_texture(texture, false);
        Ok(Self {
            sprite,
            shader: Shader::from_file("pixelate.frag", ShaderType::Fragment)?,
        })
    }

examples/borrowed-resources.rs (line 35)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut window = RenderWindow::new(
        (800, 600),
        "Borrowed resources",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    // Create a new texture. (Hey Frank!)
    let frank = Texture::from_file("frank.jpeg")?;

    // Create a font.
    let font = Font::from_file("sansation.ttf")?;

    // Create a circle with the Texture.
    let mut circle = CircleShape::with_texture(&frank);
    circle.set_radius(70.0);
    circle.set_position((100.0, 100.0));

    // Create a Sprite.
    let mut sprite = Sprite::new();
    // Have it use the same texture as the circle.
    sprite.set_texture(&frank, true);
    sprite.set_position((400.0, 300.0));
    sprite.set_scale(0.5);

    // Create a ConvexShape using the same texture.
    let mut convex_shape = ConvexShape::with_texture(6, &frank);
    convex_shape.set_point(0, (400., 100.));
    convex_shape.set_point(1, (500., 70.));
    convex_shape.set_point(2, (450., 100.));
    convex_shape.set_point(3, (580., 150.));
    convex_shape.set_point(4, (420., 230.));
    convex_shape.set_point(5, (420., 120.));

    // Create an initialized text using the font.
    let title = Text::new("Borrowed resources example!", &font, 50);

    // Create a second text using the same font.
    // This time, we create and initialize it separately.
    let mut second_text = Text::default();
    second_text.set_string("This text shares the same font with the title!");
    second_text.set_font(&font);
    second_text.set_fill_color(Color::GREEN);
    second_text.set_position((10.0, 350.0));
    second_text.set_character_size(20);

    // Create a third text using the same font.
    let mut third_text = Text::new("This one too!", &font, 20);
    third_text.set_position((300.0, 100.0));
    third_text.set_fill_color(Color::RED);

    'mainloop: loop {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => break 'mainloop,
                _ => {}
            }
        }

        window.clear(Color::BLACK);
        window.draw(&circle);
        window.draw(&sprite);
        window.draw(&convex_shape);
        window.draw(&title);
        window.draw(&second_text);
        window.draw(&third_text);

        // Little test here for `Shape::points`
        let mut circ = CircleShape::new(4.0, 30);
        circ.set_origin(2.0);
        circ.set_fill_color(Color::YELLOW);

        for p in convex_shape.points() {
            circ.set_position(p);
            window.draw(&circ);
        }

        window.display();
    }
    Ok(())
}

pub fn with_texture(texture: &'s Texture) -> Sprite<'s>

Create a new sprite with a texture

Examples found in repository

examples/shader.rs (line 187)

    fn new(bg_texture: &'t Texture, entity_texture: &'t Texture) -> SfResult<Self> {
        let mut surface = RenderTexture::new(800, 600)?;
        surface.set_smooth(true);
        let mut bg_sprite = Sprite::with_texture(bg_texture);
        bg_sprite.set_position((135., 100.));
        let mut entities = Vec::new();

        for i in 0..6 {
            entities.push(Sprite::with_texture_and_rect(
                entity_texture,
                IntRect::new(96 * i, 0, 96, 96),
            ));
        }

        let mut shader = Shader::from_file("edge.frag", ShaderType::Fragment)?;
        shader.set_uniform_current_texture("texture")?;

        Ok(Self {
            surface,
            bg_sprite,
            entities,
            shader,
        })
    }
}

impl Drawable for Edge<'_> {
    fn draw<'a: 'shader, 'texture, 'shader, 'shader_texture>(
        &'a self,
        target: &mut dyn RenderTarget,
        states: &RenderStates<'texture, 'shader, 'shader_texture>,
    ) {
        let mut states = *states;
        states.shader = Some(&self.shader);
        target.draw_with_renderstates(&Sprite::with_texture(self.surface.texture()), &states);
    }
}

impl Effect for Edge<'_> {
    fn update(&mut self, t: f32, x: f32, y: f32) -> SfResult<()> {
        self.shader
            .set_uniform_float("edge_threshold", 1. - (x + y) / 2.)?;
        let entities_len = self.entities.len() as f32;

        for (i, en) in self.entities.iter_mut().enumerate() {
            let pos = (
                (0.25 * (t * i as f32 + (entities_len - i as f32))).cos() * 300. + 350.,
                (0.25 * (t * (entities_len - i as f32) + i as f32)).cos() * 200. + 250.,
            );
            en.set_position(pos);
        }
        self.surface.clear(Color::WHITE);
        self.surface.draw(&self.bg_sprite);
        for en in &self.entities {
            self.surface.draw(en);
        }
        self.surface.display();
        Ok(())
    }
    fn name(&self) -> &str {
        "edge post-effect"
    }
}

struct Geometry<'tex> {
    point_cloud: [Vertex; 10_000],
    shader: FBox<Shader<'tex>>,
    texture: &'tex Texture,
    transform: Transform,
}

impl<'tex> Geometry<'tex> {
    fn new(texture: &'tex Texture) -> SfResult<Self> {
        if !Shader::is_geometry_available() {
            eprintln!("Geometry shaders not available");
            return Err(SfError::CallFailed);
        }
        let mut shader = Shader::from_memory_all(
            include_str!("resources/billboard.vert"),
            include_str!("resources/billboard.geom"),
            include_str!("resources/billboard.frag"),
        )?;
        shader.set_uniform_texture("texture", texture)?;
        shader.set_uniform_vec2("resolution", (800., 600.).into())?;
        let mut rng = SmallRng::seed_from_u64(1);
        Ok(Self {
            point_cloud: std::array::from_fn(|_| {
                Vertex::new(
                    (
                        rng.random_range(-480.0..480.0),
                        rng.random_range(-480.0..480.0),
                    )
                        .into(),
                    Color::WHITE,
                    Default::default(),
                )
            }),
            shader,
            texture,
            transform: Transform::IDENTITY,
        })
    }
}

impl Drawable for Geometry<'_> {
    fn draw<'a: 'shader, 'texture, 'shader, 'shader_texture>(
        &'a self,
        target: &mut dyn RenderTarget,
        states: &RenderStates<'texture, 'shader, 'shader_texture>,
    ) {
        let mut states = *states;
        states.shader = Some(&self.shader);
        states.texture = Some(self.texture);
        states.transform = self.transform;
        target.draw_primitives(&self.point_cloud, PrimitiveType::POINTS, &states);
    }
}

impl Effect for Geometry<'_> {
    fn update(&mut self, _t: f32, x: f32, y: f32) -> SfResult<()> {
        self.transform = Transform::IDENTITY;
        self.transform.translate(400., 300.);
        self.transform.rotate(x * 360.0);
        let size = 25. + y.abs() * 50.;
        self.shader.set_uniform_vec2("size", size.into())?;
        Ok(())
    }

    fn name(&self) -> &str {
        "Geometry Shader Billboards"
    }
}

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut window = RenderWindow::new(
        (800, 600),
        "SFML Shader",
        Style::TITLEBAR | Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let bg = Texture::from_file("background.jpg")?;
    let mut bg_texture = Texture::from_file("sfml.png")?;
    bg_texture.set_smooth(true);
    let mut entity_texture = Texture::from_file("devices.png")?;
    entity_texture.set_smooth(true);
    let logo_texture = Texture::from_file("logo.png")?;
    let effects: [&mut dyn Effect; 5] = [
        &mut Pixelate::new(&bg)?,
        &mut WaveBlur::new(&font)?,
        &mut StormBlink::new()?,
        &mut Edge::new(&bg_texture, &entity_texture)?,
        &mut Geometry::new(&logo_texture)?,
    ];
    let mut current = 0;
    let text_bg_texture = Texture::from_file("text-background.png")?;
    let mut text_bg = Sprite::with_texture(&text_bg_texture);
    text_bg.set_position((0., 520.));
    text_bg.set_color(Color::rgba(255, 255, 255, 200));
    let msg = format!("Current effect: {}", effects[current].name());
    let mut desc = Text::new(&msg, &font, 20);
    desc.set_position((10., 530.));
    desc.set_fill_color(Color::rgb(80, 80, 80));
    let msg = "Press left and right arrows to change the current shader";
    let mut instructions = Text::new(msg, &font, 20);
    instructions.set_position((280., 555.));
    instructions.set_fill_color(Color::rgb(80, 80, 80));
    let clock = Clock::start()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            use crate::Event::*;
            match event {
                Closed => window.close(),
                KeyPressed { code, .. } => match code {
                    Key::Escape => window.close(),
                    Key::Left => {
                        if current == 0 {
                            current = effects.len() - 1;
                        } else {
                            current -= 1;
                        }
                        desc.set_string(&format!("Current effect: {}", effects[current].name()));
                    }
                    Key::Right => {
                        if current == effects.len() - 1 {
                            current = 0;
                        } else {
                            current += 1;
                        }
                        desc.set_string(&format!("Current effect: {}", effects[current].name()));
                    }
                    _ => {}
                },
                _ => {}
            }
        }

        let x = window.mouse_position().x as f32 / window.size().x as f32;
        let y = window.mouse_position().y as f32 / window.size().y as f32;

        effects[current].update(clock.elapsed_time().as_seconds(), x, y)?;

        window.clear(Color::rgb(255, 128, 0));
        window.draw(effects[current]);
        window.draw(&text_bg);
        window.draw(&instructions);
        window.draw(&desc);
        window.display();
    }
    Ok(())
}

examples/resource-holder.rs (line 82)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut tex_holder = ResourceHolder::<Texture, _>::default();
    tex_holder.load("frank", "frank.jpeg")?;
    let mut sb_holder = ResourceHolder::<SoundBuffer, _>::default();
    sb_holder.load("canary", "canary.wav")?;
    let mut rw = RenderWindow::new(
        (800, 600),
        "Resource holder test",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let mut sound = Sound::with_buffer(sb_holder.get("canary"));
    sound.play();
    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => rw.close(),
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        rw.draw(&Sprite::with_texture(tex_holder.get("frank")));
        rw.display();
    }
    Ok(())
}

examples/rc-resources.rs (line 210)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut window =
        RenderWindow::new((800, 600), "SFML window", Style::CLOSE, &Default::default())?;
    window.set_framerate_limit(60);

    // Create a new texture.
    let texture = RcTexture::from_file("logo.png")?;
    let texture2 = test_getting_rc_texture_from_texture()?;

    // Create a new font.
    let font_path = match std::env::args().nth(1) {
        Some(path) => path,
        None => "sansation.ttf".into(),
    };
    let mut font = RcFont::from_file(&font_path)?;

    // Load many resources with no lifetime contingencies
    let mut floating_resources = Vec::from([
        FloatingResource::with_texture(&texture2, true, true, 1.1f32),
        FloatingResource::with_texture(&texture2, true, true, 1.2f32),
        FloatingResource::with_texture(&texture, true, true, 1f32),
        FloatingResource::with_texture(&texture, true, false, 1.5f32),
        FloatingResource::with_texture(&texture, false, true, 2f32),
        FloatingResource::with_texture(&texture, false, false, 2.5f32),
        FloatingResource::with_font(&font, true, true, 1.25f32),
        FloatingResource::with_font(&font, true, true, 1.75f32),
        FloatingResource::with_font(&font, true, true, 2.25f32),
        FloatingResource::with_font(&font, true, true, 2.75f32),
    ]);

    let set_smooth_text = get_set_smooth_rc_text(&font);
    let mut show_texture_atlas = false;
    let mut text_buf = String::from("SFML");

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            if event == Event::Closed {
                window.close();
            }

            match event {
                Event::Closed => window.close(),
                Event::KeyPressed { code, ctrl, .. } => match code {
                    Key::S => {
                        let smooth = !font.is_smooth();
                        font.set_smooth(smooth);
                    }
                    Key::T => {
                        show_texture_atlas ^= true;
                    }
                    Key::V if ctrl => {
                        text_buf.push_str(&clipboard::get_string());
                    }
                    _ => {}
                },
                Event::TextEntered { unicode } if show_texture_atlas => {
                    if unicode == 0x8 as char {
                        text_buf.pop();
                    } else if !unicode.is_ascii_control() && unicode != 's' && unicode != 't' {
                        text_buf.push(unicode);
                    }
                }
                _ => {}
            }
        }

        // Update floating_resource positions so they move around on the screen
        for floating_resource in &mut floating_resources {
            floating_resource.move_resources(Vector2f::new(800f32, 600f32));
            floating_resource.text.set_string(&text_buf);
        }

        window.clear(Color::BLACK);

        // Fetch and draw all the sprites in floating_resources
        for floating_resource in &floating_resources {
            floating_resource.render(&mut window);
        }

        window.draw(&set_smooth_text);
        if show_texture_atlas {
            let scale = 3.0;
            let tex = font.texture(16);
            let mut rs = RectangleShape::with_size(tex.size().as_other());
            rs.set_fill_color(Color::MAGENTA);
            rs.set_scale(scale);
            window.draw(&rs);
            let mut s = Sprite::with_texture(&tex);
            s.set_scale(scale);
            window.draw(&s);
        }
        window.display();
    }
    Ok(())
}

examples/opengl.rs (line 40)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut exit = false;
    let mut srgb = false;

    while !exit {
        let ctx_sett = ContextSettings {
            depth_bits: 24,
            srgb_capable: srgb,
            ..Default::default()
        };

        let mut window = RenderWindow::new(
            (800, 600),
            "SFML graphics with OpenGL",
            Style::default(),
            &ctx_sett,
        )?;
        window.set_vertical_sync_enabled(true);

        let mut bg_tex = Texture::new()?;
        bg_tex.set_srgb(srgb);
        bg_tex.load_from_file("opengl-background.jpg", IntRect::default())?;
        let bg_sprite = Sprite::with_texture(&bg_tex);

        let font = Font::from_file("sansation.ttf")?;
        let mut text = Text::new("SFML / OpenGL demo", &font, 32);
        let mut srgb_instr = Text::new("Press space to toggle sRGB conversion", &font, 32);
        let mut mipmap_instr = Text::new("Press return to toggle mipmapping", &font, 32);
        text.set_fill_color(Color::rgba(255, 255, 255, 170));
        srgb_instr.set_fill_color(Color::rgba(255, 255, 255, 170));
        mipmap_instr.set_fill_color(Color::rgba(255, 255, 255, 170));
        text.set_position((250., 450.));
        srgb_instr.set_position((150., 500.));
        mipmap_instr.set_position((180., 550.));

        let mut texture = Texture::from_file("texture.jpg")?;
        texture.generate_mipmap()?;
        window.set_active(true)?;
        unsafe {
            gl::glEnable(gl::GL_DEPTH_TEST);
            gl::glDepthMask(gl::GL_TRUE as _);
            gl::glClearDepth(1.);
            gl::glDisable(gl::GL_LIGHTING);
            gl::glViewport(0, 0, window.size().x as _, window.size().y as _);
            gl::glMatrixMode(gl::GL_PROJECTION);
            gl::glLoadIdentity();
            let ratio = (window.size().x / window.size().y) as gl::GLdouble;
            gl::glFrustum(-ratio, ratio, -1., 1., 1., 500.);
            gl::glEnable(gl::GL_TEXTURE_2D);
            Texture::bind(&texture);
        }

        let cube: [f32; 180] = [
            -20., -20., -20., 0., 0., -20., 20., -20., 1., 0., -20., -20., 20., 0., 1., -20., -20.,
            20., 0., 1., -20., 20., -20., 1., 0., -20., 20., 20., 1., 1., 20., -20., -20., 0., 0.,
            20., 20., -20., 1., 0., 20., -20., 20., 0., 1., 20., -20., 20., 0., 1., 20., 20., -20.,
            1., 0., 20., 20., 20., 1., 1., -20., -20., -20., 0., 0., 20., -20., -20., 1., 0., -20.,
            -20., 20., 0., 1., -20., -20., 20., 0., 1., 20., -20., -20., 1., 0., 20., -20., 20.,
            1., 1., -20., 20., -20., 0., 0., 20., 20., -20., 1., 0., -20., 20., 20., 0., 1., -20.,
            20., 20., 0., 1., 20., 20., -20., 1., 0., 20., 20., 20., 1., 1., -20., -20., -20., 0.,
            0., 20., -20., -20., 1., 0., -20., 20., -20., 0., 1., -20., 20., -20., 0., 1., 20.,
            -20., -20., 1., 0., 20., 20., -20., 1., 1., -20., -20., 20., 0., 0., 20., -20., 20.,
            1., 0., -20., 20., 20., 0., 1., -20., 20., 20., 0., 1., 20., -20., 20., 1., 0., 20.,
            20., 20., 1., 1.,
        ];

        unsafe {
            gl::glEnableClientState(gl::GL_VERTEX_ARRAY);
            gl::glEnableClientState(gl::GL_TEXTURE_COORD_ARRAY);
            gl::glVertexPointer(
                3,
                gl::GL_FLOAT,
                5 * size_of::<gl::GLfloat>() as i32,
                cube.as_ptr() as *const c_void,
            );
            gl::glTexCoordPointer(
                2,
                gl::GL_FLOAT,
                5 * size_of::<gl::GLfloat>() as i32,
                cube.as_ptr().offset(3) as *const c_void,
            );

            // Disable normal and color vertex components
            gl::glDisableClientState(gl::GL_NORMAL_ARRAY);
            gl::glDisableClientState(gl::GL_COLOR_ARRAY);
        }

        window.set_active(false)?;
        let clock = Clock::start()?;
        let mut mipmap_enabled = true;

        while window.is_open() {
            while let Some(event) = window.poll_event() {
                match event {
                    Event::Closed
                    | Event::KeyPressed {
                        code: Key::Escape, ..
                    } => {
                        exit = true;
                        window.close();
                    }
                    Event::KeyPressed {
                        code: Key::Enter, ..
                    } => {
                        if mipmap_enabled {
                            texture = Texture::from_file("texture.jpg")?;
                            mipmap_enabled = false;
                            window.set_active(true)?;
                            Texture::bind(&texture);
                            window.set_active(false)?;
                        } else {
                            texture.generate_mipmap()?;
                            mipmap_enabled = true;
                        }
                    }
                    Event::KeyPressed {
                        code: Key::Space, ..
                    } => {
                        srgb = !srgb;
                        window.close();
                    }
                    Event::Resized { width, height } => {
                        window.set_active(true)?;
                        unsafe {
                            gl::glViewport(0, 0, width as _, height as _);
                        }
                        window.set_active(false)?;
                    }
                    _ => {}
                }
            }
            window.push_gl_states();
            window.draw(&bg_sprite);
            window.pop_gl_states();

            if let Err(e) = window.set_active(true) {
                eprintln!("Failed to set window as active: {e}");
            }

            unsafe {
                gl::glClear(gl::GL_DEPTH_BUFFER_BIT);
                let x: f32 =
                    window.mouse_position().x as f32 * 200. / window.size().x as f32 - 100.;
                let y: f32 =
                    -window.mouse_position().y as f32 * 200. / window.size().y as f32 + 100.;

                gl::glMatrixMode(gl::GL_MODELVIEW);
                gl::glLoadIdentity();
                gl::glTranslatef(x, y, -100.);
                gl::glRotatef(clock.elapsed_time().as_seconds() * 50., 1., 0., 0.);
                gl::glRotatef(clock.elapsed_time().as_seconds() * 30., 0., 1., 0.);
                gl::glRotatef(clock.elapsed_time().as_seconds() * 90., 0., 0., 1.);
                gl::glDrawArrays(gl::GL_TRIANGLES, 0, 36);
            }
            if let Err(e) = window.set_active(false) {
                eprintln!("Failed to set window as active: {e}");
            }
            window.push_gl_states();
            window.draw(&text);
            window.draw(&srgb_instr);
            window.draw(&mipmap_instr);
            window.pop_gl_states();
            window.display();
        }
    }
    Ok(())
}

pub fn with_texture_and_rect(texture: &'s Texture, rect: IntRect) -> Self

Create a new sprite with a texture and a source rectangle

Examples found in repository

examples/shader.rs (lines 192-195)

    fn new(bg_texture: &'t Texture, entity_texture: &'t Texture) -> SfResult<Self> {
        let mut surface = RenderTexture::new(800, 600)?;
        surface.set_smooth(true);
        let mut bg_sprite = Sprite::with_texture(bg_texture);
        bg_sprite.set_position((135., 100.));
        let mut entities = Vec::new();

        for i in 0..6 {
            entities.push(Sprite::with_texture_and_rect(
                entity_texture,
                IntRect::new(96 * i, 0, 96, 96),
            ));
        }

        let mut shader = Shader::from_file("edge.frag", ShaderType::Fragment)?;
        shader.set_uniform_current_texture("texture")?;

        Ok(Self {
            surface,
            bg_sprite,
            entities,
            shader,
        })
    }

pub fn set_texture(&mut self, texture: &'s Texture, reset_rect: bool)

Change the source texture of a sprite

The texture argument refers to a texture that must exist as long as the sprite uses it. Indeed, the sprite doesn’t store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the sprite tries to use it, the behaviour is undefined. If reset_rect is true, the texture_rect property of the sprite is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

Arguments

• texture - New texture
• reset_rect - Should the texture rect be reset to the size of the new texture?

Examples found in repository

examples/shader.rs (line 31)

    fn new(texture: &'t Texture) -> SfResult<Self> {
        let mut sprite = Sprite::new();
        sprite.set_texture(texture, false);
        Ok(Self {
            sprite,
            shader: Shader::from_file("pixelate.frag", ShaderType::Fragment)?,
        })
    }

examples/borrowed-resources.rs (line 37)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut window = RenderWindow::new(
        (800, 600),
        "Borrowed resources",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    // Create a new texture. (Hey Frank!)
    let frank = Texture::from_file("frank.jpeg")?;

    // Create a font.
    let font = Font::from_file("sansation.ttf")?;

    // Create a circle with the Texture.
    let mut circle = CircleShape::with_texture(&frank);
    circle.set_radius(70.0);
    circle.set_position((100.0, 100.0));

    // Create a Sprite.
    let mut sprite = Sprite::new();
    // Have it use the same texture as the circle.
    sprite.set_texture(&frank, true);
    sprite.set_position((400.0, 300.0));
    sprite.set_scale(0.5);

    // Create a ConvexShape using the same texture.
    let mut convex_shape = ConvexShape::with_texture(6, &frank);
    convex_shape.set_point(0, (400., 100.));
    convex_shape.set_point(1, (500., 70.));
    convex_shape.set_point(2, (450., 100.));
    convex_shape.set_point(3, (580., 150.));
    convex_shape.set_point(4, (420., 230.));
    convex_shape.set_point(5, (420., 120.));

    // Create an initialized text using the font.
    let title = Text::new("Borrowed resources example!", &font, 50);

    // Create a second text using the same font.
    // This time, we create and initialize it separately.
    let mut second_text = Text::default();
    second_text.set_string("This text shares the same font with the title!");
    second_text.set_font(&font);
    second_text.set_fill_color(Color::GREEN);
    second_text.set_position((10.0, 350.0));
    second_text.set_character_size(20);

    // Create a third text using the same font.
    let mut third_text = Text::new("This one too!", &font, 20);
    third_text.set_position((300.0, 100.0));
    third_text.set_fill_color(Color::RED);

    'mainloop: loop {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => break 'mainloop,
                _ => {}
            }
        }

        window.clear(Color::BLACK);
        window.draw(&circle);
        window.draw(&sprite);
        window.draw(&convex_shape);
        window.draw(&title);
        window.draw(&second_text);
        window.draw(&third_text);

        // Little test here for `Shape::points`
        let mut circ = CircleShape::new(4.0, 30);
        circ.set_origin(2.0);
        circ.set_fill_color(Color::YELLOW);

        for p in convex_shape.points() {
            circ.set_position(p);
            window.draw(&circ);
        }

        window.display();
    }
    Ok(())
}

pub fn set_color(&mut self, color: Color)

Set the global color of a sprite

This color is modulated (multiplied) with the sprite’s texture. It can be used to colorize the sprite, or change its global opacity. By default, the sprite’s color is opaque white.

Arguments

• color - New color of the sprite

Examples found in repository

examples/shader.rs (line 345)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut window = RenderWindow::new(
        (800, 600),
        "SFML Shader",
        Style::TITLEBAR | Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let bg = Texture::from_file("background.jpg")?;
    let mut bg_texture = Texture::from_file("sfml.png")?;
    bg_texture.set_smooth(true);
    let mut entity_texture = Texture::from_file("devices.png")?;
    entity_texture.set_smooth(true);
    let logo_texture = Texture::from_file("logo.png")?;
    let effects: [&mut dyn Effect; 5] = [
        &mut Pixelate::new(&bg)?,
        &mut WaveBlur::new(&font)?,
        &mut StormBlink::new()?,
        &mut Edge::new(&bg_texture, &entity_texture)?,
        &mut Geometry::new(&logo_texture)?,
    ];
    let mut current = 0;
    let text_bg_texture = Texture::from_file("text-background.png")?;
    let mut text_bg = Sprite::with_texture(&text_bg_texture);
    text_bg.set_position((0., 520.));
    text_bg.set_color(Color::rgba(255, 255, 255, 200));
    let msg = format!("Current effect: {}", effects[current].name());
    let mut desc = Text::new(&msg, &font, 20);
    desc.set_position((10., 530.));
    desc.set_fill_color(Color::rgb(80, 80, 80));
    let msg = "Press left and right arrows to change the current shader";
    let mut instructions = Text::new(msg, &font, 20);
    instructions.set_position((280., 555.));
    instructions.set_fill_color(Color::rgb(80, 80, 80));
    let clock = Clock::start()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            use crate::Event::*;
            match event {
                Closed => window.close(),
                KeyPressed { code, .. } => match code {
                    Key::Escape => window.close(),
                    Key::Left => {
                        if current == 0 {
                            current = effects.len() - 1;
                        } else {
                            current -= 1;
                        }
                        desc.set_string(&format!("Current effect: {}", effects[current].name()));
                    }
                    Key::Right => {
                        if current == effects.len() - 1 {
                            current = 0;
                        } else {
                            current += 1;
                        }
                        desc.set_string(&format!("Current effect: {}", effects[current].name()));
                    }
                    _ => {}
                },
                _ => {}
            }
        }

        let x = window.mouse_position().x as f32 / window.size().x as f32;
        let y = window.mouse_position().y as f32 / window.size().y as f32;

        effects[current].update(clock.elapsed_time().as_seconds(), x, y)?;

        window.clear(Color::rgb(255, 128, 0));
        window.draw(effects[current]);
        window.draw(&text_bg);
        window.draw(&instructions);
        window.draw(&desc);
        window.display();
    }
    Ok(())
}

pub fn texture(&self) -> Option<&'s Texture>

Get the source texture of a sprite

If the sprite has no source texture, None is returned. You can’t modify the texture when you retrieve it with this function.

Return an Option to the sprite’s texture

pub fn color(&self) -> Color

Get the global color of a sprite

Return the global color of the sprite

pub fn local_bounds(&self) -> FloatRect

Get the local bounding rectangle of a sprite

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, …) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity’s coordinate system.

Return the local bounding rectangle of the entity

pub fn global_bounds(&self) -> FloatRect

Get the global bounding rectangle of a sprite

The returned rectangle is in global coordinates, which means that it takes in account the transformations (translation, rotation, scale, …) that are applied to the entity. In other words, this function returns the bounds of the sprite in the global 2D world’s coordinate system.

Return the global bounding rectangle of the entity

pub fn texture_rect(&self) -> IntRect

Get the sub-rectangle of the texture displayed by a sprite

Return the texture rectangle of the sprite

pub fn set_texture_rect(&mut self, rect: IntRect)

Set the sub-rectangle of the texture that a sprite will display

The texture rect is useful when you don’t want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

Arguments

• rectangle - Rectangle defining the region of the texture to display

Trait Implementations

impl<'s> Clone for Sprite<'s>

fn clone(&self) -> Sprite<'s>

Return a new Sprite or panic! if there is not enough memory

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

Performs copy-assignment from source.

impl<'s> Debug for Sprite<'s>

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

Formats the value using the given formatter.

impl Default for Sprite<'_>

fn default() -> Self

Returns the “default value” for a type.

impl Drawable for Sprite<'_>

fn draw<'a: 'shader, 'texture, 'shader, 'shader_texture>( &'a self, target: &mut dyn RenderTarget, states: &RenderStates<'texture, 'shader, 'shader_texture>, )

Draws into target with RenderStates states.

impl Drop for Sprite<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl Transformable for Sprite<'_>

fn set_position<P: Into<Vector2f>>(&mut self, position: P)

Sets the position of the object.

fn set_rotation(&mut self, angle: f32)

Set the orientation of the object in degrees.

fn set_scale<S: Into<Vector2f>>(&mut self, scale: S)

Sets the scale factors of the object.

fn set_origin<O: Into<Vector2f>>(&mut self, origin: O)

Sets the local origin of the object.

fn position(&self) -> Vector2f

Gets the position of the object.

fn rotation(&self) -> f32

Gets the rotation of the object in degrees.

fn get_scale(&self) -> Vector2f

Gets the current scale of the object.

fn origin(&self) -> Vector2f

Gets the local origin of the object.

fn move_<O: Into<Vector2f>>(&mut self, offset: O)

Moves the object by a given offset.

fn rotate(&mut self, angle: f32)

Rotates the object.

fn scale<F: Into<Vector2f>>(&mut self, factors: F)

Scales the object.

fn transform(&self) -> &Transform

Gets the combined transform of the object.

fn inverse_transform(&self) -> &Transform

Gets the inverse combined transform of the object.