Trait solstice_2d::SimpleConvexGeometry

pub trait SimpleConvexGeometry: Debug {
    type Vertices: Iterator<Item = Vertex2D>;
    fn vertices(&self) -> Self::Vertices;
    fn vertex_count(&self) -> usize;
}

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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, 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)>, fn(_: (f64, f64)) -> Vertex2D>

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 1]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 1]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 2]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 2]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 3]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 3]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 4]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 4]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 5]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 5]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 6]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 6]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 7]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 7]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 8]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 8]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 9]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 9]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 10]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 10]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 11]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 11]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 12]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 12]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 13]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 13]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 14]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 14]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 15]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 15]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 16]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 16]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 17]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 17]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 18]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 18]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 19]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 19]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 20]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 20]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 21]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 21]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 22]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 22]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 23]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 23]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 24]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 24]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 25]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 25]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 26]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 26]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 27]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 27]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 28]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 28]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 29]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 29]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 30]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 30]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 31]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 31]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for [Point; 32]

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for &[Point; 32]

type Vertices = Map<IntoIter<Point>, 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>, 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>

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for Circle

type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for Ellipse

type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for RegularPolygon

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

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

fn vertex_count(&self) -> usize

impl SimpleConvexGeometry for SimpleConvexPolygon

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

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

fn vertex_count(&self) -> usize