Trait rendy::util::types::vertex::AsAttributes

pub trait AsAttributes where
    <Self::Iter as Iterator>::Item == Attribute, {
    type Iter: Iterator;
    fn attributes(self) -> Self::Iter;
}

Represent types that can be interpreted as list of vertex attributes.

Associated Types

type Iter: Iterator

The iterator type for retreived attributes

Loading content...

Required methods

fn attributes(self) -> Self::Iter

Retreive a list of vertex attributes with offsets relative to beginning of that list

Loading content...

Implementations on Foreign Types

impl AsAttributes for Vec<Attribute>

type Iter = IntoIter<Attribute>

fn attributes(self) -> <Vec<Attribute> as AsAttributes>::Iter

impl<O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<N> AsAttributes for (Format, N) where
    N: Into<Cow<'static, str>>, 

type Iter = AttrGenIter<N, IntoIter<(Format, N)>>

fn attributes(self) -> <(Format, N) as AsAttributes>::Iter

impl<T, U, V, W, X, Y, Z> AsAttributes for (T, U, V, W, X, Y, Z) where
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<R, S, T, U, V, W, X, Y, Z> AsAttributes for (R, S, T, U, V, W, X, Y, Z) where
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<V, W, X, Y, Z> AsAttributes for (V, W, X, Y, Z) where
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(V, W, X, Y, Z) as AsAttributes>::Iter

impl<W, X, Y, Z> AsAttributes for (W, X, Y, Z) where
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(W, X, Y, Z) as AsAttributes>::Iter

impl<M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<N> AsAttributes for Vec<(Format, N)> where
    N: Into<Cow<'static, str>>, 

type Iter = AttrGenIter<N, IntoIter<(Format, N)>>

fn attributes(self) -> <Vec<(Format, N)> as AsAttributes>::Iter

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    C: AsAttributes,
    D: AsAttributes,
    E: AsAttributes,
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    D: AsAttributes,
    E: AsAttributes,
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    A: AsAttributes,
    B: AsAttributes,
    C: AsAttributes,
    D: AsAttributes,
    E: AsAttributes,
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<S, T, U, V, W, X, Y, Z> AsAttributes for (S, T, U, V, W, X, Y, Z) where
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    E: AsAttributes,
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (Q, R, S, T, U, V, W, X, Y, Z) where
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl AsAttributes for ()

type Iter = IntoIter<Attribute>

fn attributes(self) -> <() as AsAttributes>::Iter

impl<Z> AsAttributes for (Z,) where
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(Z,) as AsAttributes>::Iter

impl<L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    B: AsAttributes,
    C: AsAttributes,
    D: AsAttributes,
    E: AsAttributes,
    F: AsAttributes,
    G: AsAttributes,
    H: AsAttributes,
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<U, V, W, X, Y, Z> AsAttributes for (U, V, W, X, Y, Z) where
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<X, Y, Z> AsAttributes for (X, Y, Z) where
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(X, Y, Z) as AsAttributes>::Iter

impl<J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<N> AsAttributes for Option<(Format, N)> where
    N: Into<Cow<'static, str>>, 

type Iter = AttrGenIter<N, IntoIter<(Format, N)>>

fn attributes(self) -> <Option<(Format, N)> as AsAttributes>::Iter

impl<Y, Z> AsAttributes for (Y, Z) where
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(Y, Z) as AsAttributes>::Iter

impl<P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (P, Q, R, S, T, U, V, W, X, Y, Z) where
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(self) -> <(P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    I: AsAttributes,
    J: AsAttributes,
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

impl<K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> AsAttributes for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    K: AsAttributes,
    L: AsAttributes,
    M: AsAttributes,
    N: AsAttributes,
    O: AsAttributes,
    P: AsAttributes,
    Q: AsAttributes,
    R: AsAttributes,
    S: AsAttributes,
    T: AsAttributes,
    U: AsAttributes,
    V: AsAttributes,
    W: AsAttributes,
    X: AsAttributes,
    Y: AsAttributes,
    Z: AsAttributes, 

type Iter = IntoIter<Attribute>

fn attributes(
    self
) -> <(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as AsAttributes>::Iter

Loading content...

Implementors

impl AsAttributes for VertexFormat

type Iter = IntoIter<Attribute>

fn attributes(self) -> <VertexFormat as AsAttributes>::Iter

Loading content...