Struct gfx::Slice

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>

pub fn from_vertex_count(count: VertexCount) -> Self

Creates a new Slice with a given vertex count.

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

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

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

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

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>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Resources> Debug for Slice<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Hash + Resources> Hash for Slice<R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R: PartialEq + Resources> PartialEq<Slice<R>> for Slice<R>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Eq + Resources> Eq for Slice<R>

impl<R: Resources> StructuralEq for Slice<R>

impl<R: Resources> StructuralPartialEq for Slice<R>