use crate::{
ffi::graphics as ffi,
graphics::{
Color, Drawable, FloatRect, IntRect, RenderStates, RenderTarget, Shape, Texture, Transform,
Transformable,
},
system::Vector2f,
};
use std::{marker::PhantomData, ptr};
#[derive(Debug)]
pub struct RectangleShape<'s> {
rectangle_shape: *mut ffi::sfRectangleShape,
texture: PhantomData<&'s Texture>,
}
impl<'s> RectangleShape<'s> {
#[must_use]
pub fn new() -> RectangleShape<'s> {
let rectangle = unsafe { ffi::sfRectangleShape_create() };
assert!(!rectangle.is_null(), "Failed to create RectangleShape");
RectangleShape {
rectangle_shape: rectangle,
texture: PhantomData,
}
}
#[must_use]
pub fn with_texture(texture: &'s Texture) -> RectangleShape<'s> {
let mut shape = Self::new();
shape.set_texture(texture, true);
shape
}
#[must_use]
pub fn with_size(size: Vector2f) -> RectangleShape<'s> {
let mut shape = Self::new();
shape.set_size(size);
shape
}
#[must_use]
pub fn from_rect(rect: FloatRect) -> Self {
let mut shape = Self::new();
shape.set_size((rect.width, rect.height));
shape.set_position((rect.left, rect.top));
shape
}
#[must_use]
pub fn size(&self) -> Vector2f {
unsafe { ffi::sfRectangleShape_getSize(self.rectangle_shape) }
}
pub fn set_size<S: Into<Vector2f>>(&mut self, size: S) {
unsafe { ffi::sfRectangleShape_setSize(self.rectangle_shape, size.into()) }
}
pub(super) fn raw(&self) -> *const ffi::sfRectangleShape {
self.rectangle_shape
}
}
impl<'s> Default for RectangleShape<'s> {
fn default() -> Self {
Self::new()
}
}
impl<'s> Drawable for RectangleShape<'s> {
fn draw<'a: 'shader, 'texture, 'shader, 'shader_texture>(
&'a self,
target: &mut dyn RenderTarget,
states: &RenderStates<'texture, 'shader, 'shader_texture>,
) {
target.draw_rectangle_shape(self, states);
}
}
impl<'s> Transformable for RectangleShape<'s> {
fn set_position<P: Into<Vector2f>>(&mut self, position: P) {
unsafe { ffi::sfRectangleShape_setPosition(self.rectangle_shape, position.into()) }
}
fn set_rotation(&mut self, angle: f32) {
unsafe { ffi::sfRectangleShape_setRotation(self.rectangle_shape, angle) }
}
fn set_scale<S: Into<Vector2f>>(&mut self, scale: S) {
unsafe { ffi::sfRectangleShape_setScale(self.rectangle_shape, scale.into()) }
}
fn set_origin<O: Into<Vector2f>>(&mut self, origin: O) {
unsafe { ffi::sfRectangleShape_setOrigin(self.rectangle_shape, origin.into()) }
}
fn position(&self) -> Vector2f {
unsafe { ffi::sfRectangleShape_getPosition(self.rectangle_shape) }
}
fn rotation(&self) -> f32 {
unsafe { ffi::sfRectangleShape_getRotation(self.rectangle_shape) }
}
fn get_scale(&self) -> Vector2f {
unsafe { ffi::sfRectangleShape_getScale(self.rectangle_shape) }
}
fn origin(&self) -> Vector2f {
unsafe { ffi::sfRectangleShape_getOrigin(self.rectangle_shape) }
}
fn move_<O: Into<Vector2f>>(&mut self, offset: O) {
unsafe { ffi::sfRectangleShape_move(self.rectangle_shape, offset.into()) }
}
fn rotate(&mut self, angle: f32) {
unsafe { ffi::sfRectangleShape_rotate(self.rectangle_shape, angle) }
}
fn scale<F: Into<Vector2f>>(&mut self, factors: F) {
unsafe { ffi::sfRectangleShape_scale(self.rectangle_shape, factors.into()) }
}
fn transform(&self) -> &Transform {
unsafe { &*ffi::sfRectangleShape_getTransform(self.rectangle_shape) }
}
fn inverse_transform(&self) -> &Transform {
unsafe { &*ffi::sfRectangleShape_getInverseTransform(self.rectangle_shape) }
}
}
impl<'s> Shape<'s> for RectangleShape<'s> {
fn set_texture(&mut self, texture: &'s Texture, reset_rect: bool) {
unsafe { ffi::sfRectangleShape_setTexture(self.rectangle_shape, texture, reset_rect) }
}
fn disable_texture(&mut self) {
unsafe { ffi::sfRectangleShape_setTexture(self.rectangle_shape, ptr::null_mut(), true) }
}
fn set_texture_rect(&mut self, rect: IntRect) {
unsafe { ffi::sfRectangleShape_setTextureRect(self.rectangle_shape, rect) }
}
fn set_fill_color(&mut self, color: Color) {
unsafe { ffi::sfRectangleShape_setFillColor(self.rectangle_shape, color) }
}
fn set_outline_color(&mut self, color: Color) {
unsafe { ffi::sfRectangleShape_setOutlineColor(self.rectangle_shape, color) }
}
fn set_outline_thickness(&mut self, thickness: f32) {
unsafe { ffi::sfRectangleShape_setOutlineThickness(self.rectangle_shape, thickness) }
}
fn texture(&self) -> Option<&'s Texture> {
unsafe { ffi::sfRectangleShape_getTexture(self.rectangle_shape).as_ref() }
}
fn texture_rect(&self) -> IntRect {
unsafe { ffi::sfRectangleShape_getTextureRect(self.rectangle_shape) }
}
fn fill_color(&self) -> Color {
unsafe { ffi::sfRectangleShape_getFillColor(self.rectangle_shape) }
}
fn outline_color(&self) -> Color {
unsafe { ffi::sfRectangleShape_getOutlineColor(self.rectangle_shape) }
}
fn outline_thickness(&self) -> f32 {
unsafe { ffi::sfRectangleShape_getOutlineThickness(self.rectangle_shape) }
}
fn point_count(&self) -> usize {
unsafe { ffi::sfRectangleShape_getPointCount(self.rectangle_shape) }
}
fn point(&self, index: usize) -> Vector2f {
unsafe { ffi::sfRectangleShape_getPoint(self.rectangle_shape, index) }
}
fn local_bounds(&self) -> FloatRect {
unsafe { ffi::sfRectangleShape_getLocalBounds(self.rectangle_shape) }
}
fn global_bounds(&self) -> FloatRect {
unsafe { ffi::sfRectangleShape_getGlobalBounds(self.rectangle_shape) }
}
}
impl<'s> Clone for RectangleShape<'s> {
fn clone(&self) -> RectangleShape<'s> {
let rectangle = unsafe { ffi::sfRectangleShape_copy(self.rectangle_shape) };
if rectangle.is_null() {
panic!("Not enough memory to clone RectangleShape")
} else {
RectangleShape {
rectangle_shape: rectangle,
texture: self.texture,
}
}
}
}
impl<'s> Drop for RectangleShape<'s> {
fn drop(&mut self) {
unsafe { ffi::sfRectangleShape_destroy(self.rectangle_shape) }
}
}