Struct rendy_mesh::MeshBuilder

pub struct MeshBuilder<'a> { /* fields omitted */ }

Generics-free mesh builder.

Methods

impl<'a> MeshBuilder<'a>

pub fn new() -> Self

Create empty builder.

pub fn into_owned(self) -> MeshBuilder<'static>

Convert builder into fully owned type. This forces internal vertex and index buffers to be cloned, which allows borrowed source buffers to be released.

pub fn with_indices<I>(self, indices: I) -> Self where
    I: Into<Indices<'a>>, 

Set indices buffer to the MeshBuilder

pub fn set_indices<I>(&mut self, indices: I) -> &mut Self where
    I: Into<Indices<'a>>, 

Set indices buffer to the MeshBuilder

pub fn with_vertices<V, D>(self, vertices: D) -> Self where
    V: AsVertex + 'a,
    D: Into<Cow<'a, [V]>>, 

Add another vertices to the MeshBuilder

pub fn add_vertices<V, D>(&mut self, vertices: D) -> &mut Self where
    V: AsVertex + 'a,
    D: Into<Cow<'a, [V]>>, 

Add another vertices to the MeshBuilder

pub fn with_prim_type(self, prim: Primitive) -> Self

Sets the primitive type of the mesh.

By default, meshes are constructed as triangle lists.

pub fn set_prim_type(&mut self, prim: Primitive) -> &mut Self

Sets the primitive type of the mesh.

By default, meshes are constructed as triangle lists.

pub fn build<B>(
    &self,
    queue: QueueId,
    factory: &Factory<B>
) -> Result<Mesh<B>, Error> where
    B: Backend, 

Builds and returns the new mesh.

A mesh expects all vertex buffers to have the same number of elements. If those are not equal, the length of smallest vertex buffer is selected, effectively discaring extra data from larger buffers.

Note that contents of index buffer is not validated.

Trait Implementations

impl<'a> Clone for MeshBuilder<'a>

fn clone(&self) -> MeshBuilder<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, A> From<Vec<A>> for MeshBuilder<'a> where
    A: AsVertex + 'a, 

fn from(vertices: Vec<A>) -> Self

Performs the conversion.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<A>, Vec<B>, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    A: AsVertex + 'a,
    B: AsVertex + 'a,
    C: AsVertex + 'a,
    D: AsVertex + 'a,
    E: AsVertex + 'a,
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<A>, Vec<B>, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<B>, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    B: AsVertex + 'a,
    C: AsVertex + 'a,
    D: AsVertex + 'a,
    E: AsVertex + 'a,
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<B>, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    C: AsVertex + 'a,
    D: AsVertex + 'a,
    E: AsVertex + 'a,
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    D: AsVertex + 'a,
    E: AsVertex + 'a,
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    E: AsVertex + 'a,
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    F: AsVertex + 'a,
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<F>, Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, G, H, I, J, K, L, M, N, O, P> From<(Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    G: AsVertex + 'a,
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, H, I, J, K, L, M, N, O, P> From<(Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    H: AsVertex + 'a,
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, I, J, K, L, M, N, O, P> From<(Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    I: AsVertex + 'a,
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, J, K, L, M, N, O, P> From<(Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    J: AsVertex + 'a,
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(
    vertices: (Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)
) -> Self

Performs the conversion.

impl<'a, K, L, M, N, O, P> From<(Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    K: AsVertex + 'a,
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(vertices: (Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> Self

Performs the conversion.

impl<'a, L, M, N, O, P> From<(Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    L: AsVertex + 'a,
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(vertices: (Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> Self

Performs the conversion.

impl<'a, M, N, O, P> From<(Vec<M>, Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    M: AsVertex + 'a,
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(vertices: (Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> Self

Performs the conversion.

impl<'a, N, O, P> From<(Vec<N>, Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    N: AsVertex + 'a,
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(vertices: (Vec<N>, Vec<O>, Vec<P>)) -> Self

Performs the conversion.

impl<'a, O, P> From<(Vec<O>, Vec<P>)> for MeshBuilder<'a> where
    O: AsVertex + 'a,
    P: AsVertex + 'a, 

fn from(vertices: (Vec<O>, Vec<P>)) -> Self

Performs the conversion.

impl<'a, P> From<(Vec<P>,)> for MeshBuilder<'a> where
    P: AsVertex + 'a, 

fn from(vertices: (Vec<P>,)) -> Self

Performs the conversion.

impl<'a> From<()> for MeshBuilder<'a>

fn from(vertices: ()) -> Self

Performs the conversion.

impl<'a> Debug for MeshBuilder<'a>

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

Formats the value using the given formatter.

impl<'a> Serialize for MeshBuilder<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de: 'a, 'a> Deserialize<'de> for MeshBuilder<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.