1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
use crate::{
ffi::graphics as ffi,
graphics::{
Color, Drawable, FloatRect, IntRect, RenderStates, RenderTarget, Texture, Transform,
Transformable,
},
system::Vector2f,
};
use std::{marker::PhantomData, ptr::NonNull};
/// Drawable representation of a texture
///
/// Sprite is a drawable type that allows to easily
/// display a [`Texture`] (or a part of it) on a render target.
///
/// __Note:__
/// Currently, it is not feasible to store sprites long term.
/// A common pattern with rust-sfml is to create a `Sprite` right before you start drawing,
/// and draw all the sprites you want with it. You can change its properties using
/// `set_texture`, `set_position`, etc., before drawing it, as many times as you need to.
#[derive(Debug)]
pub struct Sprite<'s> {
sprite: NonNull<ffi::sfSprite>,
texture: PhantomData<&'s Texture>,
}
impl<'s> Sprite<'s> {
/// Create a new sprite
#[must_use]
pub fn new() -> Sprite<'s> {
let sp = unsafe { ffi::sfSprite_create() };
Sprite {
sprite: NonNull::new(sp).expect("Failed to create Sprite"),
texture: PhantomData,
}
}
/// Create a new sprite with a texture
#[must_use]
pub fn with_texture(texture: &'s Texture) -> Sprite<'s> {
let mut sprite = Sprite::new();
sprite.set_texture(texture, true);
sprite
}
/// Create a new sprite with a texture and a source rectangle
#[must_use]
pub fn with_texture_and_rect(texture: &'s Texture, rect: IntRect) -> Self {
let mut sprite = Sprite::with_texture(texture);
sprite.set_texture_rect(rect);
sprite
}
/// Change the source texture of a sprite
///
/// The texture argument refers to a texture that must
/// exist as long as the sprite uses it. Indeed, the sprite
/// doesn't store its own copy of the texture, but rather keeps
/// a pointer to the one that you passed to this function.
/// If the source texture is destroyed and the sprite tries to
/// use it, the behaviour is undefined.
/// If `reset_rect` is true, the [`texture_rect`] property of
/// the sprite is automatically adjusted to the size of the new
/// texture. If it is false, the texture rect is left unchanged.
///
/// [`texture_rect`]: Sprite::texture_rect
///
/// # Arguments
/// * `texture` - New texture
/// * `reset_rect` - Should the texture rect be reset to the size
/// of the new texture?
pub fn set_texture(&mut self, texture: &'s Texture, reset_rect: bool) {
unsafe { ffi::sfSprite_setTexture(self.sprite.as_ptr(), texture, reset_rect) }
}
/// Set the global color of a sprite
///
/// This color is modulated (multiplied) with the sprite's
/// texture. It can be used to colorize the sprite, or change
/// its global opacity.
/// By default, the sprite's color is opaque white.
///
/// # Arguments
/// * color - New color of the sprite
pub fn set_color(&mut self, color: Color) {
unsafe { ffi::sfSprite_setColor(self.sprite.as_ptr(), color) }
}
/// Get the source texture of a sprite
///
/// If the sprite has no source texture, None is returned.
/// You can't
/// modify the texture when you retrieve it with this function.
///
/// Return an Option to the sprite's texture
#[must_use]
pub fn texture(&self) -> Option<&'s Texture> {
unsafe { ffi::sfSprite_getTexture(self.sprite.as_ptr()).as_ref() }
}
/// Get the global color of a sprite
///
/// Return the global color of the sprite
#[must_use]
pub fn color(&self) -> Color {
unsafe { ffi::sfSprite_getColor(self.sprite.as_ptr()) }
}
/// Get the local bounding rectangle of a sprite
///
/// The returned rectangle is in local coordinates, which means
/// that it ignores the transformations (translation, rotation,
/// scale, ...) that are applied to the entity.
/// In other words, this function returns the bounds of the
/// entity in the entity's coordinate system.
///
/// Return the local bounding rectangle of the entity
#[must_use]
pub fn local_bounds(&self) -> FloatRect {
unsafe { ffi::sfSprite_getLocalBounds(self.sprite.as_ptr()) }
}
/// Get the global bounding rectangle of a sprite
///
/// The returned rectangle is in global coordinates, which means
/// that it takes in account the transformations (translation,
/// rotation, scale, ...) that are applied to the entity.
/// In other words, this function returns the bounds of the
/// sprite in the global 2D world's coordinate system.
///
/// Return the global bounding rectangle of the entity
#[must_use]
pub fn global_bounds(&self) -> FloatRect {
unsafe { ffi::sfSprite_getGlobalBounds(self.sprite.as_ptr()) }
}
/// Get the sub-rectangle of the texture displayed by a sprite
///
/// Return the texture rectangle of the sprite
#[must_use]
pub fn texture_rect(&self) -> IntRect {
unsafe { ffi::sfSprite_getTextureRect(self.sprite.as_ptr()) }
}
/// Set the sub-rectangle of the texture that a sprite will display
///
/// The texture rect is useful when you don't want to display
/// the whole texture, but rather a part of it.
/// By default, the texture rect covers the entire texture.
///
/// # Arguments
/// * rectangle - Rectangle defining the region of the texture to display
pub fn set_texture_rect(&mut self, rect: IntRect) {
unsafe { ffi::sfSprite_setTextureRect(self.sprite.as_ptr(), rect) }
}
pub(super) fn raw(&self) -> *const ffi::sfSprite {
self.sprite.as_ptr()
}
}
impl<'s> Default for Sprite<'s> {
fn default() -> Self {
Self::new()
}
}
impl<'s> Clone for Sprite<'s> {
/// Return a new Sprite or panic! if there is not enough memory
fn clone(&self) -> Sprite<'s> {
let sp = unsafe { ffi::sfSprite_copy(self.sprite.as_ptr()) };
Sprite {
sprite: NonNull::new(sp).expect("Failed to copy Sprite"),
texture: PhantomData,
}
}
}
impl<'s> Drawable for Sprite<'s> {
fn draw<'a: 'shader, 'texture, 'shader, 'shader_texture>(
&'a self,
target: &mut dyn RenderTarget,
states: &RenderStates<'texture, 'shader, 'shader_texture>,
) {
target.draw_sprite(self, states)
}
}
impl<'s> Transformable for Sprite<'s> {
fn set_position<P: Into<Vector2f>>(&mut self, position: P) {
unsafe { ffi::sfSprite_setPosition(self.sprite.as_ptr(), position.into()) }
}
fn set_rotation(&mut self, angle: f32) {
unsafe { ffi::sfSprite_setRotation(self.sprite.as_ptr(), angle) }
}
fn set_scale<S: Into<Vector2f>>(&mut self, scale: S) {
unsafe { ffi::sfSprite_setScale(self.sprite.as_ptr(), scale.into()) }
}
fn set_origin<O: Into<Vector2f>>(&mut self, origin: O) {
unsafe { ffi::sfSprite_setOrigin(self.sprite.as_ptr(), origin.into()) }
}
fn position(&self) -> Vector2f {
unsafe { ffi::sfSprite_getPosition(self.sprite.as_ptr()) }
}
fn rotation(&self) -> f32 {
unsafe { ffi::sfSprite_getRotation(self.sprite.as_ptr()) }
}
fn get_scale(&self) -> Vector2f {
unsafe { ffi::sfSprite_getScale(self.sprite.as_ptr()) }
}
fn origin(&self) -> Vector2f {
unsafe { ffi::sfSprite_getOrigin(self.sprite.as_ptr()) }
}
fn move_<O: Into<Vector2f>>(&mut self, offset: O) {
unsafe { ffi::sfSprite_move(self.sprite.as_ptr(), offset.into()) }
}
fn rotate(&mut self, angle: f32) {
unsafe { ffi::sfSprite_rotate(self.sprite.as_ptr(), angle) }
}
fn scale<F: Into<Vector2f>>(&mut self, factors: F) {
unsafe { ffi::sfSprite_scale(self.sprite.as_ptr(), factors.into()) }
}
fn transform(&self) -> &Transform {
unsafe { &*ffi::sfSprite_getTransform(self.sprite.as_ptr()) }
}
fn inverse_transform(&self) -> &Transform {
unsafe { &*ffi::sfSprite_getInverseTransform(self.sprite.as_ptr()) }
}
}
impl<'s> Drop for Sprite<'s> {
fn drop(&mut self) {
unsafe { ffi::sfSprite_destroy(self.sprite.as_ptr()) }
}
}