Struct gfx::Slice [−] [src]

pub struct Slice<R: Resources> {
    pub start: VertexCount,
    pub end: VertexCount,
    pub base_vertex: VertexCount,
    pub instances: InstanceOption,
    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 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: InstanceOption

Instancing configuration.

buffer: IndexBuffer<R>

Represents the type of index-buffer used.

Methods

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

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

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

fn get_prim_count(&self, prim: Primitive) -> u32

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

Trait Implementations

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

fn eq(&self, __arg_0: &Slice<R>) -> bool

This method tests for self and other values to be equal, and is used by ==. Read more

fn ne(&self, __arg_0: &Slice<R>) -> bool

This method tests for !=.

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

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

Formats the value using the given formatter.

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

fn clone(&self) -> Slice<R>

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more