rc_resources/
rc-resources.rs

1use sfml::{
2    graphics::{
3        Color, RcFont, RcSprite, RcText, RcTexture, RectangleShape, RenderTarget, RenderWindow,
4        Shape, Sprite, Texture, Transformable,
5    },
6    system::Vector2f,
7    window::{clipboard, Event, Key, Style},
8    SfResult,
9};
10
11include!("../example_common.rs");
12
13struct FloatingResource {
14    up: bool,
15    left: bool,
16    render_sprite: bool,
17    sprite: RcSprite,
18    text: RcText,
19    speed: f32,
20}
21
22impl FloatingResource {
23    fn with_texture(texture: &RcTexture, up: bool, left: bool, speed: f32) -> Self {
24        Self {
25            up,
26            left,
27            sprite: RcSprite::with_texture(texture),
28            text: Default::default(),
29            speed,
30            render_sprite: true,
31        }
32    }
33
34    fn with_font(font: &RcFont, up: bool, left: bool, speed: f32) -> Self {
35        let mut self_ = Self {
36            up,
37            left,
38            sprite: Default::default(),
39            text: RcText::new("", font, 16),
40            speed,
41            render_sprite: false,
42        };
43        self_.text.scale(Vector2f::new(2., 2.));
44
45        self_
46    }
47
48    fn render(&self, window: &mut RenderWindow) {
49        if self.render_sprite {
50            window.draw(&self.sprite)
51        } else {
52            window.draw(&self.text)
53        }
54    }
55
56    fn move_resources(&mut self, window_size: Vector2f) {
57        if self.render_sprite {
58            // Modify the sprite position freely
59            if self.sprite.position().y <= 0f32 {
60                self.up = false;
61            }
62            if self.sprite.position().y + self.sprite.global_bounds().height >= window_size.y {
63                self.up = true;
64            }
65            if self.sprite.position().x <= 0f32 {
66                self.left = false;
67            }
68            if self.sprite.position().x + self.sprite.global_bounds().width >= window_size.x {
69                self.left = true;
70            }
71
72            self.sprite.set_position(
73                self.sprite.position()
74                    + Vector2f::new(
75                        if self.left { -self.speed } else { self.speed },
76                        if self.up { -self.speed } else { self.speed },
77                    ),
78            );
79        } else {
80            // Modify the sprite position freely
81            if self.text.position().y <= 0f32 {
82                self.up = false;
83            }
84            if self.text.position().y + self.text.global_bounds().height >= window_size.y {
85                self.up = true;
86            }
87            if self.text.position().x <= 0f32 {
88                self.left = false;
89            }
90            if self.text.position().x + self.text.global_bounds().width >= window_size.x {
91                self.left = true;
92            }
93
94            self.text.set_position(
95                self.text.position()
96                    + Vector2f::new(
97                        if self.left { -self.speed } else { self.speed },
98                        if self.up { -self.speed } else { self.speed },
99                    ),
100            );
101        }
102    }
103}
104
105fn test_getting_rc_texture_from_texture() -> SfResult<RcTexture> {
106    Ok(RcTexture::from_texture(Texture::from_file("frank.jpeg")?))
107}
108
109fn get_set_smooth_rc_text(font: &RcFont) -> RcText {
110    let mut set_smooth_text = RcText::new(
111        "Press 's' to enable/disable font smoothing\n\
112         Press 't' to toggle showing font texture atlas",
113        font,
114        16,
115    );
116    set_smooth_text.scale(Vector2f::new(2., 2.));
117
118    set_smooth_text
119}
120
121fn main() -> SfResult<()> {
122    example_ensure_right_working_dir();
123
124    let mut window =
125        RenderWindow::new((800, 600), "SFML window", Style::CLOSE, &Default::default())?;
126    window.set_framerate_limit(60);
127
128    // Create a new texture.
129    let texture = RcTexture::from_file("logo.png")?;
130    let texture2 = test_getting_rc_texture_from_texture()?;
131
132    // Create a new font.
133    let font_path = match std::env::args().nth(1) {
134        Some(path) => path,
135        None => "sansation.ttf".into(),
136    };
137    let mut font = RcFont::from_file(&font_path)?;
138
139    // Load many resources with no lifetime contingencies
140    let mut floating_resources = Vec::from([
141        FloatingResource::with_texture(&texture2, true, true, 1.1f32),
142        FloatingResource::with_texture(&texture2, true, true, 1.2f32),
143        FloatingResource::with_texture(&texture, true, true, 1f32),
144        FloatingResource::with_texture(&texture, true, false, 1.5f32),
145        FloatingResource::with_texture(&texture, false, true, 2f32),
146        FloatingResource::with_texture(&texture, false, false, 2.5f32),
147        FloatingResource::with_font(&font, true, true, 1.25f32),
148        FloatingResource::with_font(&font, true, true, 1.75f32),
149        FloatingResource::with_font(&font, true, true, 2.25f32),
150        FloatingResource::with_font(&font, true, true, 2.75f32),
151    ]);
152
153    let set_smooth_text = get_set_smooth_rc_text(&font);
154    let mut show_texture_atlas = false;
155    let mut text_buf = String::from("SFML");
156
157    while window.is_open() {
158        while let Some(event) = window.poll_event() {
159            if event == Event::Closed {
160                window.close();
161            }
162
163            match event {
164                Event::Closed => window.close(),
165                Event::KeyPressed { code, ctrl, .. } => match code {
166                    Key::S => {
167                        let smooth = !font.is_smooth();
168                        font.set_smooth(smooth);
169                    }
170                    Key::T => {
171                        show_texture_atlas ^= true;
172                    }
173                    Key::V if ctrl => {
174                        text_buf.push_str(&clipboard::get_string());
175                    }
176                    _ => {}
177                },
178                Event::TextEntered { unicode } if show_texture_atlas => {
179                    if unicode == 0x8 as char {
180                        text_buf.pop();
181                    } else if !unicode.is_ascii_control() && unicode != 's' && unicode != 't' {
182                        text_buf.push(unicode);
183                    }
184                }
185                _ => {}
186            }
187        }
188
189        // Update floating_resource positions so they move around on the screen
190        for floating_resource in &mut floating_resources {
191            floating_resource.move_resources(Vector2f::new(800f32, 600f32));
192            floating_resource.text.set_string(&text_buf);
193        }
194
195        window.clear(Color::BLACK);
196
197        // Fetch and draw all the sprites in floating_resources
198        for floating_resource in &floating_resources {
199            floating_resource.render(&mut window);
200        }
201
202        window.draw(&set_smooth_text);
203        if show_texture_atlas {
204            let scale = 3.0;
205            let tex = font.texture(16);
206            let mut rs = RectangleShape::with_size(tex.size().as_other());
207            rs.set_fill_color(Color::MAGENTA);
208            rs.set_scale(scale);
209            window.draw(&rs);
210            let mut s = Sprite::with_texture(&*tex);
211            s.set_scale(scale);
212            window.draw(&s);
213        }
214        window.display();
215    }
216    Ok(())
217}