Trait solstice_2d::SimpleConvexGeometry

pub trait SimpleConvexGeometry: Debug {
    type Vertices: Iterator<Item = Vertex2D>;

    fn vertices(&self) -> Self::Vertices;
    fn vertex_count(&self) -> usize;
}

Required Associated Types

type Vertices: Iterator<Item = Vertex2D>

Required Methods

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

Implementations on Foreign Types

impl SimpleConvexGeometry for [(f32, f32); 1]

type Vertices = Map<IntoIter<(f32, f32), 1>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 1]

type Vertices = Map<IntoIter<(f32, f32), 1>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 2]

type Vertices = Map<IntoIter<(f32, f32), 2>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 2]

type Vertices = Map<IntoIter<(f32, f32), 2>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 3]

type Vertices = Map<IntoIter<(f32, f32), 3>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 3]

type Vertices = Map<IntoIter<(f32, f32), 3>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 4]

type Vertices = Map<IntoIter<(f32, f32), 4>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 4]

type Vertices = Map<IntoIter<(f32, f32), 4>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 5]

type Vertices = Map<IntoIter<(f32, f32), 5>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 5]

type Vertices = Map<IntoIter<(f32, f32), 5>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 6]

type Vertices = Map<IntoIter<(f32, f32), 6>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 6]

type Vertices = Map<IntoIter<(f32, f32), 6>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 7]

type Vertices = Map<IntoIter<(f32, f32), 7>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 7]

type Vertices = Map<IntoIter<(f32, f32), 7>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 8]

type Vertices = Map<IntoIter<(f32, f32), 8>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 8]

type Vertices = Map<IntoIter<(f32, f32), 8>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 9]

type Vertices = Map<IntoIter<(f32, f32), 9>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 9]

type Vertices = Map<IntoIter<(f32, f32), 9>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 10]

type Vertices = Map<IntoIter<(f32, f32), 10>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 10]

type Vertices = Map<IntoIter<(f32, f32), 10>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 11]

type Vertices = Map<IntoIter<(f32, f32), 11>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 11]

type Vertices = Map<IntoIter<(f32, f32), 11>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 12]

type Vertices = Map<IntoIter<(f32, f32), 12>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 12]

type Vertices = Map<IntoIter<(f32, f32), 12>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 13]

type Vertices = Map<IntoIter<(f32, f32), 13>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 13]

type Vertices = Map<IntoIter<(f32, f32), 13>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 14]

type Vertices = Map<IntoIter<(f32, f32), 14>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 14]

type Vertices = Map<IntoIter<(f32, f32), 14>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 15]

type Vertices = Map<IntoIter<(f32, f32), 15>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 15]

type Vertices = Map<IntoIter<(f32, f32), 15>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 16]

type Vertices = Map<IntoIter<(f32, f32), 16>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 16]

type Vertices = Map<IntoIter<(f32, f32), 16>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 17]

type Vertices = Map<IntoIter<(f32, f32), 17>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 17]

type Vertices = Map<IntoIter<(f32, f32), 17>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 18]

type Vertices = Map<IntoIter<(f32, f32), 18>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 18]

type Vertices = Map<IntoIter<(f32, f32), 18>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 19]

type Vertices = Map<IntoIter<(f32, f32), 19>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 19]

type Vertices = Map<IntoIter<(f32, f32), 19>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 20]

type Vertices = Map<IntoIter<(f32, f32), 20>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 20]

type Vertices = Map<IntoIter<(f32, f32), 20>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 21]

type Vertices = Map<IntoIter<(f32, f32), 21>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 21]

type Vertices = Map<IntoIter<(f32, f32), 21>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 22]

type Vertices = Map<IntoIter<(f32, f32), 22>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 22]

type Vertices = Map<IntoIter<(f32, f32), 22>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 23]

type Vertices = Map<IntoIter<(f32, f32), 23>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 23]

type Vertices = Map<IntoIter<(f32, f32), 23>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 24]

type Vertices = Map<IntoIter<(f32, f32), 24>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 24]

type Vertices = Map<IntoIter<(f32, f32), 24>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 25]

type Vertices = Map<IntoIter<(f32, f32), 25>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 25]

type Vertices = Map<IntoIter<(f32, f32), 25>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 26]

type Vertices = Map<IntoIter<(f32, f32), 26>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 26]

type Vertices = Map<IntoIter<(f32, f32), 26>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 27]

type Vertices = Map<IntoIter<(f32, f32), 27>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 27]

type Vertices = Map<IntoIter<(f32, f32), 27>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 28]

type Vertices = Map<IntoIter<(f32, f32), 28>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 28]

type Vertices = Map<IntoIter<(f32, f32), 28>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 29]

type Vertices = Map<IntoIter<(f32, f32), 29>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 29]

type Vertices = Map<IntoIter<(f32, f32), 29>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 30]

type Vertices = Map<IntoIter<(f32, f32), 30>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 30]

type Vertices = Map<IntoIter<(f32, f32), 30>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 31]

type Vertices = Map<IntoIter<(f32, f32), 31>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 31]

type Vertices = Map<IntoIter<(f32, f32), 31>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f32, f32); 32]

type Vertices = Map<IntoIter<(f32, f32), 32>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f32, f32); 32]

type Vertices = Map<IntoIter<(f32, f32), 32>, fn(_: (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 1]

type Vertices = Map<IntoIter<(f64, f64), 1>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 1]

type Vertices = Map<IntoIter<(f64, f64), 1>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 2]

type Vertices = Map<IntoIter<(f64, f64), 2>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 2]

type Vertices = Map<IntoIter<(f64, f64), 2>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 3]

type Vertices = Map<IntoIter<(f64, f64), 3>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 3]

type Vertices = Map<IntoIter<(f64, f64), 3>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 4]

type Vertices = Map<IntoIter<(f64, f64), 4>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 4]

type Vertices = Map<IntoIter<(f64, f64), 4>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 5]

type Vertices = Map<IntoIter<(f64, f64), 5>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 5]

type Vertices = Map<IntoIter<(f64, f64), 5>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 6]

type Vertices = Map<IntoIter<(f64, f64), 6>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 6]

type Vertices = Map<IntoIter<(f64, f64), 6>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 7]

type Vertices = Map<IntoIter<(f64, f64), 7>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 7]

type Vertices = Map<IntoIter<(f64, f64), 7>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 8]

type Vertices = Map<IntoIter<(f64, f64), 8>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 8]

type Vertices = Map<IntoIter<(f64, f64), 8>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 9]

type Vertices = Map<IntoIter<(f64, f64), 9>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 9]

type Vertices = Map<IntoIter<(f64, f64), 9>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 10]

type Vertices = Map<IntoIter<(f64, f64), 10>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 10]

type Vertices = Map<IntoIter<(f64, f64), 10>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 11]

type Vertices = Map<IntoIter<(f64, f64), 11>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 11]

type Vertices = Map<IntoIter<(f64, f64), 11>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 12]

type Vertices = Map<IntoIter<(f64, f64), 12>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 12]

type Vertices = Map<IntoIter<(f64, f64), 12>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 13]

type Vertices = Map<IntoIter<(f64, f64), 13>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 13]

type Vertices = Map<IntoIter<(f64, f64), 13>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 14]

type Vertices = Map<IntoIter<(f64, f64), 14>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 14]

type Vertices = Map<IntoIter<(f64, f64), 14>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 15]

type Vertices = Map<IntoIter<(f64, f64), 15>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 15]

type Vertices = Map<IntoIter<(f64, f64), 15>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 16]

type Vertices = Map<IntoIter<(f64, f64), 16>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 16]

type Vertices = Map<IntoIter<(f64, f64), 16>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 17]

type Vertices = Map<IntoIter<(f64, f64), 17>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 17]

type Vertices = Map<IntoIter<(f64, f64), 17>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 18]

type Vertices = Map<IntoIter<(f64, f64), 18>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 18]

type Vertices = Map<IntoIter<(f64, f64), 18>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 19]

type Vertices = Map<IntoIter<(f64, f64), 19>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 19]

type Vertices = Map<IntoIter<(f64, f64), 19>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 20]

type Vertices = Map<IntoIter<(f64, f64), 20>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 20]

type Vertices = Map<IntoIter<(f64, f64), 20>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 21]

type Vertices = Map<IntoIter<(f64, f64), 21>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 21]

type Vertices = Map<IntoIter<(f64, f64), 21>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 22]

type Vertices = Map<IntoIter<(f64, f64), 22>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 22]

type Vertices = Map<IntoIter<(f64, f64), 22>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 23]

type Vertices = Map<IntoIter<(f64, f64), 23>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 23]

type Vertices = Map<IntoIter<(f64, f64), 23>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 24]

type Vertices = Map<IntoIter<(f64, f64), 24>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 24]

type Vertices = Map<IntoIter<(f64, f64), 24>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 25]

type Vertices = Map<IntoIter<(f64, f64), 25>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 25]

type Vertices = Map<IntoIter<(f64, f64), 25>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 26]

type Vertices = Map<IntoIter<(f64, f64), 26>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 26]

type Vertices = Map<IntoIter<(f64, f64), 26>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 27]

type Vertices = Map<IntoIter<(f64, f64), 27>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 27]

type Vertices = Map<IntoIter<(f64, f64), 27>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 28]

type Vertices = Map<IntoIter<(f64, f64), 28>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 28]

type Vertices = Map<IntoIter<(f64, f64), 28>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 29]

type Vertices = Map<IntoIter<(f64, f64), 29>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 29]

type Vertices = Map<IntoIter<(f64, f64), 29>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 30]

type Vertices = Map<IntoIter<(f64, f64), 30>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 30]

type Vertices = Map<IntoIter<(f64, f64), 30>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 31]

type Vertices = Map<IntoIter<(f64, f64), 31>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 31]

type Vertices = Map<IntoIter<(f64, f64), 31>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [(f64, f64); 32]

type Vertices = Map<IntoIter<(f64, f64), 32>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[(f64, f64); 32]

type Vertices = Map<IntoIter<(f64, f64), 32>, fn(_: (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 1]

type Vertices = Map<IntoIter<Point, 1>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 1]

type Vertices = Map<IntoIter<Point, 1>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 2]

type Vertices = Map<IntoIter<Point, 2>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 2]

type Vertices = Map<IntoIter<Point, 2>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 3]

type Vertices = Map<IntoIter<Point, 3>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 3]

type Vertices = Map<IntoIter<Point, 3>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 4]

type Vertices = Map<IntoIter<Point, 4>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 4]

type Vertices = Map<IntoIter<Point, 4>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 5]

type Vertices = Map<IntoIter<Point, 5>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 5]

type Vertices = Map<IntoIter<Point, 5>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 6]

type Vertices = Map<IntoIter<Point, 6>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 6]

type Vertices = Map<IntoIter<Point, 6>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 7]

type Vertices = Map<IntoIter<Point, 7>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 7]

type Vertices = Map<IntoIter<Point, 7>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 8]

type Vertices = Map<IntoIter<Point, 8>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 8]

type Vertices = Map<IntoIter<Point, 8>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 9]

type Vertices = Map<IntoIter<Point, 9>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 9]

type Vertices = Map<IntoIter<Point, 9>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 10]

type Vertices = Map<IntoIter<Point, 10>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 10]

type Vertices = Map<IntoIter<Point, 10>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 11]

type Vertices = Map<IntoIter<Point, 11>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 11]

type Vertices = Map<IntoIter<Point, 11>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 12]

type Vertices = Map<IntoIter<Point, 12>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 12]

type Vertices = Map<IntoIter<Point, 12>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 13]

type Vertices = Map<IntoIter<Point, 13>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 13]

type Vertices = Map<IntoIter<Point, 13>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 14]

type Vertices = Map<IntoIter<Point, 14>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 14]

type Vertices = Map<IntoIter<Point, 14>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 15]

type Vertices = Map<IntoIter<Point, 15>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 15]

type Vertices = Map<IntoIter<Point, 15>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 16]

type Vertices = Map<IntoIter<Point, 16>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 16]

type Vertices = Map<IntoIter<Point, 16>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 17]

type Vertices = Map<IntoIter<Point, 17>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 17]

type Vertices = Map<IntoIter<Point, 17>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 18]

type Vertices = Map<IntoIter<Point, 18>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 18]

type Vertices = Map<IntoIter<Point, 18>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 19]

type Vertices = Map<IntoIter<Point, 19>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 19]

type Vertices = Map<IntoIter<Point, 19>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 20]

type Vertices = Map<IntoIter<Point, 20>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 20]

type Vertices = Map<IntoIter<Point, 20>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 21]

type Vertices = Map<IntoIter<Point, 21>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 21]

type Vertices = Map<IntoIter<Point, 21>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 22]

type Vertices = Map<IntoIter<Point, 22>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 22]

type Vertices = Map<IntoIter<Point, 22>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 23]

type Vertices = Map<IntoIter<Point, 23>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 23]

type Vertices = Map<IntoIter<Point, 23>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 24]

type Vertices = Map<IntoIter<Point, 24>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 24]

type Vertices = Map<IntoIter<Point, 24>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 25]

type Vertices = Map<IntoIter<Point, 25>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 25]

type Vertices = Map<IntoIter<Point, 25>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 26]

type Vertices = Map<IntoIter<Point, 26>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 26]

type Vertices = Map<IntoIter<Point, 26>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 27]

type Vertices = Map<IntoIter<Point, 27>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 27]

type Vertices = Map<IntoIter<Point, 27>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 28]

type Vertices = Map<IntoIter<Point, 28>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 28]

type Vertices = Map<IntoIter<Point, 28>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 29]

type Vertices = Map<IntoIter<Point, 29>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 29]

type Vertices = Map<IntoIter<Point, 29>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 30]

type Vertices = Map<IntoIter<Point, 30>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 30]

type Vertices = Map<IntoIter<Point, 30>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 31]

type Vertices = Map<IntoIter<Point, 31>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 31]

type Vertices = Map<IntoIter<Point, 31>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 32]

type Vertices = Map<IntoIter<Point, 32>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 32]

type Vertices = Map<IntoIter<Point, 32>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl<'a> SimpleConvexGeometry for &'a [Vertex2D]

type Vertices = Copied<Iter<'a, Vertex2D>>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl<'a> SimpleConvexGeometry for &'a [Point]

type Vertices = Map<Iter<'a, Point>, fn(_: &'a Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl<'a> SimpleConvexGeometry for Vec<Point>

type Vertices = Map<IntoIter<Point, Global>, fn(_: Point) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl<'a> SimpleConvexGeometry for &'a [(f32, f32)]

type Vertices = Map<Iter<'a, (f32, f32)>, fn(_: &'a (f32, f32)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

impl<'a> SimpleConvexGeometry for &'a [(f64, f64)]

type Vertices = Map<Iter<'a, (f64, f64)>, fn(_: &'a (f64, f64)) -> Vertex2D>

fn vertices(&self) -> Self::Vertices

fn vertex_count(&self) -> usize

Implementors

impl SimpleConvexGeometry for Arc

type Vertices = IntoIter<Vertex2D, Global>

impl SimpleConvexGeometry for Circle

type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices

impl SimpleConvexGeometry for Ellipse

type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices

impl SimpleConvexGeometry for RegularPolygon

type Vertices = Map<Range<u32>, Box<dyn Fn(u32) -> Vertex2D + 'static, Global>>

impl SimpleConvexGeometry for SimpleConvexPolygon

type Vertices = Map<Range<u32>, Box<dyn Fn(u32) -> Vertex2D + 'static, Global>>