Trait Shape

pub trait Shape<'texture>: Drawable + Transformable {
    // Required methods
    fn set_texture(&mut self, texture: &'texture Texture, reset_rect: bool);
    fn disable_texture(&mut self);
    fn set_texture_rect(&mut self, rect: IntRect);
    fn set_fill_color(&mut self, color: Color);
    fn set_outline_color(&mut self, color: Color);
    fn set_outline_thickness(&mut self, thickness: f32);
    fn texture(&self) -> Option<&'texture Texture>;
    fn texture_rect(&self) -> IntRect;
    fn fill_color(&self) -> Color;
    fn outline_color(&self) -> Color;
    fn outline_thickness(&self) -> f32;
    fn point_count(&self) -> usize;
    fn point(&self, index: usize) -> Vector2f;
    fn local_bounds(&self) -> FloatRect;
    fn global_bounds(&self) -> FloatRect;

    // Provided method
    fn points<'a>(&'a self) -> impl Iterator<Item = Vector2f> + 'a { ... }
}

Trait for textured shapes with outline.

Required Methods

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

Changes the source texture of the shape.

If reset_rect is true, the texture_rect property of the shape is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

fn disable_texture(&mut self)

Disables texturing for this shape.

fn set_texture_rect(&mut self, rect: IntRect)

Sets the sub-rectangle of the texture that the shape 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.

fn set_fill_color(&mut self, color: Color)

Sets the fill color of the shape.

This color is modulated (multiplied) with the shape’s texture if any. It can be used to colorize the shape, or change its global opacity. You can use Color::TRANSPARENT to make the inside of the shape transparent, and have the outline alone. By default, the shape’s fill color is opaque white.

fn set_outline_color(&mut self, color: Color)

Sets the outline color of the shape.

By default, the shape’s outline color is opaque white.

fn set_outline_thickness(&mut self, thickness: f32)

Sets the thickness of the shape’s outline.

Note that negative values are allowed (so that the outline expands towards the center of the shape), and using zero disables the outline. By default, the outline thickness is 0.

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

Gets the source texture of the shape.

If the shape has no source texture, None is returned.

fn texture_rect(&self) -> IntRect

Gets the sub-rectangle of the texture displayed by the shape.

fn fill_color(&self) -> Color

Gets the fill color of this shape.

fn outline_color(&self) -> Color

Gets the outline color of this shape.

fn outline_thickness(&self) -> f32

Gets the outline thickness of this shape.

fn point_count(&self) -> usize

Gets the total number of points of the shape.

fn point(&self, index: usize) -> Vector2f

Gets a point of the shape.

The returned point is in local coordinates, that is, the shape’s transforms (position, rotation, scale) are not taken into account. The result is unspecified if index is out of the valid range (0..point_count()).

fn local_bounds(&self) -> FloatRect

Gets the local bounding rectangle of the entity.

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.

fn global_bounds(&self) -> FloatRect

Gets the global (non-minimal) bounding rectangle of the entity.

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

This function does not necessarily return the minimal bounding rectangle. It merely ensures that the returned rectangle covers all the vertices (but possibly more). This allows for a fast approximation of the bounds as a first check; you may want to use more precise checks on top of that.

Provided Methods

fn points<'a>(&'a self) -> impl Iterator<Item = Vector2f> + 'a

Returns an immutable iterator over all points

Examples found in repository

examples/borrowed-resources.rs (line 91)

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(())
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'s> Shape<'s> for CircleShape<'s>

impl<'s> Shape<'s> for ConvexShape<'s>

impl<'s> Shape<'s> for CustomShape<'s>

impl<'s> Shape<'s> for RectangleShape<'s>