Enum PrimitiveType

pub enum PrimitiveType {
    Points,
    LinesList,
    LinesListAdjacency,
    LineStrip,
    LineStripAdjacency,
    LineLoop,
    TrianglesList,
    TrianglesListAdjacency,
    TriangleStrip,
    TriangleStripAdjacency,
    TriangleFan,
    Patches {
        vertices_per_patch: u16,
    },
}

List of available primitives.

See this page for a visual representation of each primitive type.

Variants

Points

Each vertex is an individual point.

LinesList

Vertices are grouped by chunks of two vertices. Each chunk represents a line.

LinesListAdjacency

Vertices are grouped by chunks of four vertices. The second and third vertices of each chunk represents the line.

Adjacency information doesn’t do anything per-se, but is passed to the geometry shader if there is any. The first vertex represents the vertex adjacent to the second vertex. The fourth vertex represents the vertex adjacent to the third vertex.

LineStrip

Each vertex (except the last one) forms a line with the next vertex.

For example vertices 0 and 1 form a line, vertices 1 and 2 form a line, vertices 2 and 3 form a line, etc.

LineStripAdjacency

Similar to LineStrip, but with an additional vertex at the beginning and at the end that represent the vertices adjacent to the first and last ones.

Adjacency information doesn’t do anything per-se, but is passed to the geometry shader if there is any.

LineLoop

Each vertex forms a line with the next vertex. The last vertex form a line with the first one.

TrianglesList

Vertices are grouped by chunks of three vertices. Each chunk represents a triangle.

The order of the vertices is important, as it determines whether the triangle will be clockwise or counter-clockwise. See BackfaceCulling for more infos.

TrianglesListAdjacency

Vertices are grouped by chunks of six vertices. The first, third and fifth vertices represent a triangle.

The order of the vertices is important, as it determines whether the triangle will be clockwise or counter-clockwise. See BackfaceCulling for more infos.

Adjacency information doesn’t do anything per-se, but is passed to the geometry shader if there is any. The second vertex represents the vertex adjacent to the first and third vertices. The fourth vertex represents the vertex adjacent to the third and fifth vertices. The sixth vertex represents the vertex adjacent to the first and fifth vertices.

TriangleStrip

Each vertex (except the first one and the last one) forms a triangle with the previous and the next vertices.

For example vertices 0, 1, 2 form a triangle, 1, 2, 3 form a triangle, 2, 3, 4 form a triangle, 3, 4, 5 form a triangle, etc.

Each uneven triangle is reversed so that all triangles are facing the same direction.

TriangleStripAdjacency

Each even vertex forms a triangle with vertices n+2 and n+4.

Each uneven vertex is adjacent to the previous and next ones. Adjacency information doesn’t do anything per-se, but is passed to the geometry shader if there is any.

TriangleFan

Starting at the second vertex, each vertex forms a triangle with the next and the first vertices.

For example vertices 0, 1, 2 form a triangle, 0, 2, 3 form a triangle, 0, 3, 4 form a triangle, 0, 4, 5 form a triangle, etc.

Patches

Vertices are grouped by chunks of vertices_per_patch vertices.

This primitives type can only be used in conjunction with a tessellation shader. The tessellation shader will indicate how each patch will be divided into lines or triangles.

Fields

vertices_per_patch: u16

Number of vertices per patch.

Implementations

impl PrimitiveType

pub fn is_supported<C>(&self, caps: &C) -> bool

where C: CapabilitiesSource + ?Sized,

Returns true if the backend supports this type of primitives.

Trait Implementations

impl Clone for PrimitiveType

fn clone(&self) -> PrimitiveType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrimitiveType

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

Formats the value using the given formatter.

impl PartialEq for PrimitiveType

fn eq(&self, other: &PrimitiveType) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for PrimitiveType

impl Eq for PrimitiveType

impl StructuralPartialEq for PrimitiveType