Struct Color

#[repr(C)]
pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
    pub a: u8,
}

Utility type for manpulating RGBA colors

Color is a simple color type composed of 4 components: Red, Green, Blue, Alpha

Example

There are 3 basic ways to construct a color

use sfml::graphics::Color;
let color1 = Color::rgb(255, 0, 0); // from red/green/blue values
let color2 = Color::rgba(255, 255, 255, 128); // from red/green/blue/alpha (transparency)
let color3 = Color::GREEN; // from one of the associated color constants

Fields

r: u8

Red component

g: u8

Green component

b: u8

Blue component

a: u8

Alpha component (transparency)

Implementations

impl Color

pub const BLACK: Self

Black predefined color

pub const WHITE: Self

White predefined color

pub const RED: Self

Red predefined color

pub const GREEN: Self

Green predefined color

pub const BLUE: Self

Blue predefined color

pub const YELLOW: Self

Yellow predefined color

pub const MAGENTA: Self

Magenta predefined color

pub const CYAN: Self

Cyan predifined color

pub const TRANSPARENT: Self

Tranparent predefined color

pub const fn rgb(red: u8, green: u8, blue: u8) -> Self

Construct a color from its 3 RGB components

Arguments

• red - Red component (0 .. 255)
• green - -Green component (0 .. 255)
• blue - Blue component (0 .. 255)

Return Color object constructed from the components

Examples found in repository

examples/custom-shape.rs (line 43)

fn hue_time(t: f32) -> Color {
    const fn lerp(from: f32, to: f32, amount: f32) -> f32 {
        from + amount * (to - from)
    }

    let frac = t.fract();

    let [r, g, b] = match (t % 6.0).floor() {
        0.0 => [255., lerp(0., 255., frac), 0.],
        1.0 => [lerp(255., 0., frac), 255., 0.],
        2.0 => [0., 255., lerp(0., 255., frac)],
        3.0 => [0., lerp(255., 0., frac), 255.],
        4.0 => [lerp(0., 255., frac), 0., 255.],
        _ => [255., 0., lerp(255., 0., frac)],
    };
    Color::rgb(r as u8, g as u8, b as u8)
}

examples/shader.rs (line 142)

    fn new() -> SfResult<Self> {
        use rand::{thread_rng, Rng};
        let mut rng = thread_rng();

        let mut points = Vec::new();
        for _ in 0..40_000 {
            let x = rng.gen_range(0.0..800.);
            let y = rng.gen_range(0.0..600.);
            let (red, green, blue) = (rng.r#gen(), rng.r#gen(), rng.r#gen());
            points.push(Vertex::with_pos_color(
                Vector2f::new(x, y),
                Color::rgb(red, green, blue),
            ));
        }

        let shader = Shader::from_file_vert_frag("storm.vert", "blink.frag")?;
        Ok(Self { points, shader })
    }
}

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

impl Effect for StormBlink {
    fn update(&mut self, t: f32, x: f32, y: f32) -> SfResult<()> {
        let radius = 200. + t.cos() * 150.;
        self.shader
            .set_uniform_vec2("storm_position", Vector2f::new(x * 800., y * 600.))?;
        self.shader
            .set_uniform_float("storm_inner_radius", radius / 3.)?;
        self.shader
            .set_uniform_float("storm_total_radius", radius)?;
        self.shader
            .set_uniform_float("blink_alpha", 0.5 + (t * 3.).cos() * 0.25)
    }
    fn name(&self) -> &str {
        "storm + blink"
    }
    fn as_drawable(&self) -> &dyn Drawable {
        self
    }
}

struct Edge<'t> {
    surface: FBox<RenderTexture>,
    bg_sprite: Sprite<'t>,
    entities: Vec<Sprite<'t>>,
    shader: FBox<Shader<'static>>,
}

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

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

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

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

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

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

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

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/custom-sound-recorder.rs (line 197)

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

    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    let mut rw = RenderWindow::new(
        (800, 600),
        "Custom sound recorder",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let (mut rec, recv) = MyRecorder::new();
    let mut samp_buf = Vec::new();
    let mut driver = SoundRecorderDriver::new(&mut rec);
    let mut started = false;
    let mut snd_buf = SoundBuffer::new()?;
    let mut samp_accum = Vec::new();
    let mut sound = Some(Sound::new());
    let mut selected_dev_idx = 0;
    let mut mode = Mode::Main;
    let mut input_buf = String::new();
    let mut desired_sample_rate = 44_100;
    let mut desired_channel_count = 2;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match mode {
                    Mode::Main => match code {
                        Key::R => {
                            if started {
                                driver.stop();
                                sound = None;
                                snd_buf.load_from_samples(
                                    &samp_accum[..],
                                    desired_channel_count,
                                    desired_sample_rate,
                                )?;
                                samp_accum.clear();
                                started = false;
                            } else {
                                driver.set_device(devices[selected_dev_idx].to_str()?)?;
                                driver.set_channel_count(desired_channel_count);
                                driver.start(desired_sample_rate)?;
                                started = true;
                            }
                        }
                        Key::P => {
                            if !started {
                                let sound = sound.insert(Sound::with_buffer(&snd_buf));
                                sound.play();
                            }
                        }
                        Key::D => mode = Mode::SetDevice,
                        Key::S => {
                            input_buf = desired_sample_rate.to_string();
                            mode = Mode::SetSampleRate;
                        }
                        Key::C => {
                            input_buf = desired_channel_count.to_string();
                            mode = Mode::SetChannelCount;
                        }
                        Key::E => {
                            input_buf = "export.wav".to_string();
                            mode = Mode::Export;
                        }
                        _ => {}
                    },
                    Mode::SetDevice => match code {
                        Key::Up => {
                            selected_dev_idx -= selected_dev_idx.saturating_sub(1);
                        }
                        Key::Down => {
                            if selected_dev_idx + 1 < devices.len() {
                                selected_dev_idx += 1;
                            }
                        }
                        Key::Enter | Key::Escape => {
                            mode = Mode::Main;
                        }
                        _ => {}
                    },
                    Mode::SetSampleRate => {
                        if code == Key::Enter {
                            desired_sample_rate = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::SetChannelCount => {
                        if code == Key::Enter {
                            desired_channel_count = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::Export => {
                        if code == Key::Enter {
                            snd_buf.save_to_file(&input_buf)?;
                            mode = Mode::Main;
                        }
                    }
                },
                Event::TextEntered { unicode } => match mode {
                    Mode::SetSampleRate | Mode::SetChannelCount => {
                        if unicode.is_ascii_digit() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Export => {
                        if !unicode.is_ascii_control() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Main | Mode::SetDevice => {}
                },
                _ => {}
            }
        }
        if let Ok(samples) = recv.try_recv() {
            samp_accum.extend_from_slice(&samples);
            samp_buf = samples;
        }
        rw.clear(Color::rgb(10, 60, 40));
        let mut writer = TextWriter::new(&font, 20, 0.0, 0.0);
        macro_rules! w {
            ($($arg:tt)*) => {
                writer.write(&format!($($arg)*), &mut rw);
            }
        }
        match mode {
            Mode::Main => {
                w!("D - set device, S - set sample rate, C - set channel count, E - export");
                let s = if started {
                    "Press R to stop recording"
                } else {
                    "Press R to start recording. Press P to play the recording."
                };
                w!("{s}");
                w!(
                    "{} @ {} Hz\n{} samples, {} channels, {} bytes recorded",
                    driver.device(),
                    driver.sample_rate(),
                    samp_buf.len(),
                    driver.channel_count(),
                    samp_accum.len() * 2,
                );
                let mut rect = RectangleShape::new();
                for (i, &sample) in samp_buf.iter().enumerate() {
                    let ratio = samp_buf.len() as f32 / rw.size().x as f32;
                    rect.set_position((i as f32 / ratio, 300.0));
                    rect.set_size((2.0, sample as f32 / 48.0));
                    rw.draw(&rect);
                }
            }
            Mode::SetDevice => {
                for (i, dev) in devices.iter().enumerate() {
                    let default_str = if dev == &*default_device {
                        " (default)"
                    } else {
                        ""
                    };
                    let color = if selected_dev_idx == i {
                        Color::YELLOW
                    } else {
                        Color::WHITE
                    };
                    writer.text.set_fill_color(color);
                    w!("{}: {}{default_str}", i + 1, dev.to_str()?);
                }
            }
            Mode::SetSampleRate => {
                w!("Enter desired sample rate");
                w!("{input_buf}");
            }
            Mode::SetChannelCount => {
                w!("Enter desired channel count");
                w!("{input_buf}");
            }
            Mode::Export => {
                w!("Enter filename to export as");
                w!("{input_buf}");
            }
        }
        rw.display();
    }
    Ok(())
}

examples/cursor.rs (line 282)

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

examples/pong.rs (line 68)

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 const fn rgba(red: u8, green: u8, blue: u8, alpha: u8) -> Self

Construct a color from its 4 RGBA components

Arguments

• red - Red component (0 .. 255)
• green - -Green component (0 .. 255)
• blue - Blue component (0 .. 255)
• alpha - Alpha component (0 .. 255)

Return Color object constructed from the components

Examples found in repository

examples/shader.rs (line 284)

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/opengl.rs (line 46)

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

Trait Implementations

impl Add for Color

fn add(self, other: Self) -> Self

Calculate the component-wise saturated addition of two colors.

type Output = Color

The resulting type after applying the + operator.

impl AddAssign for Color

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Color

fn clone(&self) -> Color

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl From<Color> for IVec4

fn from(src: Color) -> Self

Converts to this type from the input type.

impl From<Color> for Vec4

fn from(src: Color) -> Self

Converts to this type from the input type.

impl From<Color> for u32

fn from(src: Color) -> Self

Converts to this type from the input type.

impl From<u32> for Color

fn from(src: u32) -> Self

Construct the color from 32-bit unsigned integer.

The number should contain the components in RGBA order.

impl Mul for Color

fn mul(self, other: Color) -> Color

Calculate the component-wise modulated multiplication of two colors.

For each X in rgba, result.X = a.X * b.X / 255.

type Output = Color

The resulting type after applying the * operator.

impl MulAssign for Color

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PartialEq for Color

fn eq(&self, other: &Color) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for Color

fn sub(self, other: Self) -> Self

Component-wise subtraction of two colors. Components below 0 are clamped to 0.

type Output = Color

The resulting type after applying the - operator.

impl SubAssign for Color

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Color

impl Eq for Color

impl StructuralPartialEq for Color