[][src]Struct luminance::tess::TessBuilder

pub struct TessBuilder<'a, B, V, I = (), W = (), S = Interleaved> where
    B: ?Sized,
    V: TessVertexData<S>,
    W: TessVertexData<S>,
    S: ?Sized
{ /* fields omitted */ }

Tess builder object.

This type allows to create Tess via a builder pattern. You have several flavors of possible vertex storage situations, as well as data encoding, described below.

Vertex storage

Interleaved

You can pass around interleaved vertices and indices. Those are encoded in Vec<T>. You typically want to use this when you already have the vertices and/or indices allocated somewhere, as the interface will use the input vector as a source of truth for lengths.

Deinterleaved

This is the same as interleaved data in terms of interface, but the T type is interpreted a bit differently. Here, the encoding is (Vec<Field0>, Vec<Field1>, …), where Field0, Field1 etc. are all the ordered fieds in T.

That representation allows field-based operation later on Tess, while it would be impossible with the interleaved version (you would need to get all the fields at once, since you would work onT directly and each of its fields).

Data encoding

  • Vectors: you can pass vectors as input data for both vertices and indices. Those will be interpreted differently based on the vertex storage you chose for vertices, and the normal way for indices.
  • Buffers: you can pass [Buffer] objects, too. Those are more flexible than vectors ase you can use all of the [Buffer] API before sending them to the builder.
  • Disabled: disabling means that no data will be passed to the GPU. You can disable independently vertex data and/or index data.

Parametricity

  • B is the backend type
  • V is the vertex type.
  • S is the storage type.

Implementations

impl<'a, B, V, I, W, S> TessBuilder<'a, B, V, I, W, S> where
    B: ?Sized,
    V: TessVertexData<S>,
    I: TessIndex,
    W: TessVertexData<S>,
    S: ?Sized
[src]

pub fn set_mode(self, mode: Mode) -> Self[src]

Set the Mode to connect vertices.

Calling that function twice replace the previously set value.

pub fn set_vertex_nb(self, vert_nb: usize) -> Self[src]

Set the default number of vertices to render.

Calling that function twice replace the previously set value.

pub fn set_instance_nb(self, inst_nb: usize) -> Self[src]

Set the default number of instances to render.

Calling that function twice replace the previously set value.

pub fn set_primitive_restart_index(self, restart_index: I) -> Self[src]

Set the primitive restart index.

Calling that function twice replace the previously set value.

impl<'a, B, V, I, W, S> TessBuilder<'a, B, V, I, W, S> where
    B: ?Sized,
    V: TessVertexData<S>,
    I: TessIndex,
    W: TessVertexData<S>,
    S: ?Sized
[src]

pub fn new<C>(ctx: &'a mut C) -> Self where
    C: GraphicsContext<Backend = B>, 
[src]

Create a new default TessBuilder.

Notes

Feel free to use the [GraphicsContext::new_tess_builder] method for a simpler method.

impl<'a, B, V, W, S> TessBuilder<'a, B, V, (), W, S> where
    B: ?Sized,
    V: TessVertexData<S>,
    W: TessVertexData<S>,
    S: ?Sized
[src]

pub fn set_indices<I, X>(self, indices: X) -> TessBuilder<'a, B, V, I, W, S> where
    X: Into<Vec<I>>, 
[src]

Add indices to be bundled in the Tess.

Every time you call that function, the set of indices is replaced by the one you provided. The type of expected indices is ruled by the II type variable you chose.

impl<'a, B, I, W> TessBuilder<'a, B, (), I, W, Interleaved> where
    B: ?Sized,
    I: TessIndex,
    W: TessVertexData<Interleaved>, 
[src]

pub fn set_vertices<V, X>(
    self,
    vertices: X
) -> TessBuilder<'a, B, V, I, W, Interleaved> where
    X: Into<Vec<V>>,
    V: TessVertexData<Interleaved, Data = Vec<V>>, 
[src]

Add vertices to be bundled in the Tess.

Every time you call that function, the set of vertices is replaced by the one you provided.

impl<'a, B, I, V> TessBuilder<'a, B, V, I, (), Interleaved> where
    B: ?Sized,
    I: TessIndex,
    V: TessVertexData<Interleaved>, 
[src]

pub fn set_instances<W, X>(
    self,
    instances: X
) -> TessBuilder<'a, B, V, I, W, Interleaved> where
    X: Into<Vec<W>>,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 
[src]

Add instances to be bundled in the Tess.

Every time you call that function, the set of instances is replaced by the one you provided.

impl<'a, B, V, I, W> TessBuilder<'a, B, V, I, W, Deinterleaved> where
    B: ?Sized,
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>, 
[src]

pub fn set_attributes<A, X>(self, attributes: X) -> Self where
    X: Into<Vec<A>>,
    V: Deinterleave<A>, 
[src]

Add vertices to be bundled in the Tess.

Every time you call that function, the set of vertices is replaced by the one you provided.

pub fn set_instance_attributes<A, X>(self, attributes: X) -> Self where
    X: Into<Vec<A>>,
    W: Deinterleave<A>, 
[src]

Add instances to be bundled in the Tess.

Every time you call that function, the set of instances is replaced by the one you provided.

impl<'a, B: ?Sized, V, I, W, S> TessBuilder<'a, B, V, I, W, S> where
    B: TessBackend<V, I, W, S>,
    V: TessVertexData<S>,
    I: TessIndex,
    W: TessVertexData<S>, 
[src]

pub fn build(self) -> Result<Tess<B, V, I, W, S>, TessError>[src]

Build a Tess if the TessBuilder has enough data and is in a valid state. What is needed is backend-dependent but most of the time, you will want to:

  • Set a Mode.
  • Give vertex data and optionally indices, or give none of them (attributeless objects).
  • If you provide vertex data by submitting several sets with [TessBuilder::add_vertices] and/or [TessBuilder::add_instances], do not forget that you must submit sets with the same size. Otherwise, the GPU will not know what values use for missing attributes in vertices.

Auto Trait Implementations

impl<'a, B: ?Sized, V, I, W, S: ?Sized> RefUnwindSafe for TessBuilder<'a, B, V, I, W, S> where
    B: RefUnwindSafe,
    I: RefUnwindSafe,
    <V as TessVertexData<S>>::Data: RefUnwindSafe,
    <W as TessVertexData<S>>::Data: RefUnwindSafe

impl<'a, B: ?Sized, V, I, W, S: ?Sized> Send for TessBuilder<'a, B, V, I, W, S> where
    B: Send,
    I: Send,
    <V as TessVertexData<S>>::Data: Send,
    <W as TessVertexData<S>>::Data: Send

impl<'a, B: ?Sized, V, I, W, S: ?Sized> Sync for TessBuilder<'a, B, V, I, W, S> where
    B: Sync,
    I: Sync,
    <V as TessVertexData<S>>::Data: Sync,
    <W as TessVertexData<S>>::Data: Sync

impl<'a, B: ?Sized, V, I, W, S: ?Sized> Unpin for TessBuilder<'a, B, V, I, W, S> where
    I: Unpin,
    <V as TessVertexData<S>>::Data: Unpin,
    <W as TessVertexData<S>>::Data: Unpin

impl<'a, B, V, I = (), W = (), S = Interleaved> !UnwindSafe for TessBuilder<'a, B, V, I, W, S>

Blanket Implementations

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

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

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

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

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.