Trait SimpleConvexGeometry 

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

    // Required methods
    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

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 32]

type Vertices = Map<IntoIter<Point, 32>, fn(Point) -> 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 [(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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 [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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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<'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

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 &'a [Vertex2D]

type Vertices = Copied<Iter<'a, 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

Implementors

impl SimpleConvexGeometry for Arc

type Vertices = IntoIter<Vertex2D>

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>>

impl SimpleConvexGeometry for SimpleConvexPolygon

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