Struct gfx::Slice[][src]

pub struct Slice<R: Resources> {
    pub start: VertexCount,
    pub end: VertexCount,
    pub base_vertex: VertexCount,
    pub instances: Option<InstanceParams>,
    pub buffer: IndexBuffer<R>,
}

A Slice dictates in which and in what order vertices get processed. It is required for processing a PSO.

Overview

A Slice in gfx has a different meaning from the term slice as employed more broadly in rust (&[T]).

A Slice object in essence dictates in what order the vertices in a VertexBuffer get processed. To do this, it contains an internal index-buffer. This Buffer is a list of indices into this VertexBuffer (vertex-index). A vertex-index of 0 represents the first vertex in the VertexBuffer, a vertex-index of 1 represents the second, 2 represents the third, and so on. The vertex-indices in the index-buffer are read in order; every vertex-index tells the pipeline which vertex to process next.

Because the same index can re-appear multiple times, duplicate-vertices can be avoided. For instance, if you want to draw a square, you need two triangles, and thus six vertices. Because the same index can reappear multiple times, this means we can instead use 4 vertices, and 6 vertex-indices.

This index-buffer has a few variants. See the IndexBuffer documentation for a detailed description.

The start and end fields say where in the index-buffer to start and stop reading. Setting start to 0, and end to the length of the index-buffer, will cause the entire index-buffer to be processed. The base_vertex dictates the index of the first vertex in the VertexBuffer. This essentially moves the the start of the VertexBuffer, to the vertex with this index.

Constuction & Handling

The Slice structure can be constructed automatically when using a Factory to create a vertex buffer. If needed, it can also be created manually.

A Slice is required to process a PSO, as it contains the needed information on in what order to draw which vertices. As such, every draw call on an Encoder requires a Slice.

Fields

start: VertexCount

The start index of the index-buffer. Processing will start at this location in the index-buffer.

end: VertexCount

The end index in the index-buffer. Processing will stop at this location (exclusive) in the index buffer.

base_vertex: VertexCount

This is the index of the first vertex in the VertexBuffer. This value will be added to every index in the index-buffer, effectively moving the start of the VertexBuffer to this base-vertex.

instances: Option<InstanceParams>

Instancing configuration.

buffer: IndexBuffer<R>

Represents the type of index-buffer used.

Implementations

impl<R: Resources> Slice<R>[src]

pub fn from_vertex_count(count: VertexCount) -> Self[src]

Creates a new Slice with a given vertex count.

pub fn new_match_vertex_buffer<V>(vbuf: &Buffer<R, V>) -> Self where
    V: Structure<Format>, 
[src]

Creates a new Slice to match the supplied vertex buffer, from start to end, in order.

pub fn get_prim_count(&self, prim: Primitive) -> u32[src]

Calculates the number of primitives of the specified type in this Slice.

pub fn split_at(&self, mid: VertexCount) -> (Self, Self)[src]

Divides one slice into two at an index.

The first will contain the range in the index-buffer [self.start, mid) (excluding the index mid itself) and the second will contain the range [mid, self.end).

Trait Implementations

impl<R: Clone + Resources> Clone for Slice<R>[src]

impl<R: Debug + Resources> Debug for Slice<R>[src]

impl<R: Eq + Resources> Eq for Slice<R>[src]

impl<R: Hash + Resources> Hash for Slice<R>[src]

impl<R: PartialEq + Resources> PartialEq<Slice<R>> for Slice<R>[src]

impl<R: Resources> StructuralEq for Slice<R>[src]

impl<R: Resources> StructuralPartialEq for Slice<R>[src]

Auto Trait Implementations

impl<R> !RefUnwindSafe for Slice<R>

impl<R> Send for Slice<R>

impl<R> Sync for Slice<R>

impl<R> Unpin for Slice<R>

impl<R> !UnwindSafe for Slice<R>

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> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

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.