Struct RenderWindow

#[repr(C)]
pub struct RenderWindow { /* private fields */ }

Window that can serve as a target for 2D drawing.

RenderWindow is the main type of the graphics module. It defines an OS window that can be painted using the other classes of the graphics module.

Implementations

impl RenderWindow

Creation

pub fn new<V: Into<VideoMode>, S: SfStrConv>( mode: V, title: S, style: Style, settings: &ContextSettings, ) -> SfResult<FBox<Self>>

Construct a new render window

This function creates the render window with the size and pixel depth defined in mode. An optional style can be passed to customize the look and behaviour of the window (borders, title bar, resizable, closable, …). If style contains Style::FULLSCREEN, then mode must be a valid video mode.

The fourth parameter is a pointer to a structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

Arguments

• mode - Video mode to use (defines the width, height and depth of the rendering area of the render window)
• title - Title of the render window
• style - Window style
• settings - Additional settings for the underlying OpenGL context

Examples found in repository

examples/custom-drawable.rs (lines 42-47)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom drawable",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let bullet = Bullet::new();

    '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(&bullet);
        window.display()
    }
    Ok(())
}

examples/resource-holder.rs (lines 62-67)

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/custom-shape.rs (lines 47-52)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom shape",
        Style::DEFAULT,
        &Default::default(),
    )?;
    let clock = Clock::start()?;
    window.set_vertical_sync_enabled(true);

    let mut shape = CustomShape::new(Box::new(TriangleShape));
    shape.set_position((400., 300.));
    shape.set_origin((400., 300.));
    shape.set_outline_thickness(3.);

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

        let t = clock.elapsed_time().as_seconds();

        shape.set_rotation(t.sin().abs() * 360.0);
        let scale = t.cos().abs();
        shape.set_scale(scale);
        shape.set_fill_color(hue_time(t));
        shape.set_outline_color(hue_time(t / 2.0));
        window.clear(Color::BLACK);
        window.draw(&shape);
        window.display();
    }
    Ok(())
}

examples/vertex-buffers.rs (lines 10-15)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "SFML VertexBuffer accessors Example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertices = vec![
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];
    let mut vertex_buffer = VertexBuffer::new(
        PrimitiveType::LINE_STRIP,
        vertices.len(),
        VertexBufferUsage::DYNAMIC,
    )?;
    vertex_buffer.update(&vertices, 0)?;

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            match e {
                Event::Closed => break 'mainloop,
                Event::MouseButtonPressed {
                    button: Button::Left,
                    x,
                    y,
                } => {
                    vertices.push(Vertex::with_pos_color(
                        (x as f32, y as f32).into(),
                        Color::GREEN,
                    ));
                    vertex_buffer.update(&vertices, 0)?;
                }
                _ => {}
            }
        }
        // Clear the window
        window.clear(Color::BLACK);
        window.draw(&*vertex_buffer);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/vertex-arrays.rs (lines 11-16)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Vertex array example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertex_array = [
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];

    println!("\nIterate over the vertices of a vertex array");
    for v in &vertex_array {
        println!("Vertex Color: {:?} | Position: {:?}", v.color, v.position)
    }

    println!("\nMutable access to a vertex");
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    vertex_array[1].position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    println!("\nImmutable access to a vertex");
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    let vertex = &mut vertex_array[1];
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );
    vertex.position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );

    // Or:
    vertex_array[1] = Vertex::with_pos((20., 40.).into());
    println!("[2] After Vertex Position: {:?}", vertex_array[1].position);
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    let bounds = vertex_array_bounds(&vertex_array);
    let mut bound_rect = RectangleShape::from_rect(bounds);
    bound_rect.set_fill_color(Color::TRANSPARENT);
    bound_rect.set_outline_thickness(1.0);
    bound_rect.set_outline_color(Color::YELLOW);

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            if e == Event::Closed {
                break 'mainloop;
            }
        }
        let rs = RenderStates::default();
        // Clear the window
        window.clear(Color::BLACK);
        window.draw_primitives(&vertex_array, PrimitiveType::LINE_STRIP, &rs);
        window.draw(&bound_rect);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/borrowed-resources.rs (lines 15-20)

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

Additional examples can be found in:

• examples/shader.rs
• examples/rc-resources.rs
• examples/mouse.rs
• examples/window-test.rs
• examples/positional-audio.rs
• examples/spritemark.rs
• examples/unicode-text-entry.rs
• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs
• examples/pong.rs

pub fn recreate<V: Into<VideoMode>, S: SfStrConv>( &mut self, mode: V, title: S, style: Style, settings: &ContextSettings, )

Recreate with new settings. See Self::new for more information.

Examples found in repository

examples/window-test.rs (line 54)

fn main() -> SfResult<()> {
    let configs = [
        WindowConfig {
            mode: (320, 240),
            title: "(Windowed) Retro",
            style: Style::CLOSE,
        },
        WindowConfig {
            mode: (640, 480),
            title: "(Windowed) Classic",
            style: Style::DEFAULT,
        },
        WindowConfig {
            mode: (800, 600),
            title: "(Windowed) Big",
            style: Style::TITLEBAR,
        },
    ];
    let mut cfg_idx = 2usize;
    let mut rw = RenderWindow::new(
        configs[cfg_idx].mode,
        "Window test",
        Style::CLOSE,
        &ContextSettings::default(),
    )?;
    let font = Font::from_memory_static(include_bytes!("resources/sansation.ttf"))?;
    let fs_modes = VideoMode::fullscreen_modes();

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::Up => cfg_idx = cfg_idx.saturating_sub(1),
                    Key::Down => {
                        if cfg_idx + 1 < configs.len() + fs_modes.len() {
                            cfg_idx += 1
                        }
                    }
                    Key::Enter => match configs.get(cfg_idx) {
                        Some(cfg) => {
                            rw.recreate(cfg.mode, cfg.title, cfg.style, &ContextSettings::default())
                        }
                        None => match fs_modes.get(cfg_idx - configs.len()) {
                            Some(mode) => rw.recreate(
                                *mode,
                                "Fullscreen",
                                Style::FULLSCREEN,
                                &ContextSettings::default(),
                            ),
                            None => {
                                eprintln!("Invalid index: {cfg_idx}");
                            }
                        },
                    },
                    _ => {}
                },
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        let fontsize = 16;
        let mut txt = Text::new("Arrow keys to select mode, enter to set.", &font, fontsize);
        rw.draw(&txt);
        let mut y = fontsize as f32;
        for (i, cfg) in configs.iter().enumerate() {
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            txt.set_string(&format!(
                "{}x{} \"{}\" ({:?})",
                cfg.mode.0, cfg.mode.1, cfg.title, cfg.style
            ));
            txt.set_position((0., y));
            rw.draw(&txt);
            y += fontsize as f32;
        }
        let mut i = configs.len();
        y += fontsize as f32;
        txt.set_position((0., y));
        txt.set_fill_color(Color::WHITE);
        txt.set_string("= Fullscreen modes =");
        rw.draw(&txt);
        for mode in fs_modes.iter() {
            let n_rows = 23;
            let column = i / n_rows;
            let row = i % n_rows;
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            let left_pad = 16.0;
            let x = left_pad + (column * 128) as f32;
            let gap = 16.0;
            let y = y + gap + (row * fontsize as usize) as f32;
            txt.set_position((x, y));
            txt.set_string(&format!(
                "{}x{}x{}",
                mode.width, mode.height, mode.bits_per_pixel
            ));
            rw.draw(&txt);
            i += 1;
        }
        rw.display();
    }
    Ok(())
}

pub unsafe fn from_handle( handle: Handle, settings: &ContextSettings, ) -> SfResult<FBox<Self>>

Create a render window from an existing platform-specific window handle

This function creates a render window based on an existing platform specific window handle which has been allocated outside of SFML. This is only intended to be used in cases where you need to integrate SFML with some other windowing library.

Safety

It is the caller’s responsibility to ensure that it is called with a valid window handle.

Arguments

• handle - The handle to the platform-specific window handle to use for the window.
• settings - Additional settings for the underlying OpenGL context

impl RenderWindow

Event handling

pub fn poll_event(&mut self) -> Option<Event>

Pop the event on top of event queue, if any, and return it

This function is not blocking: if there’s no pending event then it will return None. Note that more than one event may be present in the event queue, thus you should always call this function in a loop to make sure that you process every pending event.

Returns Some(event) if an event was returned, or None if the event queue was empty

Examples found in repository

examples/custom-drawable.rs (line 53)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom drawable",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let bullet = Bullet::new();

    '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(&bullet);
        window.display()
    }
    Ok(())
}

examples/resource-holder.rs (line 72)

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/custom-shape.rs (line 62)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom shape",
        Style::DEFAULT,
        &Default::default(),
    )?;
    let clock = Clock::start()?;
    window.set_vertical_sync_enabled(true);

    let mut shape = CustomShape::new(Box::new(TriangleShape));
    shape.set_position((400., 300.));
    shape.set_origin((400., 300.));
    shape.set_outline_thickness(3.);

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

        let t = clock.elapsed_time().as_seconds();

        shape.set_rotation(t.sin().abs() * 360.0);
        let scale = t.cos().abs();
        shape.set_scale(scale);
        shape.set_fill_color(hue_time(t));
        shape.set_outline_color(hue_time(t / 2.0));
        window.clear(Color::BLACK);
        window.draw(&shape);
        window.display();
    }
    Ok(())
}

examples/vertex-buffers.rs (line 34)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "SFML VertexBuffer accessors Example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertices = vec![
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];
    let mut vertex_buffer = VertexBuffer::new(
        PrimitiveType::LINE_STRIP,
        vertices.len(),
        VertexBufferUsage::DYNAMIC,
    )?;
    vertex_buffer.update(&vertices, 0)?;

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            match e {
                Event::Closed => break 'mainloop,
                Event::MouseButtonPressed {
                    button: Button::Left,
                    x,
                    y,
                } => {
                    vertices.push(Vertex::with_pos_color(
                        (x as f32, y as f32).into(),
                        Color::GREEN,
                    ));
                    vertex_buffer.update(&vertices, 0)?;
                }
                _ => {}
            }
        }
        // Clear the window
        window.clear(Color::BLACK);
        window.draw(&*vertex_buffer);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/vertex-arrays.rs (line 75)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Vertex array example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertex_array = [
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];

    println!("\nIterate over the vertices of a vertex array");
    for v in &vertex_array {
        println!("Vertex Color: {:?} | Position: {:?}", v.color, v.position)
    }

    println!("\nMutable access to a vertex");
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    vertex_array[1].position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    println!("\nImmutable access to a vertex");
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    let vertex = &mut vertex_array[1];
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );
    vertex.position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );

    // Or:
    vertex_array[1] = Vertex::with_pos((20., 40.).into());
    println!("[2] After Vertex Position: {:?}", vertex_array[1].position);
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    let bounds = vertex_array_bounds(&vertex_array);
    let mut bound_rect = RectangleShape::from_rect(bounds);
    bound_rect.set_fill_color(Color::TRANSPARENT);
    bound_rect.set_outline_thickness(1.0);
    bound_rect.set_outline_color(Color::YELLOW);

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            if e == Event::Closed {
                break 'mainloop;
            }
        }
        let rs = RenderStates::default();
        // Clear the window
        window.clear(Color::BLACK);
        window.draw_primitives(&vertex_array, PrimitiveType::LINE_STRIP, &rs);
        window.draw(&bound_rect);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/borrowed-resources.rs (line 68)

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

Additional examples can be found in:

• examples/shader.rs
• examples/rc-resources.rs
• examples/mouse.rs
• examples/window-test.rs
• examples/positional-audio.rs
• examples/spritemark.rs
• examples/unicode-text-entry.rs
• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs
• examples/pong.rs

pub fn wait_event(&mut self) -> Option<Event>

Wait for an event and return it

This function is blocking: if there’s no pending event then it will wait until an event is received.

This function is typically used when you have a thread that is dedicated to events handling: you want to make this thread sleep as long as no new event is received.

Returns Some(event) or None if an error has occured

impl RenderWindow

Rendering. See also RenderTarget, which RenderWindow implements.

pub fn display(&mut self)

Display on screen what has been rendered to the window so far

This function is typically called after all OpenGL rendering has been done for the current frame, in order to show it on screen.

Examples found in repository

examples/custom-drawable.rs (line 65)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom drawable",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let bullet = Bullet::new();

    '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(&bullet);
        window.display()
    }
    Ok(())
}

examples/resource-holder.rs (line 83)

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/custom-shape.rs (line 81)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom shape",
        Style::DEFAULT,
        &Default::default(),
    )?;
    let clock = Clock::start()?;
    window.set_vertical_sync_enabled(true);

    let mut shape = CustomShape::new(Box::new(TriangleShape));
    shape.set_position((400., 300.));
    shape.set_origin((400., 300.));
    shape.set_outline_thickness(3.);

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

        let t = clock.elapsed_time().as_seconds();

        shape.set_rotation(t.sin().abs() * 360.0);
        let scale = t.cos().abs();
        shape.set_scale(scale);
        shape.set_fill_color(hue_time(t));
        shape.set_outline_color(hue_time(t / 2.0));
        window.clear(Color::BLACK);
        window.draw(&shape);
        window.display();
    }
    Ok(())
}

examples/vertex-buffers.rs (line 55)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "SFML VertexBuffer accessors Example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertices = vec![
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];
    let mut vertex_buffer = VertexBuffer::new(
        PrimitiveType::LINE_STRIP,
        vertices.len(),
        VertexBufferUsage::DYNAMIC,
    )?;
    vertex_buffer.update(&vertices, 0)?;

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            match e {
                Event::Closed => break 'mainloop,
                Event::MouseButtonPressed {
                    button: Button::Left,
                    x,
                    y,
                } => {
                    vertices.push(Vertex::with_pos_color(
                        (x as f32, y as f32).into(),
                        Color::GREEN,
                    ));
                    vertex_buffer.update(&vertices, 0)?;
                }
                _ => {}
            }
        }
        // Clear the window
        window.clear(Color::BLACK);
        window.draw(&*vertex_buffer);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/vertex-arrays.rs (line 86)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Vertex array example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertex_array = [
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];

    println!("\nIterate over the vertices of a vertex array");
    for v in &vertex_array {
        println!("Vertex Color: {:?} | Position: {:?}", v.color, v.position)
    }

    println!("\nMutable access to a vertex");
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    vertex_array[1].position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    println!("\nImmutable access to a vertex");
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    let vertex = &mut vertex_array[1];
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );
    vertex.position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );

    // Or:
    vertex_array[1] = Vertex::with_pos((20., 40.).into());
    println!("[2] After Vertex Position: {:?}", vertex_array[1].position);
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    let bounds = vertex_array_bounds(&vertex_array);
    let mut bound_rect = RectangleShape::from_rect(bounds);
    bound_rect.set_fill_color(Color::TRANSPARENT);
    bound_rect.set_outline_thickness(1.0);
    bound_rect.set_outline_color(Color::YELLOW);

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            if e == Event::Closed {
                break 'mainloop;
            }
        }
        let rs = RenderStates::default();
        // Clear the window
        window.clear(Color::BLACK);
        window.draw_primitives(&vertex_array, PrimitiveType::LINE_STRIP, &rs);
        window.draw(&bound_rect);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/borrowed-resources.rs (line 96)

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

Additional examples can be found in:

• examples/shader.rs
• examples/rc-resources.rs
• examples/mouse.rs
• examples/window-test.rs
• examples/positional-audio.rs
• examples/spritemark.rs
• examples/unicode-text-entry.rs
• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs
• examples/pong.rs

pub fn set_framerate_limit(&mut self, limit: u32)

Limit the framerate to a maximum fixed frequency

If a limit is set, the window will use a small delay after each call to RenderWindow::display to ensure that the current frame lasted long enough to match the framerate limit.

Arguments

• limit - Framerate limit, in frames per seconds (use 0 to disable limit)

Examples found in repository

examples/rc-resources.rs (line 126)

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

pub fn settings(&self) -> &ContextSettings

Get the settings of the OpenGL context of a window

Note that these settings may be different from what was passed to the RenderWindow::new function, if one or more settings were not supported. In this case, SFML chose the closest match.

Return a structure containing the OpenGL context settings

Examples found in repository

examples/pong.rs (line 53)

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

    let mut rng = thread_rng();

    // Optional antialiasing
    let mut aa_level = 0;

    if let Some(arg) = env::args().nth(1) {
        match arg.parse::<u32>() {
            Ok(arg_as_num) => aa_level = arg_as_num,
            Err(e) => println!("Didn't set AA level: {e}"),
        }
    }

    // Define some constants
    let game_width = 800;
    let game_height = 600;
    let paddle_size = Vector2f::new(25., 100.);
    let ball_radius = 10.;

    // Create the window of the application
    let context_settings = ContextSettings {
        antialiasing_level: aa_level,
        ..Default::default()
    };
    let mut window = RenderWindow::new(
        (game_width, game_height),
        "SFML Pong",
        Style::CLOSE,
        &context_settings,
    )?;
    let context_settings = window.settings();
    if context_settings.antialiasing_level > 0 {
        println!("Using {}xAA", context_settings.antialiasing_level);
    }
    window.set_vertical_sync_enabled(true);

    // Load the sounds used in the game
    let ball_soundbuffer = SoundBuffer::from_file("ball.wav")?;
    let mut ball_sound = Sound::with_buffer(&ball_soundbuffer);

    // Create the left paddle
    let mut left_paddle = RectangleShape::new();
    left_paddle.set_size(paddle_size - Vector2f::new(3., 3.));
    left_paddle.set_outline_thickness(3.);
    left_paddle.set_outline_color(Color::BLACK);
    left_paddle.set_fill_color(Color::rgb(100, 100, 200));
    left_paddle.set_origin(paddle_size / 2.);

    // Create the right paddle
    let mut right_paddle = RectangleShape::new();
    right_paddle.set_size(paddle_size - Vector2f::new(3., 3.));
    right_paddle.set_outline_thickness(3.);
    right_paddle.set_outline_color(Color::BLACK);
    right_paddle.set_fill_color(Color::rgb(200, 100, 100));
    right_paddle.set_origin(paddle_size / 2.);

    // Create the ball
    let mut ball = CircleShape::default();
    ball.set_radius(ball_radius - 3.);
    ball.set_outline_thickness(3.);
    ball.set_outline_color(Color::BLACK);
    ball.set_fill_color(Color::WHITE);
    ball.set_origin(ball_radius / 2.);

    // Load the text font
    let font = Font::from_file("sansation.ttf")?;

    // Initialize the pause message
    let mut pause_message = Text::default();
    pause_message.set_font(&font);
    pause_message.set_character_size(40);
    pause_message.set_position((170., 150.));
    pause_message.set_fill_color(Color::WHITE);
    pause_message.set_string("Welcome to SFML pong!\nPress space to start the game");

    // Define the paddles properties
    let mut ai_timer = Clock::start()?;
    let paddle_speed = 400.;
    let mut right_paddle_speed = 0.;
    let mut ball_speed = 400.;
    let mut ball_angle = 0.;

    let mut clock = Clock::start()?;
    let mut is_playing = false;
    let mut up = false;
    let mut down = false;

    'mainloop: loop {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => break 'mainloop,
                Event::KeyPressed {
                    code: Key::Space, ..
                } if !is_playing => {
                    // (re)start the game
                    is_playing = true;
                    ball_speed = 400.0;
                    ball_sound.set_pitch(1.0);
                    clock.restart();
                    // Reset the position of the paddles and ball
                    left_paddle.set_position((10. + paddle_size.x / 2., game_height as f32 / 2.));
                    right_paddle.set_position((
                        game_width as f32 - 10. - paddle_size.x / 2.,
                        game_height as f32 / 2.,
                    ));
                    ball.set_position((game_width as f32 / 2., game_height as f32 / 2.));
                    // Reset the ball angle
                    loop {
                        // Make sure the ball initial angle is not too much vertical
                        ball_angle = rng.gen_range(0.0..360.) * 2. * PI / 360.;

                        if ball_angle.cos().abs() >= 0.7 {
                            break;
                        }
                    }
                }
                Event::KeyPressed { code: Key::Up, .. }
                | Event::KeyPressed {
                    scan: Scancode::W, ..
                } => up = true,
                Event::KeyReleased { code: Key::Up, .. }
                | Event::KeyReleased {
                    scan: Scancode::W, ..
                } => up = false,
                Event::KeyPressed {
                    code: Key::Down, ..
                }
                | Event::KeyPressed {
                    scan: Scancode::S, ..
                } => down = true,
                Event::KeyReleased {
                    code: Key::Down, ..
                }
                | Event::KeyReleased {
                    scan: Scancode::S, ..
                } => down = false,
                _ => {}
            }
        }
        if is_playing {
            let delta_time = clock.restart().as_seconds();

            // Move the player's paddle
            if up && (left_paddle.position().y - paddle_size.y / 2. > 5.) {
                left_paddle.move_((0., -paddle_speed * delta_time));
            }
            if down && (left_paddle.position().y + paddle_size.y / 2. < game_height as f32 - 5.) {
                left_paddle.move_((0., paddle_speed * delta_time));
            }

            // Move the computer's paddle
            if ((right_paddle_speed < 0.) && (right_paddle.position().y - paddle_size.y / 2. > 5.))
                || ((right_paddle_speed > 0.)
                    && (right_paddle.position().y + paddle_size.y / 2. < game_height as f32 - 5.))
            {
                right_paddle.move_((0., right_paddle_speed * delta_time));
            }

            // Update the computer's paddle direction according to the ball position
            if ai_timer.elapsed_time() > AI_REACT_DELAY {
                ai_timer.restart();
                if ball.position().y + ball_radius > right_paddle.position().y + paddle_size.y / 2.
                {
                    right_paddle_speed = paddle_speed;
                } else if ball.position().y - ball_radius
                    < right_paddle.position().y - paddle_size.y / 2.
                {
                    right_paddle_speed = -paddle_speed;
                } else {
                    right_paddle_speed = 0.;
                }
            }

            // Move the ball
            let factor = ball_speed * delta_time;
            ball.move_((ball_angle.cos() * factor, ball_angle.sin() * factor));

            // Check collisions between the ball and the screen
            if ball.position().x - ball_radius < 0. {
                is_playing = false;
                pause_message.set_string("You lost !\nPress space to restart or\nescape to exit");
            }
            if ball.position().x + ball_radius > game_width as f32 {
                is_playing = false;
                pause_message.set_string("You won !\nPress space to restart or\nescape to exit");
            }
            if ball.position().y - ball_radius < 0. {
                on_bounce(&mut ball_sound, &mut ball_speed);
                ball_angle = -ball_angle;
                let p = ball.position().x;
                ball.set_position((p, ball_radius + 0.1));
            }
            if ball.position().y + ball_radius > game_height as f32 {
                on_bounce(&mut ball_sound, &mut ball_speed);
                ball_angle = -ball_angle;
                let p = ball.position().x;
                ball.set_position((p, game_height as f32 - ball_radius - 0.1));
            }

            // Check the collisions between the ball and the paddles
            // Left Paddle
            let (ball_pos, paddle_pos) = (ball.position(), left_paddle.position());
            if ball_pos.x - ball_radius < paddle_pos.x + paddle_size.x / 2.
                && ball_pos.y + ball_radius >= paddle_pos.y - paddle_size.y / 2.
                && ball_pos.y - ball_radius <= paddle_pos.y + paddle_size.y / 2.
            {
                if ball_pos.y > paddle_pos.y {
                    ball_angle = PI - ball_angle + rng.gen_range(0.0..20.) * PI / 180.;
                } else {
                    ball_angle = PI - ball_angle - rng.gen_range(0.0..20.) * PI / 180.;
                }

                on_bounce(&mut ball_sound, &mut ball_speed);
                ball.set_position((
                    paddle_pos.x + ball_radius + paddle_size.x / 2. + 0.1,
                    ball_pos.y,
                ));
            }

            // Right Paddle
            let (ball_pos, paddle_pos) = (ball.position(), right_paddle.position());
            if ball_pos.x + ball_radius > paddle_pos.x - paddle_size.x / 2.
                && ball_pos.y + ball_radius >= paddle_pos.y - paddle_size.y / 2.
                && ball_pos.y - ball_radius <= paddle_pos.y + paddle_size.y / 2.
            {
                if ball_pos.y > paddle_pos.y {
                    ball_angle = PI - ball_angle + rng.gen_range(0.0..20.) * PI / 180.;
                } else {
                    ball_angle = PI - ball_angle - rng.gen_range(0.0..20.) * PI / 180.;
                }

                on_bounce(&mut ball_sound, &mut ball_speed);
                ball.set_position((
                    paddle_pos.x - ball_radius - paddle_size.x / 2. - 0.1,
                    ball_pos.y,
                ));
            }
        }
        // Clear the window
        window.clear(Color::rgb(50, 200, 50));

        if is_playing {
            // Draw the paddles and the ball
            window.draw(&left_paddle);
            window.draw(&right_paddle);
            window.draw(&ball);
        } else {
            // Draw the pause message
            window.draw(&pause_message);
        }

        // Display things on screen
        window.display()
    }
    Ok(())
}

pub fn is_srgb(&self) -> bool

Tell if the render texture will use sRGB encoding when drawing it

Returns true if sRGB encoding is enabled, false if sRGB encoding is disabled

pub fn set_vertical_sync_enabled(&mut self, enabled: bool)

Enable or disable vertical synchronization

Activating vertical synchronization will limit the number of frames displayed to the refresh rate of the monitor. This can avoid some visual artifacts, and limit the framerate to a good value (but not constant across different computers).

Arguments

• enabled - true to enable v-sync, false to deactivate

Examples found in repository

examples/custom-drawable.rs (line 48)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom drawable",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let bullet = Bullet::new();

    '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(&bullet);
        window.display()
    }
    Ok(())
}

examples/resource-holder.rs (line 68)

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/custom-shape.rs (line 54)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Custom shape",
        Style::DEFAULT,
        &Default::default(),
    )?;
    let clock = Clock::start()?;
    window.set_vertical_sync_enabled(true);

    let mut shape = CustomShape::new(Box::new(TriangleShape));
    shape.set_position((400., 300.));
    shape.set_origin((400., 300.));
    shape.set_outline_thickness(3.);

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

        let t = clock.elapsed_time().as_seconds();

        shape.set_rotation(t.sin().abs() * 360.0);
        let scale = t.cos().abs();
        shape.set_scale(scale);
        shape.set_fill_color(hue_time(t));
        shape.set_outline_color(hue_time(t / 2.0));
        window.clear(Color::BLACK);
        window.draw(&shape);
        window.display();
    }
    Ok(())
}

examples/vertex-buffers.rs (line 16)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "SFML VertexBuffer accessors Example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertices = vec![
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];
    let mut vertex_buffer = VertexBuffer::new(
        PrimitiveType::LINE_STRIP,
        vertices.len(),
        VertexBufferUsage::DYNAMIC,
    )?;
    vertex_buffer.update(&vertices, 0)?;

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            match e {
                Event::Closed => break 'mainloop,
                Event::MouseButtonPressed {
                    button: Button::Left,
                    x,
                    y,
                } => {
                    vertices.push(Vertex::with_pos_color(
                        (x as f32, y as f32).into(),
                        Color::GREEN,
                    ));
                    vertex_buffer.update(&vertices, 0)?;
                }
                _ => {}
            }
        }
        // Clear the window
        window.clear(Color::BLACK);
        window.draw(&*vertex_buffer);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/vertex-arrays.rs (line 17)

fn main() -> SfResult<()> {
    let mut window = RenderWindow::new(
        (800, 600),
        "Vertex array example",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_vertical_sync_enabled(true);

    let mut vertex_array = [
        Vertex::with_pos_color((20.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((30.0, 30.0).into(), Color::GREEN),
        Vertex::with_pos_color((40.0, 40.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 50.0).into(), Color::GREEN),
        Vertex::with_pos_color((60.0, 60.0).into(), Color::GREEN),
        Vertex::with_pos_color((50.0, 80.0).into(), Color::GREEN),
    ];

    println!("\nIterate over the vertices of a vertex array");
    for v in &vertex_array {
        println!("Vertex Color: {:?} | Position: {:?}", v.color, v.position)
    }

    println!("\nMutable access to a vertex");
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    vertex_array[1].position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    println!("\nImmutable access to a vertex");
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );

    let vertex = &mut vertex_array[1];
    println!(
        "Before Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );
    vertex.position.x = 100.0;
    println!(
        "After Vertex Color: {:?} | Position: {:?}",
        vertex.color, vertex.position
    );

    // Or:
    vertex_array[1] = Vertex::with_pos((20., 40.).into());
    println!("[2] After Vertex Position: {:?}", vertex_array[1].position);
    println!(
        "Vertex Color: {:?} | Position: {:?}",
        vertex_array[1].color, vertex_array[1].position
    );
    let bounds = vertex_array_bounds(&vertex_array);
    let mut bound_rect = RectangleShape::from_rect(bounds);
    bound_rect.set_fill_color(Color::TRANSPARENT);
    bound_rect.set_outline_thickness(1.0);
    bound_rect.set_outline_color(Color::YELLOW);

    'mainloop: loop {
        while let Some(e) = window.poll_event() {
            if e == Event::Closed {
                break 'mainloop;
            }
        }
        let rs = RenderStates::default();
        // Clear the window
        window.clear(Color::BLACK);
        window.draw_primitives(&vertex_array, PrimitiveType::LINE_STRIP, &rs);
        window.draw(&bound_rect);
        // Display things on screen
        window.display()
    }
    Ok(())
}

examples/borrowed-resources.rs (line 21)

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

Additional examples can be found in:

• examples/shader.rs
• examples/mouse.rs
• examples/positional-audio.rs
• examples/spritemark.rs
• examples/unicode-text-entry.rs
• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs
• examples/pong.rs

pub fn set_active(&mut self, enabled: bool) -> SfResult<()>

Activate or deactivate a render window as the current target for OpenGL rendering

A window is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one window can be active on a thread at a time, thus the window previously active (if any) automatically gets deactivated.

Arguments

• active - true to activate, false to deactivate

Examples found in repository

examples/opengl.rs (line 55)

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

impl RenderWindow

Input

pub fn set_mouse_cursor_visible(&mut self, visible: bool)

Show or hide the mouse cursor

Arguments

• visible - true to false to hide

Examples found in repository

examples/mouse.rs (line 14)

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

    let mut window = RenderWindow::new(
        (800, 600),
        "Mouse events",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_mouse_cursor_visible(false);
    window.set_vertical_sync_enabled(true);

    let font = Font::from_file("sansation.ttf")?;
    let mut circle = CircleShape::new(4., 30);
    let mut texts: Vec<Text> = Vec::new();
    let mut mp_text = Text::new("", &font, 14);
    let mut cursor_visible = false;
    let mut grabbed = false;
    macro_rules! push_text {
        ($x:expr, $y:expr, $fmt:expr, $($arg:tt)*) => {
            let mut text = Text::new(&format!($fmt, $($arg)*), &font, 14);
            text.set_position(($x as f32, $y as f32));
            texts.push(text);
        }
    }

    'mainloop: loop {
        while let Some(ev) = window.poll_event() {
            match ev {
                Event::Closed => break 'mainloop,
                Event::MouseWheelScrolled { wheel, delta, x, y } => {
                    push_text!(x, y, "Scroll: {:?}, {}, {}, {}", wheel, delta, x, y);
                }
                Event::MouseButtonPressed { button, x, y } => {
                    push_text!(x, y, "Press: {:?}, {}, {}", button, x, y);
                }
                Event::MouseButtonReleased { button, x, y } => {
                    push_text!(x, y, "Release: {:?}, {}, {}", button, x, y);
                }
                Event::KeyPressed { code, .. } => {
                    if code == Key::W {
                        window.set_mouse_position(Vector2i::new(400, 300));
                    } else if code == Key::D {
                        let dm = VideoMode::desktop_mode();
                        let center = Vector2i::new(dm.width as i32 / 2, dm.height as i32 / 2);
                        mouse::set_desktop_position(center);
                    } else if code == Key::V {
                        cursor_visible = !cursor_visible;
                        window.set_mouse_cursor_visible(cursor_visible);
                    } else if code == Key::G {
                        grabbed = !grabbed;
                        window.set_mouse_cursor_grabbed(grabbed);
                    }
                }
                _ => {}
            }
        }

        let mp = window.mouse_position();
        let dmp = mouse::desktop_position();
        let cur_vis_msg = if cursor_visible {
            "visible"
        } else {
            "invisible"
        };
        let grab_msg = if grabbed { "grabbed" } else { "not grabbed" };
        mp_text.set_string(&format!(
            "x: {}, y: {} (Window)\n\
             x: {}, y: {} (Desktop)\n\
             [{cur_vis_msg}] [{grab_msg}] ('V'/'G') to toggle\n\
             'W' to center mouse on window\n\
             'D' to center mouse on desktop",
            mp.x, mp.y, dmp.x, dmp.y
        ));

        circle.set_position((mp.x as f32, mp.y as f32));

        window.clear(Color::BLACK);
        // Push texts out of each other's way
        for i in (0..texts.len()).rev() {
            for j in (0..i).rev() {
                if let Some(intersect) = texts[i]
                    .global_bounds()
                    .intersection(&texts[j].global_bounds())
                {
                    texts[j].move_((0., -intersect.height));
                }
            }
        }
        texts.retain(|txt| txt.fill_color().a > 0);
        for txt in &mut texts {
            let mut color = txt.fill_color();
            color.a -= 1;
            txt.set_fill_color(color);
            window.draw(txt);
        }
        if !cursor_visible {
            window.draw(&circle);
        }
        window.draw(&mp_text);
        window.display();
    }
    Ok(())
}

pub fn set_mouse_cursor_grabbed(&mut self, grabbed: bool)

Grab or release the mouse cursor.

If set, grabs the mouse cursor inside this window’s client area so it may no longer be moved outside its bounds. Note that grabbing is only active while the window has focus.

Examples found in repository

examples/mouse.rs (line 56)

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

    let mut window = RenderWindow::new(
        (800, 600),
        "Mouse events",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_mouse_cursor_visible(false);
    window.set_vertical_sync_enabled(true);

    let font = Font::from_file("sansation.ttf")?;
    let mut circle = CircleShape::new(4., 30);
    let mut texts: Vec<Text> = Vec::new();
    let mut mp_text = Text::new("", &font, 14);
    let mut cursor_visible = false;
    let mut grabbed = false;
    macro_rules! push_text {
        ($x:expr, $y:expr, $fmt:expr, $($arg:tt)*) => {
            let mut text = Text::new(&format!($fmt, $($arg)*), &font, 14);
            text.set_position(($x as f32, $y as f32));
            texts.push(text);
        }
    }

    'mainloop: loop {
        while let Some(ev) = window.poll_event() {
            match ev {
                Event::Closed => break 'mainloop,
                Event::MouseWheelScrolled { wheel, delta, x, y } => {
                    push_text!(x, y, "Scroll: {:?}, {}, {}, {}", wheel, delta, x, y);
                }
                Event::MouseButtonPressed { button, x, y } => {
                    push_text!(x, y, "Press: {:?}, {}, {}", button, x, y);
                }
                Event::MouseButtonReleased { button, x, y } => {
                    push_text!(x, y, "Release: {:?}, {}, {}", button, x, y);
                }
                Event::KeyPressed { code, .. } => {
                    if code == Key::W {
                        window.set_mouse_position(Vector2i::new(400, 300));
                    } else if code == Key::D {
                        let dm = VideoMode::desktop_mode();
                        let center = Vector2i::new(dm.width as i32 / 2, dm.height as i32 / 2);
                        mouse::set_desktop_position(center);
                    } else if code == Key::V {
                        cursor_visible = !cursor_visible;
                        window.set_mouse_cursor_visible(cursor_visible);
                    } else if code == Key::G {
                        grabbed = !grabbed;
                        window.set_mouse_cursor_grabbed(grabbed);
                    }
                }
                _ => {}
            }
        }

        let mp = window.mouse_position();
        let dmp = mouse::desktop_position();
        let cur_vis_msg = if cursor_visible {
            "visible"
        } else {
            "invisible"
        };
        let grab_msg = if grabbed { "grabbed" } else { "not grabbed" };
        mp_text.set_string(&format!(
            "x: {}, y: {} (Window)\n\
             x: {}, y: {} (Desktop)\n\
             [{cur_vis_msg}] [{grab_msg}] ('V'/'G') to toggle\n\
             'W' to center mouse on window\n\
             'D' to center mouse on desktop",
            mp.x, mp.y, dmp.x, dmp.y
        ));

        circle.set_position((mp.x as f32, mp.y as f32));

        window.clear(Color::BLACK);
        // Push texts out of each other's way
        for i in (0..texts.len()).rev() {
            for j in (0..i).rev() {
                if let Some(intersect) = texts[i]
                    .global_bounds()
                    .intersection(&texts[j].global_bounds())
                {
                    texts[j].move_((0., -intersect.height));
                }
            }
        }
        texts.retain(|txt| txt.fill_color().a > 0);
        for txt in &mut texts {
            let mut color = txt.fill_color();
            color.a -= 1;
            txt.set_fill_color(color);
            window.draw(txt);
        }
        if !cursor_visible {
            window.draw(&circle);
        }
        window.draw(&mp_text);
        window.display();
    }
    Ok(())
}

pub fn set_key_repeat_enabled(&mut self, enabled: bool)

Enable or disable automatic key-repeat

If key repeat is enabled, you will receive repeated crate::window::Event::KeyPressed events while keeping a key pressed. If it is disabled, you will only get a single event when the key is pressed.

Key repeat is enabled by default.

Arguments

• enabled - true to enable, false to disable

pub fn set_joystick_threshold(&mut self, threshold: f32)

Change the joystick threshold

The joystick threshold is the value below which no crate::window::Event::JoystickMoved event will be generated.

Arguments

• threshold - New threshold, in the range [0, 100]

pub fn mouse_position(&self) -> Vector2i

Returns the current position of the mouse relative to the window.

Examples found in repository

examples/shader.rs (line 324)

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 effects: [&mut dyn Effect; 4] = [
        &mut Pixelate::new(&bg)?,
        &mut WaveBlur::new(&font)?,
        &mut StormBlink::new()?,
        &mut Edge::new(&bg_texture, &entity_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].as_drawable());
        window.draw(&text_bg);
        window.draw(&instructions);
        window.draw(&desc);
        window.display();
    }
    Ok(())
}

examples/mouse.rs (line 63)

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

    let mut window = RenderWindow::new(
        (800, 600),
        "Mouse events",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_mouse_cursor_visible(false);
    window.set_vertical_sync_enabled(true);

    let font = Font::from_file("sansation.ttf")?;
    let mut circle = CircleShape::new(4., 30);
    let mut texts: Vec<Text> = Vec::new();
    let mut mp_text = Text::new("", &font, 14);
    let mut cursor_visible = false;
    let mut grabbed = false;
    macro_rules! push_text {
        ($x:expr, $y:expr, $fmt:expr, $($arg:tt)*) => {
            let mut text = Text::new(&format!($fmt, $($arg)*), &font, 14);
            text.set_position(($x as f32, $y as f32));
            texts.push(text);
        }
    }

    'mainloop: loop {
        while let Some(ev) = window.poll_event() {
            match ev {
                Event::Closed => break 'mainloop,
                Event::MouseWheelScrolled { wheel, delta, x, y } => {
                    push_text!(x, y, "Scroll: {:?}, {}, {}, {}", wheel, delta, x, y);
                }
                Event::MouseButtonPressed { button, x, y } => {
                    push_text!(x, y, "Press: {:?}, {}, {}", button, x, y);
                }
                Event::MouseButtonReleased { button, x, y } => {
                    push_text!(x, y, "Release: {:?}, {}, {}", button, x, y);
                }
                Event::KeyPressed { code, .. } => {
                    if code == Key::W {
                        window.set_mouse_position(Vector2i::new(400, 300));
                    } else if code == Key::D {
                        let dm = VideoMode::desktop_mode();
                        let center = Vector2i::new(dm.width as i32 / 2, dm.height as i32 / 2);
                        mouse::set_desktop_position(center);
                    } else if code == Key::V {
                        cursor_visible = !cursor_visible;
                        window.set_mouse_cursor_visible(cursor_visible);
                    } else if code == Key::G {
                        grabbed = !grabbed;
                        window.set_mouse_cursor_grabbed(grabbed);
                    }
                }
                _ => {}
            }
        }

        let mp = window.mouse_position();
        let dmp = mouse::desktop_position();
        let cur_vis_msg = if cursor_visible {
            "visible"
        } else {
            "invisible"
        };
        let grab_msg = if grabbed { "grabbed" } else { "not grabbed" };
        mp_text.set_string(&format!(
            "x: {}, y: {} (Window)\n\
             x: {}, y: {} (Desktop)\n\
             [{cur_vis_msg}] [{grab_msg}] ('V'/'G') to toggle\n\
             'W' to center mouse on window\n\
             'D' to center mouse on desktop",
            mp.x, mp.y, dmp.x, dmp.y
        ));

        circle.set_position((mp.x as f32, mp.y as f32));

        window.clear(Color::BLACK);
        // Push texts out of each other's way
        for i in (0..texts.len()).rev() {
            for j in (0..i).rev() {
                if let Some(intersect) = texts[i]
                    .global_bounds()
                    .intersection(&texts[j].global_bounds())
                {
                    texts[j].move_((0., -intersect.height));
                }
            }
        }
        texts.retain(|txt| txt.fill_color().a > 0);
        for txt in &mut texts {
            let mut color = txt.fill_color();
            color.a -= 1;
            txt.set_fill_color(color);
            window.draw(txt);
        }
        if !cursor_visible {
            window.draw(&circle);
        }
        window.draw(&mp_text);
        window.display();
    }
    Ok(())
}

examples/positional-audio.rs (line 95)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    let mut rw = RenderWindow::new(
        (800, 600),
        "Positional audio demo",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let mut text = Text::new("", &font, 20);
    let mut music = match std::env::args().nth(1) {
        Some(music_path) => Music::from_file(&music_path)?,
        None => Music::from_file("canary.wav")?,
    };
    if music.channel_count() != 1 {
        return Err("Sorry, only sounds with 1 channel are supported.".into());
    };
    music.set_looping(true);
    music.play();
    music.set_position(Vector3::new(0., 0., 0.));

    let mut listener_pos = Vector3::new(0.0, 0.0, 0.0);
    let center = Vector2::new(400., 300.);
    let [mut go_left, mut go_right, mut go_up, mut go_down] = [false; 4];
    let clock = Clock::start()?;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::A => go_left = true,
                    Key::D => go_right = true,
                    Key::W => go_up = true,
                    Key::S => go_down = true,
                    _ => {}
                },
                Event::KeyReleased { code, .. } => match code {
                    Key::A => go_left = false,
                    Key::D => go_right = false,
                    Key::W => go_up = false,
                    Key::S => go_down = false,
                    _ => {}
                },
                _ => {}
            }
        }
        let Vector2f { x: mx, y: my } = rw.mouse_position().as_other();
        let speed = 0.05;
        if go_left {
            listener_pos.x -= speed;
        }
        if go_right {
            listener_pos.x += speed;
        }
        if go_up {
            listener_pos.y -= speed;
        }
        if go_down {
            listener_pos.y += speed;
        }
        let scale = 20.0; // Scale the positions for better visualization
        listener::set_position(listener_pos);
        listener::set_direction(Vector3::new(
            (mx - center.x) / scale,
            (my - center.y) / scale,
            -1.,
        ));
        let Vector3 {
            x: lx,
            y: ly,
            z: lz,
        } = listener::position();
        let Vector3 {
            x: dx,
            y: dy,
            z: dz,
        } = listener::direction();
        rw.clear(Color::BLACK);
        let mut circle_shape = CircleShape::new(8.0, 32);
        // Draw circle at center, representing position of music being played
        circle_shape.set_position(center);
        circle_shape.set_fill_color(Color::YELLOW);
        let t = clock.elapsed_time().as_seconds();
        let radius = 12.0 + t.sin() * 3.0;
        circle_shape.set_radius(radius);
        circle_shape.set_origin(radius);
        rw.draw(&circle_shape);
        // Draw circle representing listener
        circle_shape.set_position((center.x + lx * scale, center.y + ly * scale));
        circle_shape.set_origin(4.0);
        circle_shape.set_radius(4.0);
        circle_shape.set_fill_color(Color::GREEN);
        rw.draw(&circle_shape);
        // Draw line from listener to direction vector position
        rw.draw_line(
            circle_shape.position(),
            (center.x + dx * scale, center.y + dy * scale).into(),
            2.0,
        );
        text.set_string("WASD + mouse for movement of listener");
        text.set_position(0.);
        rw.draw(&text);
        text.set_string(&format!("Listener position: {lx}, {ly}, {lz}"));
        text.set_position((0., 20.0));
        rw.draw(&text);
        text.set_string(&format!("Listener direction: {dx}, {dy}, {dz}"));
        text.set_position((0., 40.0));
        rw.draw(&text);
        rw.display();
    }
    Ok(())
}

examples/spritemark.rs (line 119)

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

    let native_mode = VideoMode::desktop_mode();
    let mut window = RenderWindow::new(
        native_mode,
        "Spritemark",
        Style::default(),
        &ContextSettings::default(),
    )?;
    window.set_position(Vector2::new(0, 0));
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let texture = Texture::from_file("devices.png")?;
    let mut text = Text::new("", &font, 18);
    text.set_outline_color(Color::BLACK);
    text.set_outline_thickness(1.0);
    let mut click_counter = 0;
    let mut objects = Vec::new();
    let mut rng = thread_rng();
    let mut rs = RenderStates::default();
    let mut buf = Vec::new();
    let mut frames_rendered = 0;
    let mut sec_clock = Clock::start()?;
    let mut fps = 0;
    let mut lmb_down = false;
    let mut view = View::new()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => window.close(),
                Event::MouseButtonPressed {
                    button: Button::Left,
                    ..
                } => {
                    click_counter += 1;
                    lmb_down = true;
                }
                Event::MouseButtonReleased {
                    button: Button::Left,
                    ..
                } => {
                    lmb_down = false;
                }
                Event::Resized { width, height } => {
                    view.reset(Rect::new(0., 0., width as f32, height as f32));
                    window.set_view(&view);
                }
                _ => {}
            }
        }

        if lmb_down {
            let mp = window.mouse_position();
            for _ in 0..25 {
                objects.push(Object {
                    position: fconv(mp),
                    speed: Vector2f::new(rng.gen_range(-3.0..3.0), 0.0),
                    image_id: click_counter % N_IMAGES,
                    angle: 0.0,
                    rot_speed: rng.gen_range(-2.0..2.0),
                });
            }
        }

        for obj in &mut objects {
            let size = f32::from(SUBIMAGE_SIZE);
            let tex_x = f32::from(obj.image_id) * size;
            let mut tf = Transform::default();
            tf.translate(obj.position.x, obj.position.y);
            tf.rotate_with_center(obj.angle, size / 2.0, size / 2.0);
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., 0.)),
                tex_coords: Vector2f::new(tex_x, 0.),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., size)),
                tex_coords: Vector2f::new(tex_x, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, size)),
                tex_coords: Vector2f::new(tex_x + size, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, 0.)),
                tex_coords: Vector2f::new(tex_x + size, 0.),
            });
            obj.update(window.size().y as f32, window.size().x as f32);
        }
        window.clear(Color::BLACK);
        rs.texture = Some(&texture);
        window.draw_primitives(&buf, PrimitiveType::QUADS, &rs);
        rs.texture = None;
        text.set_string(&format!("{} sprites\n{fps} fps", objects.len()));
        window.draw_text(&text, &rs);
        window.display();
        buf.clear();
        frames_rendered += 1;
        if sec_clock.elapsed_time().as_milliseconds() >= 1000 {
            fps = frames_rendered;
            sec_clock.restart();
            frames_rendered = 0;
        }
    }
    Ok(())
}

examples/opengl.rs (line 160)

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

examples/cursor.rs (line 201)

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

    let mut cursor = Cursor::from_system(CursorType::Arrow)?;
    let mut rw = RenderWindow::new(
        (800, 800),
        "SFML cursor example",
        Style::CLOSE,
        &ContextSettings::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let mut failed_index = usize::MAX;
    let mut selected_index = usize::MAX;
    let set_button = Rect::new(348, 500, 100, 32);
    let hotspot_button = Rect::new(458, 500, 100, 32);
    let clear_button = Rect::new(568, 500, 100, 32);
    let mut pixel_grid = [false; DRAW_GRID_WH as usize * DRAW_GRID_WH as usize];
    let mut hotspot_selection = false;
    let mut hotspot_selected = false;
    let mut hotspot = Vector2::new(8, 8);
    let mut modif = false;

    let mut buttons = Vec::new();
    let cursor_types = [
        CursorType::Arrow,
        CursorType::ArrowWait,
        CursorType::Wait,
        CursorType::Text,
        CursorType::Hand,
        CursorType::SizeHorizontal,
        CursorType::SizeVertical,
        CursorType::SizeTopLeftBottomRight,
        CursorType::SizeBottomLeftTopRight,
        CursorType::SizeLeft,
        CursorType::SizeRight,
        CursorType::SizeTop,
        CursorType::SizeBottom,
        CursorType::SizeTopLeft,
        CursorType::SizeBottomRight,
        CursorType::SizeBottomLeft,
        CursorType::SizeTopRight,
        CursorType::SizeAll,
        CursorType::Cross,
        CursorType::Help,
        CursorType::NotAllowed,
    ];
    for i in 0..cursor_types.len() {
        buttons.push(Rect::new(16, 16 + i as i32 * 36, 250, 32));
    }

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::MouseButtonPressed {
                    button: mouse::Button::Left,
                    x,
                    y,
                } => {
                    for (i, b) in buttons.iter().enumerate() {
                        if mouse_over(b, x, y) {
                            match cursor.load_from_system(cursor_types[i]) {
                                Ok(()) => {
                                    unsafe {
                                        rw.set_mouse_cursor(&cursor);
                                    }
                                    selected_index = i;
                                }
                                Err(e) => {
                                    eprintln!("{e}");
                                    failed_index = i;
                                }
                            }
                        }
                    }
                    if mouse_over(&set_button, x, y) {
                        let mut pixels = [0; DRAW_GRID_WH as usize * DRAW_GRID_WH as usize * 4];
                        for (i, px) in pixel_grid.iter().enumerate() {
                            let offset = i * 4;
                            if *px {
                                pixels[offset] = 255;
                                pixels[offset + 1] = 255;
                                pixels[offset + 2] = 255;
                                pixels[offset + 3] = 255;
                            }
                        }
                        unsafe {
                            match cursor.load_from_pixels(
                                &pixels,
                                Vector2::new(DRAW_GRID_WH as u32, DRAW_GRID_WH as u32),
                                hotspot,
                            ) {
                                Ok(()) => {
                                    rw.set_mouse_cursor(&cursor);
                                }
                                Err(e) => {
                                    eprintln!("{e}");
                                }
                            }
                        }
                        modif = false;
                    }
                    if mouse_over(&clear_button, x, y) {
                        for px in pixel_grid.iter_mut() {
                            *px = false;
                        }
                        modif = true;
                    }
                    if mouse_over(&hotspot_button, x, y) {
                        hotspot_selection = true;
                    }
                }
                Event::MouseButtonReleased {
                    button: mouse::Button::Left,
                    ..
                } => {
                    if hotspot_selected {
                        hotspot_selection = false;
                        hotspot_selected = false;
                    }
                }
                _ => {}
            }
        }
        let mut set_button_highlighted = false;
        let mut hotspot_button_highlighted = false;
        let mut clear_button_highlighted = false;
        // System cursor set button interactions
        let mp = rw.mouse_position();
        let mut highlight_index = usize::MAX;
        for (i, b) in buttons.iter().enumerate() {
            if mouse_over(b, mp.x, mp.y) {
                highlight_index = i;
            }
        }
        if mouse_over(&set_button, mp.x, mp.y) {
            set_button_highlighted = true;
        }
        if mouse_over(&hotspot_button, mp.x, mp.y) {
            hotspot_button_highlighted = true;
        }
        if mouse_over(&clear_button, mp.x, mp.y) {
            clear_button_highlighted = true;
        }
        // Grid interactions
        let rela_x = mp.x - DRAW_AREA_TOPLEFT.0 as i32;
        let rela_y = mp.y - DRAW_AREA_TOPLEFT.1 as i32;
        let (gx, gy) = (rela_x / DRAW_CELL_WH as i32, rela_y / DRAW_CELL_WH as i32);
        if gx >= 0 && gy >= 0 {
            if let Some(cell) = gridindex(&mut pixel_grid, gx as usize, gy as usize) {
                if hotspot_selection {
                    hotspot_selected = true;
                    hotspot = Vector2::new(gx as u32, gy as u32);
                    modif = true;
                } else if mouse::Button::Left.is_pressed() {
                    *cell = true;
                    modif = true;
                } else if mouse::Button::Right.is_pressed() {
                    *cell = false;
                    modif = true;
                }
            }
        }
        rw.clear(Color::BLACK);
        // Draw system cursor set buttons
        let mut shape = RectangleShape::default();
        let mut text = Text::new("", &font, 14);
        shape.set_outline_thickness(-1.0);
        shape.set_outline_color(Color::WHITE);
        for (i, b) in buttons.iter().enumerate() {
            let types = [
                "ARROW",
                "ARROW_WAIT",
                "WAIT",
                "TEXT",
                "HAND",
                "SIZE_HORIZONTAL",
                "SIZE_VERTICAL",
                "SIZE_TOP_LEFT_BOTTOM_RIGHT",
                "SIZE_BOTTOM_LEFT_TOP_RIGHT",
                "SIZE_LEFT",
                "SIZE_RIGHT",
                "SIZE_TOP",
                "SIZE_BOTTOM",
                "SIZE_TOP_LEFT",
                "SIZE_BOTTOM_RIGHT",
                "SIZE_BOTTOM_LEFT",
                "SIZE_TOP_RIGHT",
                "SIZE_ALL",
                "CROSS",
                "HELP",
                "NOT_ALLOWED",
            ];
            draw_button(
                b,
                &mut shape,
                &mut text,
                types[i],
                &mut rw,
                bstyle(highlight_index == i, selected_index == i, failed_index == i),
            );
        }
        // Draw pixel drawing grid
        shape.set_fill_color(Color::TRANSPARENT);
        for y in 0..DRAW_GRID_WH {
            for x in 0..DRAW_GRID_WH {
                if hotspot.x == x as u32 && hotspot.y == y as u32 {
                    shape.set_outline_color(Color::RED);
                } else {
                    shape.set_outline_color(Color::rgb(180, 180, 180));
                }
                if gridindex(&mut pixel_grid, x as usize, y as usize).is_some_and(|bool| *bool) {
                    shape.set_fill_color(Color::WHITE);
                } else {
                    shape.set_fill_color(Color::TRANSPARENT);
                }
                shape.set_size((DRAW_CELL_WH as f32, DRAW_CELL_WH as f32));
                shape.set_position((
                    DRAW_AREA_TOPLEFT.0 as f32 + (x as f32 * DRAW_CELL_WH as f32),
                    DRAW_AREA_TOPLEFT.1 as f32 + (y as f32 * DRAW_CELL_WH as f32),
                ));
                rw.draw(&shape);
            }
        }
        draw_button(
            &set_button,
            &mut shape,
            &mut text,
            if modif { "Set*" } else { "Set" },
            &mut rw,
            bstyle(set_button_highlighted, false, false),
        );
        draw_button(
            &hotspot_button,
            &mut shape,
            &mut text,
            "Hotspot",
            &mut rw,
            bstyle(hotspot_button_highlighted, hotspot_selection, false),
        );
        draw_button(
            &clear_button,
            &mut shape,
            &mut text,
            "Clear",
            &mut rw,
            bstyle(clear_button_highlighted, false, false),
        );
        rw.display();
    }
    Ok(())
}

pub fn set_mouse_position(&mut self, position: Vector2i)

Set the current position of the mouse relatively to a render window

This function sets the current position of the mouse cursor relative to the given render window

Arguments

• position - the positon to set

Examples found in repository

examples/mouse.rs (line 46)

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

    let mut window = RenderWindow::new(
        (800, 600),
        "Mouse events",
        Style::CLOSE,
        &Default::default(),
    )?;
    window.set_mouse_cursor_visible(false);
    window.set_vertical_sync_enabled(true);

    let font = Font::from_file("sansation.ttf")?;
    let mut circle = CircleShape::new(4., 30);
    let mut texts: Vec<Text> = Vec::new();
    let mut mp_text = Text::new("", &font, 14);
    let mut cursor_visible = false;
    let mut grabbed = false;
    macro_rules! push_text {
        ($x:expr, $y:expr, $fmt:expr, $($arg:tt)*) => {
            let mut text = Text::new(&format!($fmt, $($arg)*), &font, 14);
            text.set_position(($x as f32, $y as f32));
            texts.push(text);
        }
    }

    'mainloop: loop {
        while let Some(ev) = window.poll_event() {
            match ev {
                Event::Closed => break 'mainloop,
                Event::MouseWheelScrolled { wheel, delta, x, y } => {
                    push_text!(x, y, "Scroll: {:?}, {}, {}, {}", wheel, delta, x, y);
                }
                Event::MouseButtonPressed { button, x, y } => {
                    push_text!(x, y, "Press: {:?}, {}, {}", button, x, y);
                }
                Event::MouseButtonReleased { button, x, y } => {
                    push_text!(x, y, "Release: {:?}, {}, {}", button, x, y);
                }
                Event::KeyPressed { code, .. } => {
                    if code == Key::W {
                        window.set_mouse_position(Vector2i::new(400, 300));
                    } else if code == Key::D {
                        let dm = VideoMode::desktop_mode();
                        let center = Vector2i::new(dm.width as i32 / 2, dm.height as i32 / 2);
                        mouse::set_desktop_position(center);
                    } else if code == Key::V {
                        cursor_visible = !cursor_visible;
                        window.set_mouse_cursor_visible(cursor_visible);
                    } else if code == Key::G {
                        grabbed = !grabbed;
                        window.set_mouse_cursor_grabbed(grabbed);
                    }
                }
                _ => {}
            }
        }

        let mp = window.mouse_position();
        let dmp = mouse::desktop_position();
        let cur_vis_msg = if cursor_visible {
            "visible"
        } else {
            "invisible"
        };
        let grab_msg = if grabbed { "grabbed" } else { "not grabbed" };
        mp_text.set_string(&format!(
            "x: {}, y: {} (Window)\n\
             x: {}, y: {} (Desktop)\n\
             [{cur_vis_msg}] [{grab_msg}] ('V'/'G') to toggle\n\
             'W' to center mouse on window\n\
             'D' to center mouse on desktop",
            mp.x, mp.y, dmp.x, dmp.y
        ));

        circle.set_position((mp.x as f32, mp.y as f32));

        window.clear(Color::BLACK);
        // Push texts out of each other's way
        for i in (0..texts.len()).rev() {
            for j in (0..i).rev() {
                if let Some(intersect) = texts[i]
                    .global_bounds()
                    .intersection(&texts[j].global_bounds())
                {
                    texts[j].move_((0., -intersect.height));
                }
            }
        }
        texts.retain(|txt| txt.fill_color().a > 0);
        for txt in &mut texts {
            let mut color = txt.fill_color();
            color.a -= 1;
            txt.set_fill_color(color);
            window.draw(txt);
        }
        if !cursor_visible {
            window.draw(&circle);
        }
        window.draw(&mp_text);
        window.display();
    }
    Ok(())
}

pub fn touch_position(&self, finger: u32) -> Vector2i

Returns the current position of a touch in window coordinates.

impl RenderWindow

Window operations

pub unsafe fn set_icon(&mut self, width: u32, height: u32, pixels: &[u8])

Change a render window’s icon pixels must be an array of width x height pixels in 32-bits RGBA format.

Arguments

• width - Icon’s width, in pixels
• height - Icon’s height, in pixels
• pixels - Vector of pixels

Safety

pixels not being at least width * height * 4 will likely cause undefined behavior.

Platform-specific behavior is also unclear (limits on max size, etc).

pub fn close(&mut self)

Close a render window and destroy all the attached resources

After calling this method, the Window object remains valid. All other functions such as poll_event or display will still work (i.e. you don’t have to test is_open every time), and will have no effect on closed windows.

Examples found in repository

examples/resource-holder.rs (line 77)

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/shader.rs (line 299)

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 effects: [&mut dyn Effect; 4] = [
        &mut Pixelate::new(&bg)?,
        &mut WaveBlur::new(&font)?,
        &mut StormBlink::new()?,
        &mut Edge::new(&bg_texture, &entity_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].as_drawable());
        window.draw(&text_bg);
        window.draw(&instructions);
        window.draw(&desc);
        window.display();
    }
    Ok(())
}

examples/rc-resources.rs (line 160)

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/window-test.rs (line 44)

fn main() -> SfResult<()> {
    let configs = [
        WindowConfig {
            mode: (320, 240),
            title: "(Windowed) Retro",
            style: Style::CLOSE,
        },
        WindowConfig {
            mode: (640, 480),
            title: "(Windowed) Classic",
            style: Style::DEFAULT,
        },
        WindowConfig {
            mode: (800, 600),
            title: "(Windowed) Big",
            style: Style::TITLEBAR,
        },
    ];
    let mut cfg_idx = 2usize;
    let mut rw = RenderWindow::new(
        configs[cfg_idx].mode,
        "Window test",
        Style::CLOSE,
        &ContextSettings::default(),
    )?;
    let font = Font::from_memory_static(include_bytes!("resources/sansation.ttf"))?;
    let fs_modes = VideoMode::fullscreen_modes();

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::Up => cfg_idx = cfg_idx.saturating_sub(1),
                    Key::Down => {
                        if cfg_idx + 1 < configs.len() + fs_modes.len() {
                            cfg_idx += 1
                        }
                    }
                    Key::Enter => match configs.get(cfg_idx) {
                        Some(cfg) => {
                            rw.recreate(cfg.mode, cfg.title, cfg.style, &ContextSettings::default())
                        }
                        None => match fs_modes.get(cfg_idx - configs.len()) {
                            Some(mode) => rw.recreate(
                                *mode,
                                "Fullscreen",
                                Style::FULLSCREEN,
                                &ContextSettings::default(),
                            ),
                            None => {
                                eprintln!("Invalid index: {cfg_idx}");
                            }
                        },
                    },
                    _ => {}
                },
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        let fontsize = 16;
        let mut txt = Text::new("Arrow keys to select mode, enter to set.", &font, fontsize);
        rw.draw(&txt);
        let mut y = fontsize as f32;
        for (i, cfg) in configs.iter().enumerate() {
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            txt.set_string(&format!(
                "{}x{} \"{}\" ({:?})",
                cfg.mode.0, cfg.mode.1, cfg.title, cfg.style
            ));
            txt.set_position((0., y));
            rw.draw(&txt);
            y += fontsize as f32;
        }
        let mut i = configs.len();
        y += fontsize as f32;
        txt.set_position((0., y));
        txt.set_fill_color(Color::WHITE);
        txt.set_string("= Fullscreen modes =");
        rw.draw(&txt);
        for mode in fs_modes.iter() {
            let n_rows = 23;
            let column = i / n_rows;
            let row = i % n_rows;
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            let left_pad = 16.0;
            let x = left_pad + (column * 128) as f32;
            let gap = 16.0;
            let y = y + gap + (row * fontsize as usize) as f32;
            txt.set_position((x, y));
            txt.set_string(&format!(
                "{}x{}x{}",
                mode.width, mode.height, mode.bits_per_pixel
            ));
            rw.draw(&txt);
            i += 1;
        }
        rw.display();
    }
    Ok(())
}

examples/positional-audio.rs (line 77)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    let mut rw = RenderWindow::new(
        (800, 600),
        "Positional audio demo",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let mut text = Text::new("", &font, 20);
    let mut music = match std::env::args().nth(1) {
        Some(music_path) => Music::from_file(&music_path)?,
        None => Music::from_file("canary.wav")?,
    };
    if music.channel_count() != 1 {
        return Err("Sorry, only sounds with 1 channel are supported.".into());
    };
    music.set_looping(true);
    music.play();
    music.set_position(Vector3::new(0., 0., 0.));

    let mut listener_pos = Vector3::new(0.0, 0.0, 0.0);
    let center = Vector2::new(400., 300.);
    let [mut go_left, mut go_right, mut go_up, mut go_down] = [false; 4];
    let clock = Clock::start()?;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::A => go_left = true,
                    Key::D => go_right = true,
                    Key::W => go_up = true,
                    Key::S => go_down = true,
                    _ => {}
                },
                Event::KeyReleased { code, .. } => match code {
                    Key::A => go_left = false,
                    Key::D => go_right = false,
                    Key::W => go_up = false,
                    Key::S => go_down = false,
                    _ => {}
                },
                _ => {}
            }
        }
        let Vector2f { x: mx, y: my } = rw.mouse_position().as_other();
        let speed = 0.05;
        if go_left {
            listener_pos.x -= speed;
        }
        if go_right {
            listener_pos.x += speed;
        }
        if go_up {
            listener_pos.y -= speed;
        }
        if go_down {
            listener_pos.y += speed;
        }
        let scale = 20.0; // Scale the positions for better visualization
        listener::set_position(listener_pos);
        listener::set_direction(Vector3::new(
            (mx - center.x) / scale,
            (my - center.y) / scale,
            -1.,
        ));
        let Vector3 {
            x: lx,
            y: ly,
            z: lz,
        } = listener::position();
        let Vector3 {
            x: dx,
            y: dy,
            z: dz,
        } = listener::direction();
        rw.clear(Color::BLACK);
        let mut circle_shape = CircleShape::new(8.0, 32);
        // Draw circle at center, representing position of music being played
        circle_shape.set_position(center);
        circle_shape.set_fill_color(Color::YELLOW);
        let t = clock.elapsed_time().as_seconds();
        let radius = 12.0 + t.sin() * 3.0;
        circle_shape.set_radius(radius);
        circle_shape.set_origin(radius);
        rw.draw(&circle_shape);
        // Draw circle representing listener
        circle_shape.set_position((center.x + lx * scale, center.y + ly * scale));
        circle_shape.set_origin(4.0);
        circle_shape.set_radius(4.0);
        circle_shape.set_fill_color(Color::GREEN);
        rw.draw(&circle_shape);
        // Draw line from listener to direction vector position
        rw.draw_line(
            circle_shape.position(),
            (center.x + dx * scale, center.y + dy * scale).into(),
            2.0,
        );
        text.set_string("WASD + mouse for movement of listener");
        text.set_position(0.);
        rw.draw(&text);
        text.set_string(&format!("Listener position: {lx}, {ly}, {lz}"));
        text.set_position((0., 20.0));
        rw.draw(&text);
        text.set_string(&format!("Listener direction: {dx}, {dy}, {dz}"));
        text.set_position((0., 40.0));
        rw.draw(&text);
        rw.display();
    }
    Ok(())
}

examples/spritemark.rs (line 96)

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

    let native_mode = VideoMode::desktop_mode();
    let mut window = RenderWindow::new(
        native_mode,
        "Spritemark",
        Style::default(),
        &ContextSettings::default(),
    )?;
    window.set_position(Vector2::new(0, 0));
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let texture = Texture::from_file("devices.png")?;
    let mut text = Text::new("", &font, 18);
    text.set_outline_color(Color::BLACK);
    text.set_outline_thickness(1.0);
    let mut click_counter = 0;
    let mut objects = Vec::new();
    let mut rng = thread_rng();
    let mut rs = RenderStates::default();
    let mut buf = Vec::new();
    let mut frames_rendered = 0;
    let mut sec_clock = Clock::start()?;
    let mut fps = 0;
    let mut lmb_down = false;
    let mut view = View::new()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => window.close(),
                Event::MouseButtonPressed {
                    button: Button::Left,
                    ..
                } => {
                    click_counter += 1;
                    lmb_down = true;
                }
                Event::MouseButtonReleased {
                    button: Button::Left,
                    ..
                } => {
                    lmb_down = false;
                }
                Event::Resized { width, height } => {
                    view.reset(Rect::new(0., 0., width as f32, height as f32));
                    window.set_view(&view);
                }
                _ => {}
            }
        }

        if lmb_down {
            let mp = window.mouse_position();
            for _ in 0..25 {
                objects.push(Object {
                    position: fconv(mp),
                    speed: Vector2f::new(rng.gen_range(-3.0..3.0), 0.0),
                    image_id: click_counter % N_IMAGES,
                    angle: 0.0,
                    rot_speed: rng.gen_range(-2.0..2.0),
                });
            }
        }

        for obj in &mut objects {
            let size = f32::from(SUBIMAGE_SIZE);
            let tex_x = f32::from(obj.image_id) * size;
            let mut tf = Transform::default();
            tf.translate(obj.position.x, obj.position.y);
            tf.rotate_with_center(obj.angle, size / 2.0, size / 2.0);
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., 0.)),
                tex_coords: Vector2f::new(tex_x, 0.),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., size)),
                tex_coords: Vector2f::new(tex_x, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, size)),
                tex_coords: Vector2f::new(tex_x + size, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, 0.)),
                tex_coords: Vector2f::new(tex_x + size, 0.),
            });
            obj.update(window.size().y as f32, window.size().x as f32);
        }
        window.clear(Color::BLACK);
        rs.texture = Some(&texture);
        window.draw_primitives(&buf, PrimitiveType::QUADS, &rs);
        rs.texture = None;
        text.set_string(&format!("{} sprites\n{fps} fps", objects.len()));
        window.draw_text(&text, &rs);
        window.display();
        buf.clear();
        frames_rendered += 1;
        if sec_clock.elapsed_time().as_milliseconds() >= 1000 {
            fps = frames_rendered;
            sec_clock.restart();
            frames_rendered = 0;
        }
    }
    Ok(())
}

Additional examples can be found in:

• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs

pub fn is_open(&self) -> bool

Tell whether or not a window is opened

This function returns whether or not the window exists. Note that a hidden window (set_visible(false)) will return true.

Examples found in repository

examples/resource-holder.rs (line 71)

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/shader.rs (line 295)

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 effects: [&mut dyn Effect; 4] = [
        &mut Pixelate::new(&bg)?,
        &mut WaveBlur::new(&font)?,
        &mut StormBlink::new()?,
        &mut Edge::new(&bg_texture, &entity_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].as_drawable());
        window.draw(&text_bg);
        window.draw(&instructions);
        window.draw(&desc);
        window.display();
    }
    Ok(())
}

examples/rc-resources.rs (line 157)

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/window-test.rs (line 41)

fn main() -> SfResult<()> {
    let configs = [
        WindowConfig {
            mode: (320, 240),
            title: "(Windowed) Retro",
            style: Style::CLOSE,
        },
        WindowConfig {
            mode: (640, 480),
            title: "(Windowed) Classic",
            style: Style::DEFAULT,
        },
        WindowConfig {
            mode: (800, 600),
            title: "(Windowed) Big",
            style: Style::TITLEBAR,
        },
    ];
    let mut cfg_idx = 2usize;
    let mut rw = RenderWindow::new(
        configs[cfg_idx].mode,
        "Window test",
        Style::CLOSE,
        &ContextSettings::default(),
    )?;
    let font = Font::from_memory_static(include_bytes!("resources/sansation.ttf"))?;
    let fs_modes = VideoMode::fullscreen_modes();

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::Up => cfg_idx = cfg_idx.saturating_sub(1),
                    Key::Down => {
                        if cfg_idx + 1 < configs.len() + fs_modes.len() {
                            cfg_idx += 1
                        }
                    }
                    Key::Enter => match configs.get(cfg_idx) {
                        Some(cfg) => {
                            rw.recreate(cfg.mode, cfg.title, cfg.style, &ContextSettings::default())
                        }
                        None => match fs_modes.get(cfg_idx - configs.len()) {
                            Some(mode) => rw.recreate(
                                *mode,
                                "Fullscreen",
                                Style::FULLSCREEN,
                                &ContextSettings::default(),
                            ),
                            None => {
                                eprintln!("Invalid index: {cfg_idx}");
                            }
                        },
                    },
                    _ => {}
                },
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        let fontsize = 16;
        let mut txt = Text::new("Arrow keys to select mode, enter to set.", &font, fontsize);
        rw.draw(&txt);
        let mut y = fontsize as f32;
        for (i, cfg) in configs.iter().enumerate() {
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            txt.set_string(&format!(
                "{}x{} \"{}\" ({:?})",
                cfg.mode.0, cfg.mode.1, cfg.title, cfg.style
            ));
            txt.set_position((0., y));
            rw.draw(&txt);
            y += fontsize as f32;
        }
        let mut i = configs.len();
        y += fontsize as f32;
        txt.set_position((0., y));
        txt.set_fill_color(Color::WHITE);
        txt.set_string("= Fullscreen modes =");
        rw.draw(&txt);
        for mode in fs_modes.iter() {
            let n_rows = 23;
            let column = i / n_rows;
            let row = i % n_rows;
            let fc = if i == cfg_idx {
                Color::YELLOW
            } else {
                Color::WHITE
            };
            txt.set_fill_color(fc);
            let left_pad = 16.0;
            let x = left_pad + (column * 128) as f32;
            let gap = 16.0;
            let y = y + gap + (row * fontsize as usize) as f32;
            txt.set_position((x, y));
            txt.set_string(&format!(
                "{}x{}x{}",
                mode.width, mode.height, mode.bits_per_pixel
            ));
            rw.draw(&txt);
            i += 1;
        }
        rw.display();
    }
    Ok(())
}

examples/positional-audio.rs (line 74)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    let mut rw = RenderWindow::new(
        (800, 600),
        "Positional audio demo",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let mut text = Text::new("", &font, 20);
    let mut music = match std::env::args().nth(1) {
        Some(music_path) => Music::from_file(&music_path)?,
        None => Music::from_file("canary.wav")?,
    };
    if music.channel_count() != 1 {
        return Err("Sorry, only sounds with 1 channel are supported.".into());
    };
    music.set_looping(true);
    music.play();
    music.set_position(Vector3::new(0., 0., 0.));

    let mut listener_pos = Vector3::new(0.0, 0.0, 0.0);
    let center = Vector2::new(400., 300.);
    let [mut go_left, mut go_right, mut go_up, mut go_down] = [false; 4];
    let clock = Clock::start()?;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match code {
                    Key::A => go_left = true,
                    Key::D => go_right = true,
                    Key::W => go_up = true,
                    Key::S => go_down = true,
                    _ => {}
                },
                Event::KeyReleased { code, .. } => match code {
                    Key::A => go_left = false,
                    Key::D => go_right = false,
                    Key::W => go_up = false,
                    Key::S => go_down = false,
                    _ => {}
                },
                _ => {}
            }
        }
        let Vector2f { x: mx, y: my } = rw.mouse_position().as_other();
        let speed = 0.05;
        if go_left {
            listener_pos.x -= speed;
        }
        if go_right {
            listener_pos.x += speed;
        }
        if go_up {
            listener_pos.y -= speed;
        }
        if go_down {
            listener_pos.y += speed;
        }
        let scale = 20.0; // Scale the positions for better visualization
        listener::set_position(listener_pos);
        listener::set_direction(Vector3::new(
            (mx - center.x) / scale,
            (my - center.y) / scale,
            -1.,
        ));
        let Vector3 {
            x: lx,
            y: ly,
            z: lz,
        } = listener::position();
        let Vector3 {
            x: dx,
            y: dy,
            z: dz,
        } = listener::direction();
        rw.clear(Color::BLACK);
        let mut circle_shape = CircleShape::new(8.0, 32);
        // Draw circle at center, representing position of music being played
        circle_shape.set_position(center);
        circle_shape.set_fill_color(Color::YELLOW);
        let t = clock.elapsed_time().as_seconds();
        let radius = 12.0 + t.sin() * 3.0;
        circle_shape.set_radius(radius);
        circle_shape.set_origin(radius);
        rw.draw(&circle_shape);
        // Draw circle representing listener
        circle_shape.set_position((center.x + lx * scale, center.y + ly * scale));
        circle_shape.set_origin(4.0);
        circle_shape.set_radius(4.0);
        circle_shape.set_fill_color(Color::GREEN);
        rw.draw(&circle_shape);
        // Draw line from listener to direction vector position
        rw.draw_line(
            circle_shape.position(),
            (center.x + dx * scale, center.y + dy * scale).into(),
            2.0,
        );
        text.set_string("WASD + mouse for movement of listener");
        text.set_position(0.);
        rw.draw(&text);
        text.set_string(&format!("Listener position: {lx}, {ly}, {lz}"));
        text.set_position((0., 20.0));
        rw.draw(&text);
        text.set_string(&format!("Listener direction: {dx}, {dy}, {dz}"));
        text.set_position((0., 40.0));
        rw.draw(&text);
        rw.display();
    }
    Ok(())
}

examples/spritemark.rs (line 90)

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

    let native_mode = VideoMode::desktop_mode();
    let mut window = RenderWindow::new(
        native_mode,
        "Spritemark",
        Style::default(),
        &ContextSettings::default(),
    )?;
    window.set_position(Vector2::new(0, 0));
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let texture = Texture::from_file("devices.png")?;
    let mut text = Text::new("", &font, 18);
    text.set_outline_color(Color::BLACK);
    text.set_outline_thickness(1.0);
    let mut click_counter = 0;
    let mut objects = Vec::new();
    let mut rng = thread_rng();
    let mut rs = RenderStates::default();
    let mut buf = Vec::new();
    let mut frames_rendered = 0;
    let mut sec_clock = Clock::start()?;
    let mut fps = 0;
    let mut lmb_down = false;
    let mut view = View::new()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => window.close(),
                Event::MouseButtonPressed {
                    button: Button::Left,
                    ..
                } => {
                    click_counter += 1;
                    lmb_down = true;
                }
                Event::MouseButtonReleased {
                    button: Button::Left,
                    ..
                } => {
                    lmb_down = false;
                }
                Event::Resized { width, height } => {
                    view.reset(Rect::new(0., 0., width as f32, height as f32));
                    window.set_view(&view);
                }
                _ => {}
            }
        }

        if lmb_down {
            let mp = window.mouse_position();
            for _ in 0..25 {
                objects.push(Object {
                    position: fconv(mp),
                    speed: Vector2f::new(rng.gen_range(-3.0..3.0), 0.0),
                    image_id: click_counter % N_IMAGES,
                    angle: 0.0,
                    rot_speed: rng.gen_range(-2.0..2.0),
                });
            }
        }

        for obj in &mut objects {
            let size = f32::from(SUBIMAGE_SIZE);
            let tex_x = f32::from(obj.image_id) * size;
            let mut tf = Transform::default();
            tf.translate(obj.position.x, obj.position.y);
            tf.rotate_with_center(obj.angle, size / 2.0, size / 2.0);
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., 0.)),
                tex_coords: Vector2f::new(tex_x, 0.),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., size)),
                tex_coords: Vector2f::new(tex_x, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, size)),
                tex_coords: Vector2f::new(tex_x + size, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, 0.)),
                tex_coords: Vector2f::new(tex_x + size, 0.),
            });
            obj.update(window.size().y as f32, window.size().x as f32);
        }
        window.clear(Color::BLACK);
        rs.texture = Some(&texture);
        window.draw_primitives(&buf, PrimitiveType::QUADS, &rs);
        rs.texture = None;
        text.set_string(&format!("{} sprites\n{fps} fps", objects.len()));
        window.draw_text(&text, &rs);
        window.display();
        buf.clear();
        frames_rendered += 1;
        if sec_clock.elapsed_time().as_milliseconds() >= 1000 {
            fps = frames_rendered;
            sec_clock.restart();
            frames_rendered = 0;
        }
    }
    Ok(())
}

Additional examples can be found in:

• examples/opengl.rs
• examples/custom-sound-recorder.rs
• examples/cursor.rs

pub fn set_title<S: SfStrConv>(&mut self, title: S)

Change the title of a window

Arguments

• title - New title

pub fn set_visible(&mut self, visible: bool)

Show or hide a window.

Arguments

• visible - true to show the window, false to hide it

pub fn position(&self) -> Vector2i

Get the position of a window

Return the position in pixels

pub fn set_position(&mut self, position: Vector2i)

Change the position of a window on screen

This function only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

Arguments

• position - New position of the window, in pixels

Examples found in repository

examples/spritemark.rs (line 72)

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

    let native_mode = VideoMode::desktop_mode();
    let mut window = RenderWindow::new(
        native_mode,
        "Spritemark",
        Style::default(),
        &ContextSettings::default(),
    )?;
    window.set_position(Vector2::new(0, 0));
    window.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let texture = Texture::from_file("devices.png")?;
    let mut text = Text::new("", &font, 18);
    text.set_outline_color(Color::BLACK);
    text.set_outline_thickness(1.0);
    let mut click_counter = 0;
    let mut objects = Vec::new();
    let mut rng = thread_rng();
    let mut rs = RenderStates::default();
    let mut buf = Vec::new();
    let mut frames_rendered = 0;
    let mut sec_clock = Clock::start()?;
    let mut fps = 0;
    let mut lmb_down = false;
    let mut view = View::new()?;

    while window.is_open() {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => window.close(),
                Event::MouseButtonPressed {
                    button: Button::Left,
                    ..
                } => {
                    click_counter += 1;
                    lmb_down = true;
                }
                Event::MouseButtonReleased {
                    button: Button::Left,
                    ..
                } => {
                    lmb_down = false;
                }
                Event::Resized { width, height } => {
                    view.reset(Rect::new(0., 0., width as f32, height as f32));
                    window.set_view(&view);
                }
                _ => {}
            }
        }

        if lmb_down {
            let mp = window.mouse_position();
            for _ in 0..25 {
                objects.push(Object {
                    position: fconv(mp),
                    speed: Vector2f::new(rng.gen_range(-3.0..3.0), 0.0),
                    image_id: click_counter % N_IMAGES,
                    angle: 0.0,
                    rot_speed: rng.gen_range(-2.0..2.0),
                });
            }
        }

        for obj in &mut objects {
            let size = f32::from(SUBIMAGE_SIZE);
            let tex_x = f32::from(obj.image_id) * size;
            let mut tf = Transform::default();
            tf.translate(obj.position.x, obj.position.y);
            tf.rotate_with_center(obj.angle, size / 2.0, size / 2.0);
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., 0.)),
                tex_coords: Vector2f::new(tex_x, 0.),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(0., size)),
                tex_coords: Vector2f::new(tex_x, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, size)),
                tex_coords: Vector2f::new(tex_x + size, size),
            });
            buf.push(Vertex {
                color: Color::WHITE,
                position: tf.transform_point(Vector2f::new(size, 0.)),
                tex_coords: Vector2f::new(tex_x + size, 0.),
            });
            obj.update(window.size().y as f32, window.size().x as f32);
        }
        window.clear(Color::BLACK);
        rs.texture = Some(&texture);
        window.draw_primitives(&buf, PrimitiveType::QUADS, &rs);
        rs.texture = None;
        text.set_string(&format!("{} sprites\n{fps} fps", objects.len()));
        window.draw_text(&text, &rs);
        window.display();
        buf.clear();
        frames_rendered += 1;
        if sec_clock.elapsed_time().as_milliseconds() >= 1000 {
            fps = frames_rendered;
            sec_clock.restart();
            frames_rendered = 0;
        }
    }
    Ok(())
}

pub fn set_size<S: Into<Vector2u>>(&mut self, size: S)

Change the size of the rendering region of a window

Arguments

• size - New size, in pixels

pub unsafe fn set_mouse_cursor(&mut self, cursor: &Cursor)

Set the displayed cursor to a native system cursor.

Upon window creation, the arrow cursor is used by default.

Safety

The cursor can not be destroyed while in use by the window.

Examples found in repository

examples/cursor.rs (line 137)

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

    let mut cursor = Cursor::from_system(CursorType::Arrow)?;
    let mut rw = RenderWindow::new(
        (800, 800),
        "SFML cursor example",
        Style::CLOSE,
        &ContextSettings::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let mut failed_index = usize::MAX;
    let mut selected_index = usize::MAX;
    let set_button = Rect::new(348, 500, 100, 32);
    let hotspot_button = Rect::new(458, 500, 100, 32);
    let clear_button = Rect::new(568, 500, 100, 32);
    let mut pixel_grid = [false; DRAW_GRID_WH as usize * DRAW_GRID_WH as usize];
    let mut hotspot_selection = false;
    let mut hotspot_selected = false;
    let mut hotspot = Vector2::new(8, 8);
    let mut modif = false;

    let mut buttons = Vec::new();
    let cursor_types = [
        CursorType::Arrow,
        CursorType::ArrowWait,
        CursorType::Wait,
        CursorType::Text,
        CursorType::Hand,
        CursorType::SizeHorizontal,
        CursorType::SizeVertical,
        CursorType::SizeTopLeftBottomRight,
        CursorType::SizeBottomLeftTopRight,
        CursorType::SizeLeft,
        CursorType::SizeRight,
        CursorType::SizeTop,
        CursorType::SizeBottom,
        CursorType::SizeTopLeft,
        CursorType::SizeBottomRight,
        CursorType::SizeBottomLeft,
        CursorType::SizeTopRight,
        CursorType::SizeAll,
        CursorType::Cross,
        CursorType::Help,
        CursorType::NotAllowed,
    ];
    for i in 0..cursor_types.len() {
        buttons.push(Rect::new(16, 16 + i as i32 * 36, 250, 32));
    }

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::MouseButtonPressed {
                    button: mouse::Button::Left,
                    x,
                    y,
                } => {
                    for (i, b) in buttons.iter().enumerate() {
                        if mouse_over(b, x, y) {
                            match cursor.load_from_system(cursor_types[i]) {
                                Ok(()) => {
                                    unsafe {
                                        rw.set_mouse_cursor(&cursor);
                                    }
                                    selected_index = i;
                                }
                                Err(e) => {
                                    eprintln!("{e}");
                                    failed_index = i;
                                }
                            }
                        }
                    }
                    if mouse_over(&set_button, x, y) {
                        let mut pixels = [0; DRAW_GRID_WH as usize * DRAW_GRID_WH as usize * 4];
                        for (i, px) in pixel_grid.iter().enumerate() {
                            let offset = i * 4;
                            if *px {
                                pixels[offset] = 255;
                                pixels[offset + 1] = 255;
                                pixels[offset + 2] = 255;
                                pixels[offset + 3] = 255;
                            }
                        }
                        unsafe {
                            match cursor.load_from_pixels(
                                &pixels,
                                Vector2::new(DRAW_GRID_WH as u32, DRAW_GRID_WH as u32),
                                hotspot,
                            ) {
                                Ok(()) => {
                                    rw.set_mouse_cursor(&cursor);
                                }
                                Err(e) => {
                                    eprintln!("{e}");
                                }
                            }
                        }
                        modif = false;
                    }
                    if mouse_over(&clear_button, x, y) {
                        for px in pixel_grid.iter_mut() {
                            *px = false;
                        }
                        modif = true;
                    }
                    if mouse_over(&hotspot_button, x, y) {
                        hotspot_selection = true;
                    }
                }
                Event::MouseButtonReleased {
                    button: mouse::Button::Left,
                    ..
                } => {
                    if hotspot_selected {
                        hotspot_selection = false;
                        hotspot_selected = false;
                    }
                }
                _ => {}
            }
        }
        let mut set_button_highlighted = false;
        let mut hotspot_button_highlighted = false;
        let mut clear_button_highlighted = false;
        // System cursor set button interactions
        let mp = rw.mouse_position();
        let mut highlight_index = usize::MAX;
        for (i, b) in buttons.iter().enumerate() {
            if mouse_over(b, mp.x, mp.y) {
                highlight_index = i;
            }
        }
        if mouse_over(&set_button, mp.x, mp.y) {
            set_button_highlighted = true;
        }
        if mouse_over(&hotspot_button, mp.x, mp.y) {
            hotspot_button_highlighted = true;
        }
        if mouse_over(&clear_button, mp.x, mp.y) {
            clear_button_highlighted = true;
        }
        // Grid interactions
        let rela_x = mp.x - DRAW_AREA_TOPLEFT.0 as i32;
        let rela_y = mp.y - DRAW_AREA_TOPLEFT.1 as i32;
        let (gx, gy) = (rela_x / DRAW_CELL_WH as i32, rela_y / DRAW_CELL_WH as i32);
        if gx >= 0 && gy >= 0 {
            if let Some(cell) = gridindex(&mut pixel_grid, gx as usize, gy as usize) {
                if hotspot_selection {
                    hotspot_selected = true;
                    hotspot = Vector2::new(gx as u32, gy as u32);
                    modif = true;
                } else if mouse::Button::Left.is_pressed() {
                    *cell = true;
                    modif = true;
                } else if mouse::Button::Right.is_pressed() {
                    *cell = false;
                    modif = true;
                }
            }
        }
        rw.clear(Color::BLACK);
        // Draw system cursor set buttons
        let mut shape = RectangleShape::default();
        let mut text = Text::new("", &font, 14);
        shape.set_outline_thickness(-1.0);
        shape.set_outline_color(Color::WHITE);
        for (i, b) in buttons.iter().enumerate() {
            let types = [
                "ARROW",
                "ARROW_WAIT",
                "WAIT",
                "TEXT",
                "HAND",
                "SIZE_HORIZONTAL",
                "SIZE_VERTICAL",
                "SIZE_TOP_LEFT_BOTTOM_RIGHT",
                "SIZE_BOTTOM_LEFT_TOP_RIGHT",
                "SIZE_LEFT",
                "SIZE_RIGHT",
                "SIZE_TOP",
                "SIZE_BOTTOM",
                "SIZE_TOP_LEFT",
                "SIZE_BOTTOM_RIGHT",
                "SIZE_BOTTOM_LEFT",
                "SIZE_TOP_RIGHT",
                "SIZE_ALL",
                "CROSS",
                "HELP",
                "NOT_ALLOWED",
            ];
            draw_button(
                b,
                &mut shape,
                &mut text,
                types[i],
                &mut rw,
                bstyle(highlight_index == i, selected_index == i, failed_index == i),
            );
        }
        // Draw pixel drawing grid
        shape.set_fill_color(Color::TRANSPARENT);
        for y in 0..DRAW_GRID_WH {
            for x in 0..DRAW_GRID_WH {
                if hotspot.x == x as u32 && hotspot.y == y as u32 {
                    shape.set_outline_color(Color::RED);
                } else {
                    shape.set_outline_color(Color::rgb(180, 180, 180));
                }
                if gridindex(&mut pixel_grid, x as usize, y as usize).is_some_and(|bool| *bool) {
                    shape.set_fill_color(Color::WHITE);
                } else {
                    shape.set_fill_color(Color::TRANSPARENT);
                }
                shape.set_size((DRAW_CELL_WH as f32, DRAW_CELL_WH as f32));
                shape.set_position((
                    DRAW_AREA_TOPLEFT.0 as f32 + (x as f32 * DRAW_CELL_WH as f32),
                    DRAW_AREA_TOPLEFT.1 as f32 + (y as f32 * DRAW_CELL_WH as f32),
                ));
                rw.draw(&shape);
            }
        }
        draw_button(
            &set_button,
            &mut shape,
            &mut text,
            if modif { "Set*" } else { "Set" },
            &mut rw,
            bstyle(set_button_highlighted, false, false),
        );
        draw_button(
            &hotspot_button,
            &mut shape,
            &mut text,
            "Hotspot",
            &mut rw,
            bstyle(hotspot_button_highlighted, hotspot_selection, false),
        );
        draw_button(
            &clear_button,
            &mut shape,
            &mut text,
            "Clear",
            &mut rw,
            bstyle(clear_button_highlighted, false, false),
        );
        rw.display();
    }
    Ok(())
}

pub fn has_focus(&self) -> bool

Check whether the window has the input focus.

At any given time, only one window may have the input focus to receive input events such as keystrokes or most mouse events.

pub fn request_focus(&mut self)

Request the current window to be made the active foreground window.

At any given time, only one window may have the input focus to receive input events such as keystrokes or mouse events. If a window requests focus, it only hints to the operating system, that it would like to be focused. The operating system is free to deny the request. This is not to be confused with RenderWindow::set_active.

impl RenderWindow

System integration

pub fn system_handle(&self) -> Handle

Get the OS-specific handle of the window.

The type of the returned handle is Handle, which is a typedef to the handle type defined by the OS. You shouldn’t need to use this function, unless you have very specific stuff to implement that SFML doesn’t support, or implement a temporary workaround until a bug is fixed.

Trait Implementations

impl Debug for RenderWindow

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

Formats the value using the given formatter.

impl Drop for RenderWindow

fn drop(&mut self)

Executes the destructor for this type.

impl RenderTarget for RenderWindow

fn push_gl_states(&mut self)

Save the current OpenGL render states and matrices

fn pop_gl_states(&mut self)

Restore the previously saved OpenGL render states and matrices

fn reset_gl_states(&mut self)

Reset the internal OpenGL states so that the target is ready for drawing

fn set_view(&mut self, view: &View)

set a new view to the target

fn view(&self) -> &View

return the current view

fn default_view(&self) -> &View

get the default view for the render target

fn map_pixel_to_coords(&self, point: Vector2i, view: &View) -> Vector2f

Convert a point from window coordinates to world coordinates

fn map_pixel_to_coords_current_view(&self, point: Vector2i) -> Vector2f

Convert a point from window coordinates to world coordinates

fn map_coords_to_pixel(&self, point: Vector2f, view: &View) -> Vector2i

Convert a point from world coordinates to window coordinates

fn map_coords_to_pixel_current_view(&self, point: Vector2f) -> Vector2i

Convert a point from window coordinates to world coordinates

fn viewport(&self, view: &View) -> IntRect

get the viewport of the render target

fn size(&self) -> Vector2u

Get the size of the rendering region of a window

fn draw(&mut self, object: &dyn Drawable)

Draw a drawable object to the render target

fn draw_with_renderstates( &mut self, object: &dyn Drawable, render_states: &RenderStates<'_, '_, '_>, )

Draw a drawable object to the render-target with a RenderStates

fn draw_text( &mut self, text: &Text<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw Text

fn draw_rc_text( &mut self, text: &RcText, render_states: &RenderStates<'_, '_, '_>, )

Draw RcText

fn draw_shape( &mut self, shape: &CustomShape<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw Shape

fn draw_sprite( &mut self, sprite: &Sprite<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw Sprite

fn draw_rc_sprite( &mut self, sprite: &RcSprite, render_states: &RenderStates<'_, '_, '_>, )

Draw RcSprite

fn draw_circle_shape( &mut self, circle_shape: &CircleShape<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw CircleShape

fn draw_rectangle_shape( &mut self, rectangle_shape: &RectangleShape<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw RectangleShape

fn draw_convex_shape( &mut self, convex_shape: &ConvexShape<'_>, render_states: &RenderStates<'_, '_, '_>, )

Draw ConvexShape

fn draw_vertex_buffer( &mut self, vertex_buffer: &VertexBuffer, render_states: &RenderStates<'_, '_, '_>, )

Draw primitives defined by a vertex buffer

fn draw_primitives( &mut self, vertices: &[Vertex], ty: PrimitiveType, rs: &RenderStates<'_, '_, '_>, )

Draw primitives defined by an array of vertices.

fn clear(&mut self, color: Color)

clear the screen