Struct Polygon 

pub struct Polygon<T>(/* private fields */);

A convex polygon.

The N represents how many points the polygon can have before it needs to allocate onto the heap. If you know your shapes will never have more than N edges, you can set it to that value and avoid heap allocations.

Implementations

impl<T: Num> Polygon<T>

pub fn new() -> Self

Creates a new empty polygon.

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty polygon with at least the specified capacity.

pub fn from_arr<const LEN: usize>(arr: [Vec2<T>; LEN]) -> Self

Create a new polygon using the array of points.

pub fn from_slice<const LEN: usize>(slice: &[Vec2<T>]) -> Self

Create a new polygon using the slice of points.

pub fn from_vec(vec: Vec<Vec2<T>>) -> Self

Create a new polygon using the array of points.

pub fn from_rect(rect: Rect<T>) -> Self

pub fn from_tri(tri: Triangle<T>) -> Self

Create a polygon representation of the provided triangle.

pub fn from_quad(quad: Quad<T>) -> Self

Create a polygon representation of the provided quad.

pub fn len(&self) -> usize

How many points the polygon has.

pub fn is_empty(&self) -> bool

If the polygon has no points.

pub fn capacity(&self) -> usize

The polygon’s allocated capacity.

pub fn push(&mut self, p: Vec2<T>)

Add a point to the polygon.

pub fn pop(&mut self) -> Option<Vec2<T>>

Remove the last point from the polygon and return it.

pub fn reserve(&mut self, capacity: usize)

Reserve enough space for at least capacity points.

pub fn points(&self) -> &[Vec2<T>]

Reference to the polygon’s points.

pub fn points_mut(&mut self) -> &mut [Vec2<T>]

Mutable reference to the polygon’s points.

pub fn clear(&mut self)

Remove all points from the polygon.

pub fn remove(&mut self, index: usize) -> Vec2<T>

Remove the point at index.

pub fn insert(&mut self, index: usize, p: Vec2<T>)

Insert a point at index.

pub fn to_vec(self) -> Vec<Vec2<T>>

Convert the polygon into a Vec of points.

pub fn resize_with<F: FnMut() -> Vec2<T>>(&mut self, new_size: usize, f: F)

Resize the polygon, using the provided function to create new points.

pub fn translate(&mut self, amount: Vec2<T>)

Translate all points in the polygon.

pub fn edge(&self, index: usize) -> Option<Line<T>>

Get the nth edge of the polygon. A polygon has the same amount of edges as vertices, so if this index exceeds len(), then None will be returned.

pub fn edges(&self) -> impl Iterator<Item = Line<T>> + '_

An iterator over all the polygon’s edges.

impl<T: Float> Polygon<T>

pub fn transform_in_place_by(&mut self, f: impl FnMut(Vec2<T>) -> Vec2<T>)

pub fn transform_by_into( &self, into: &mut Self, f: impl FnMut(Vec2<T>) -> Vec2<T>, )

pub fn transform_by(&self, f: impl FnMut(Vec2<T>) -> Vec2<T>) -> Self

Trait Implementations

impl<T> AsMut<[Vec2<T>]> for Polygon<T>

fn as_mut(&mut self) -> &mut [Vec2<T>]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<[Vec2<T>]> for Polygon<T>

fn as_ref(&self) -> &[Vec2<T>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Polygon<T>

fn clone(&self) -> Polygon<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Polygon<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Polygon<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Num> Extend<Vec2<T>> for Polygon<T>

fn extend<I: IntoIterator<Item = Vec2<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: Num, const S: usize> From<[Vec2<T>; S]> for Polygon<T>

fn from(value: [Vec2<T>; S]) -> Self

Converts to this type from the input type.

impl<T> From<Polygon<T>> for DynShape<T>

fn from(value: Polygon<T>) -> Self

Converts to this type from the input type.

impl<T: Num> From<Quad<T>> for Polygon<T>

fn from(value: Quad<T>) -> Self

Converts to this type from the input type.

impl<T: Num> From<Rect<T>> for Polygon<T>

fn from(value: Rect<T>) -> Self

Converts to this type from the input type.

impl<T: Num> From<Triangle<T>> for Polygon<T>

fn from(value: Triangle<T>) -> Self

Converts to this type from the input type.

impl<T: Num> From<Vec<Vec2<T>>> for Polygon<T>

fn from(value: Vec<Vec2<T>>) -> Self

Converts to this type from the input type.

impl<T: Num> FromIterator<Vec2<T>> for Polygon<T>

fn from_iter<I: IntoIterator<Item = Vec2<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> IntoIterator for Polygon<T>

type Item = Vec2<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<Vec2<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Num> Numeric for Polygon<T>

type AsU8 = Polygon<u8>

type AsU16 = Polygon<u16>

type AsU32 = Polygon<u32>

type AsU64 = Polygon<u64>

type AsU128 = Polygon<u128>

type AsUSize = Polygon<usize>

type AsI8 = Polygon<i8>

type AsI16 = Polygon<i16>

type AsI32 = Polygon<i32>

type AsI64 = Polygon<i64>

type AsI128 = Polygon<i128>

type AsISize = Polygon<isize>

type AsF32 = Polygon<f32>

type AsF64 = Polygon<f64>

fn to_u8(self) -> Self::AsU8

fn to_u16(self) -> Self::AsU16

fn to_u32(self) -> Self::AsU32

fn to_u64(self) -> Self::AsU64

fn to_u128(self) -> Self::AsU128

fn to_usize(self) -> Self::AsUSize

fn to_i8(self) -> Self::AsI8

fn to_i16(self) -> Self::AsI16

fn to_i32(self) -> Self::AsI32

fn to_i64(self) -> Self::AsI64

fn to_i128(self) -> Self::AsI128

fn to_isize(self) -> Self::AsISize

fn to_f32(self) -> Self::AsF32

fn to_f64(self) -> Self::AsF64

impl<T: PartialEq> PartialEq for Polygon<T>

fn eq(&self, other: &Polygon<T>) -> 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<T> Serialize for Polygon<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Polygon<T>