Struct nannou::draw::primitive::mesh::Vertexless

pub struct Vertexless;

The mesh type prior to being initialised with vertices or indices.

Implementations

impl Vertexless

pub fn points_textured<S, I, P, T>(
    self,
    inner_mesh: &mut Mesh<S>,
    texture_view: &dyn ToTextureView,
    points: I
) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, T)>,
    P: Into<Point<S>>,
    T: Into<TexCoords<S>>, 

Describe the mesh with a sequence of textured points.

Each of the vertices must be represented as a tuple containing the point and tex coordinates in that order, e.g. (point, tex_coords). point may be of any type that implements Into<Point3> and tex_coords may be of any type that implements Into<Point2>.

pub fn points_colored<S, I, P, C>(
    self,
    inner_mesh: &mut Mesh<S>,
    points: I
) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, C)>,
    P: Into<Point<S>>,
    C: IntoLinSrgba<ColorScalar>, 

Describe the mesh with a sequence of colored points.

Each of the points must be represented as a tuple containing the point and the color in that order, e.g. (point, color). point may be of any type that implements Into<Point3> and color may be of any type that implements IntoLinSrgba.

pub fn points<S, I>(self, inner_mesh: &mut Mesh<S>, points: I) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator,
    I::Item: Into<Point<S>>, 

Describe the mesh with a sequence of points.

The given iterator may yield any type that can be converted directly into Point3s.

This method assumes that the entire mesh should be coloured with a single colour. If a colour is not specified via one of the builder methods, a default colour will be retrieved from the inner Theme.

pub fn tris_textured<S, I, P, T>(
    self,
    inner_mesh: &mut Mesh<S>,
    texture_view: &dyn ToTextureView,
    tris: I
) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator<Item = Tri<(P, T)>>,
    P: Into<Point<S>>,
    T: Into<TexCoords<S>>, 

Describe the mesh with a sequence of textured triangles.

Each of the vertices must be represented as a tuple containing the point and tex coordinates in that order, e.g. (point, tex_coords). point may be of any type that implements Into<Point3> and tex_coords may be of any type that implements Into<Point2>.

pub fn tris_colored<S, I, P, C>(
    self,
    inner_mesh: &mut Mesh<S>,
    tris: I
) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator<Item = Tri<(P, C)>>,
    P: Into<Point<S>>,
    C: IntoLinSrgba<ColorScalar>, 

Describe the mesh with a sequence of colored triangles.

Each of the vertices must be represented as a tuple containing the point and the color in that order, e.g. (point, color). point may be of any type that implements Into<Point3> and color may be of any type that implements IntoLinSrgba.

pub fn tris<S, I, V>(self, inner_mesh: &mut Mesh<S>, tris: I) -> Mesh<S> where
    S: BaseFloat,
    I: IntoIterator<Item = Tri<V>>,
    V: Into<Point<S>>, 

Describe the mesh with a sequence of triangles.

Each triangle may be composed of any vertex type that may be converted directly into Point3s.

This method assumes that the entire mesh should be coloured with a single colour. If a colour is not specified via one of the builder methods, a default colour will be retrieved from the inner Theme.

pub fn indexed_textured<S, V, I, P, T>(
    self,
    inner_mesh: &mut Mesh<S>,
    texture_view: &dyn ToTextureView,
    points: V,
    indices: I
) -> Mesh<S> where
    S: BaseFloat,
    V: IntoIterator<Item = (P, T)>,
    I: IntoIterator<Item = usize>,
    P: Into<Point<S>>,
    T: Into<TexCoords<S>>, 

Describe the mesh with the given indexed, textured points.

Each trio of indices describes a single triangle made up of colored points.

Each of the points must be represented as a tuple containing the point and the texture coordinates in that order, e.g. (point, tex_coords). point may be of any type that implements Into<Point3> and tex_coords may be of any type that implements Into<Point2>.

pub fn indexed_colored<S, V, I, P, C>(
    self,
    inner_mesh: &mut Mesh<S>,
    points: V,
    indices: I
) -> Mesh<S> where
    S: BaseFloat,
    V: IntoIterator<Item = (P, C)>,
    I: IntoIterator<Item = usize>,
    P: Into<Point<S>>,
    C: IntoLinSrgba<ColorScalar>, 

Describe the mesh with the given indexed, colored points.

Each trio of indices describes a single triangle made up of colored points.

Each of the points must be represented as a tuple containing the point and the color in that order, e.g. (point, color). point may be of any type that implements Into<Point3> and color may be of any type that implements IntoLinSrgba.

pub fn indexed<S, V, I>(
    self,
    inner_mesh: &mut Mesh<S>,
    points: V,
    indices: I
) -> Mesh<S> where
    S: BaseFloat,
    V: IntoIterator,
    V::Item: Into<Point<S>>,
    I: IntoIterator<Item = usize>, 

Describe the mesh with the given indexed points.

Each trio of indices describes a single triangle made up of points.

Each point may be any type that may be converted directly into the Point3 type.

Trait Implementations

impl Clone for Vertexless

fn clone(&self) -> Vertexless

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vertexless

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

Formats the value using the given formatter.

impl Default for Vertexless

fn default() -> Vertexless

Returns the “default value” for a type.

impl<S> From<Vertexless> for Primitive<S>

fn from(prim: Vertexless) -> Self

Performs the conversion.