Trait solstice_2d::SimpleConvexGeometry[−][src]

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>`[src]

Loading content...

Required methods

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

Loading content...

Implementations on Foreign Types

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 1]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 1]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 2]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 2]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 3]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 3]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 4]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 4]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 5]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 5]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 6]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 6]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 7]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 7]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 8]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 8]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 9]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 9]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 10]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 10]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 11]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 11]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 12]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 12]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 13]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 13]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 14]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 14]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 15]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 15]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 16]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 16]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 17]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 17]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 18]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 18]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 19]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 19]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 20]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 20]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 21]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 21]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 22]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 22]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 23]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 23]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 24]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 24]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 25]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 25]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 26]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 26]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 27]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 27]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 28]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 28]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 29]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 29]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 30]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 30]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 31]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 31]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for [Point; 32]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for &[Point; 32]`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl<'a> SimpleConvexGeometry for Vec<Point>`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

Loading content...

Implementors

`impl SimpleConvexGeometry for Arc`[src]

`type Vertices = IntoIter<Vertex2D>`

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for Circle`[src]

`type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices`

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for Ellipse`[src]

`type Vertices = <SimpleConvexPolygon as SimpleConvexGeometry>::Vertices`

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for RegularPolygon`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

`impl SimpleConvexGeometry for SimpleConvexPolygon`[src]

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

Loading content...

Trait solstice_2d::SimpleConvexGeometry⎘[−][src]

Associated Types

type Vertices: Iterator<Item = Vertex2D>[src]

Required methods

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

Implementations on Foreign Types

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

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

fn vertices(&self) -> Self::Vertices[src]

fn vertex_count(&self) -> usize[src]

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

Trait solstice_2d::SimpleConvexGeometry[−][src]

`type Vertices: Iterator<Item = Vertex2D>`[src]

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]

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

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

`fn vertices(&self) -> Self::Vertices`[src]

`fn vertex_count(&self) -> usize`[src]