[−][src]Struct amethyst_rendy::rendy::mesh::MeshBuilder

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

Generics-free mesh builder.

Methods

`impl<'a> MeshBuilder<'a>`[src]

`pub fn new() -> MeshBuilder<'a>`[src]

Create empty builder.

`pub fn into_owned(self) -> MeshBuilder<'static>`[src]

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(self, indices: I) -> MeshBuilder<'a> where I: Into<Indices<'a>>,` [src]

Set indices buffer to the MeshBuilder

`pub fn set_indices(&mut self, indices: I) -> &mut MeshBuilder<'a> where I: Into<Indices<'a>>,` [src]

Set indices buffer to the MeshBuilder

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

Add another vertices to the MeshBuilder

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

Add another vertices to the MeshBuilder

`pub fn with_prim_type(self, prim: Primitive) -> MeshBuilder<'a>`[src]

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

Sets the primitive type of the mesh.

By default, meshes are constructed as triangle lists.

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

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, 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, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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, [src]

`fn from( vertices: (Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

`impl<'a, I, J, K, L, M, N, O, P> From<(Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<O>, Vec)) -> MeshBuilder<'a>`[src]

`impl<'a, J, K, L, M, N, O, P> From<(Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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

`fn from( vertices: (Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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, [src]

`fn from( vertices: (Vec, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

`impl<'a, H, I, J, K, L, M, N, O, P> From<(Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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, [src]

`fn from( vertices: (Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<M>, Vec<N>, Vec<O>, Vec)) -> MeshBuilder<'a>`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<A>, Vec, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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, [src]

`fn from( vertices: (Vec<A>, Vec, Vec<C>, Vec<D>, Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<N>, Vec<O>, Vec)) -> MeshBuilder<'a>`[src]

`impl<'a, E, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec<E>, Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

`impl<'a, A> From<Vec<A>> for MeshBuilder<'a> where A: AsVertex + 'a,` [src]

`fn from(vertices: Vec<A>) -> MeshBuilder<'a>`[src]

`impl<'a, F, G, H, I, J, K, L, M, N, O, P> From<(Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec<F>, Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

`impl<'a> From<()> for MeshBuilder<'a>`[src]

`fn from(vertices: ()) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec,)) -> MeshBuilder<'a>`[src]

`impl<'a, G, H, I, J, K, L, M, N, O, P> From<(Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)> 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,` [src]

`fn from( vertices: (Vec<G>, Vec<H>, Vec, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec)) -> MeshBuilder<'a>`[src]

`impl<'de, 'a> Deserialize<'de> for MeshBuilder<'a> where 'de: 'a,` [src]

`fn deserialize<D>( deserializer: D ) -> Result<MeshBuilder<'a>, <D as Deserializer<'de>>::Error> where __D: Deserializer<'de>,` [src]

`impl<'a> Serialize for MeshBuilder<'a>`[src]

`fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer,` [src]

`impl<'a> Debug for MeshBuilder<'a>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

`impl<'a> Clone for MeshBuilder<'a>`[src]

`fn clone(&self) -> MeshBuilder<'a>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from source. Read more

`impl From<MeshBuilder<'static>> for MeshData`[src]

`fn from(builder: MeshBuilder<'static>) -> Self`[src]

Auto Trait Implementations

`impl<'a> Unpin for MeshBuilder<'a>`

`impl<'a> Sync for MeshBuilder<'a>`

`impl<'a> Send for MeshBuilder<'a>`

`impl<'a> UnwindSafe for MeshBuilder<'a>`

`impl<'a> RefUnwindSafe for MeshBuilder<'a>`

Blanket Implementations

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where D: AdaptFrom<S, Swp, Dwp, T>, Dwp: WhitePoint, Swp: WhitePoint, T: Component + Float,` [src]

`fn adapt_into_using<M>(self, method: M) -> D where M: TransformMatrix<Swp, Dwp, T>,` [src]

`fn adapt_into(self) -> D`[src]

Convert the source color to the destination color using the bradford method by default Read more

`impl<T> DeserializeOwned for T where T: Deserialize<'de>,` [src]

`impl<T> SetParameter for T`[src]

`fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where T: Parameter<Self>,` [src]

Sets value as a parameter of self.

`impl<T> Supports<T> for T`[src]

`impl<T> Erased for T`[src]

`impl<T> Serialize for T where T: Serialize + ?Sized,` [src]

`fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<Ok, Error>`[src]

`impl<T> Same<T> for T`[src]

`type Output = T`

Should always be Self

`impl<SS, SP> SupersetOf<SS> for SP where SS: SubsetOf<SP>,` [src]

`fn to_subset(&self) -> Option<SS>`[src]

`fn is_in_subset(&self) -> bool`[src]

`unsafe fn to_subset_unchecked(&self) -> SS`[src]

`fn from_subset(element: &SS) -> SP`[src]

`impl<T> Resource for T where T: Any + Send + Sync,` [src]

`impl<T> Any for T where T: Any,` [src]

`fn get_type_id(&self) -> TypeId`[src]

`impl<T> Event for T where T: Send + Sync + 'static,` [src]

`impl<T> Clone for T where T: Clone,` [src]

`unsafe fn clone_box(&self) -> *mut ()`[src]

[−][src]Struct amethyst_rendy::rendy::mesh::MeshBuilder

Methods

impl<'a> MeshBuilder<'a>[src]

pub fn new() -> MeshBuilder<'a>[src]

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

pub fn with_indices<I>(self, indices: I) -> MeshBuilder<'a> where I: Into<Indices<'a>>, [src]

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

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

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

pub fn with_prim_type(self, prim: Primitive) -> MeshBuilder<'a>[src]

pub fn set_prim_type(&mut self, prim: Primitive) -> &mut MeshBuilder<'a>[src]

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

Trait Implementations

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>)) -> MeshBuilder<'a>[src]

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

fn from( vertices: (Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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

fn from(vertices: (Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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

fn from( vertices: (Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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

fn from( vertices: (Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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>)) -> MeshBuilder<'a>[src]

fn from( vertices: (Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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>)) -> MeshBuilder<'a>[src]

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

fn from(vertices: (Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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>)) -> MeshBuilder<'a>[src]

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

fn from(vertices: (Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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>)) -> MeshBuilder<'a>[src]

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

fn from(vertices: Vec<A>) -> MeshBuilder<'a>[src]

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>)) -> MeshBuilder<'a>[src]

impl<'a> From<()> for MeshBuilder<'a>[src]

fn from(vertices: ()) -> MeshBuilder<'a>[src]

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

fn from(vertices: (Vec<P>,)) -> MeshBuilder<'a>[src]

fn from( vertices: (Vec<G>, Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

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

fn from(vertices: (Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>[src]

impl<'de, 'a> Deserialize<'de> for MeshBuilder<'a> where 'de: 'a, [src]

fn deserialize<__D>( __deserializer: __D) -> Result<MeshBuilder<'a>, <__D as Deserializer<'de>>::Error> where __D: Deserializer<'de>, [src]

impl<'a> Serialize for MeshBuilder<'a>[src]

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

impl<'a> Debug for MeshBuilder<'a>[src]

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>[src]

impl<'a> Clone for MeshBuilder<'a>[src]

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

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl From<MeshBuilder<'static>> for MeshData[src]

fn from(builder: MeshBuilder<'static>) -> Self[src]

Auto Trait Implementations

impl<'a> Unpin for MeshBuilder<'a>

impl<'a> Sync for MeshBuilder<'a>

impl<'a> Send for MeshBuilder<'a>

impl<'a> UnwindSafe for MeshBuilder<'a>

impl<'a> RefUnwindSafe for MeshBuilder<'a>

Blanket Implementations

impl<T> ToOwned for T where T: Clone, [src]

type Owned = T

fn to_owned(&self) -> T[src]

fn clone_into(&self, target: &mut T)[src]

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where D: AdaptFrom<S, Swp, Dwp, T>, Dwp: WhitePoint, Swp: WhitePoint, T: Component + Float, [src]

`impl<'a> MeshBuilder<'a>`[src]

`pub fn new() -> MeshBuilder<'a>`[src]

`pub fn into_owned(self) -> MeshBuilder<'static>`[src]

`pub fn with_indices<I>(self, indices: I) -> MeshBuilder<'a> where I: Into<Indices<'a>>,` [src]

`pub fn set_indices<I>(&mut self, indices: I) -> &mut MeshBuilder<'a> where I: Into<Indices<'a>>,` [src]

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

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

`pub fn with_prim_type(self, prim: Primitive) -> MeshBuilder<'a>`[src]

`pub fn set_prim_type(&mut self, prim: Primitive) -> &mut MeshBuilder<'a>`[src]

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

`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>) ) -> MeshBuilder<'a>`[src]

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

`fn from( vertices: (Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<O>, Vec<P>)) -> MeshBuilder<'a>`[src]

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

`fn from( vertices: (Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>) ) -> MeshBuilder<'a>`[src]

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

`fn from( vertices: (Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>) ) -> MeshBuilder<'a>`[src]

`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>) ) -> MeshBuilder<'a>`[src]

`fn from( vertices: (Vec<H>, Vec<I>, Vec<J>, Vec<K>, Vec<L>, Vec<M>, Vec<N>, Vec<O>, Vec<P>) ) -> MeshBuilder<'a>`[src]

`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>) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<M>, Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>`[src]

`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>) ) -> MeshBuilder<'a>`[src]

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

`fn from(vertices: (Vec<N>, Vec<O>, Vec<P>)) -> MeshBuilder<'a>`[src]

`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>) ) -> MeshBuilder<'a>`[src]