# [−]Enum amethyst_rendy::rendy::hal::Primitive

Describes the type of geometric primitives, created from vertex data.

## Variants

Each vertex represents a single point.

Each pair of vertices represent a single line segment. For example, with `[a, b, c, d, e]`

, `a`

and `b`

form a line, `c`

and `d`

form a line, and `e`

is discarded.

Every two consecutive vertices represent a single line segment. Visually forms a "path" of
lines, as they are all connected. For example, with `[a, b, c]`

, `a`

and `b`

form a line
line, and `b`

and `c`

form a line.

Each triplet of vertices represent a single triangle. For example, with `[a, b, c, d, e]`

,
`a`

, `b`

, and `c`

form a triangle, `d`

and `e`

are discarded.

Every three consecutive vertices represent a single triangle. For example, with `[a, b, c, d]`

, `a`

, `b`

, and `c`

form a triangle, and `b`

, `c`

, and `d`

form a triangle.

Each quadtruplet of vertices represent a single line segment with adjacency information.
For example, with `[a, b, c, d]`

, `b`

and `c`

form a line, and `a`

and `d`

are the adjacent
vertices.

Every four consecutive vertices represent a single line segment with adjacency information.
For example, with `[a, b, c, d, e]`

, `[a, b, c, d]`

form a line segment with adjacency, and
`[b, c, d, e]`

form a line segment with adjacency.

Each sextuplet of vertices represent a single triangle with adjacency information. For
example, with `[a, b, c, d, e, f]`

, `a`

, `c`

, and `e`

form a triangle, and `b`

, `d`

, and
`f`

are the adjacent vertices, where `b`

is adjacent to the edge formed by `a`

and `c`

, `d`

is adjacent to the edge `c`

and `e`

, and `f`

is adjacent to the edge `e`

and `a`

.

Every even-numbered vertex (every other starting from the first) represents an additional
vertex for the triangle strip, while odd-numbered vertices (every other starting from the
second) represent adjacent vertices. For example, with `[a, b, c, d, e, f, g, h]`

, `[a, c, e, g]`

form a triangle strip, and `[b, d, f, h]`

are the adjacent vertices, where `b`

, `d`

,
and `f`

are adjacent to the first triangle in the strip, and `d`

, `f`

, and `h`

are adjacent
to the second.

`PatchList(u8)`

Patch list, used with shaders capable of producing primitives on their own (tessellation)

## Trait Implementations

`impl Clone for Primitive`

`fn clone(&self) -> Primitive`

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

1.0.0[src]

`impl Copy for Primitive`

`impl Debug for Primitive`

`impl<'de> Deserialize<'de> for Primitive`

`fn deserialize<__D>(`

__deserializer: __D

) -> Result<Primitive, <__D as Deserializer<'de>>::Error> where

__D: Deserializer<'de>,

__deserializer: __D

) -> Result<Primitive, <__D as Deserializer<'de>>::Error> where

__D: Deserializer<'de>,

`impl Eq for Primitive`

`impl Hash for Primitive`

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

__H: Hasher,

__H: Hasher,

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

H: Hasher,

1.3.0[src]

H: Hasher,

`impl Ord for Primitive`

`fn cmp(&self, other: &Primitive) -> Ordering`

`#[must_use]fn max(self, other: Self) -> Self`

1.21.0[src]

`#[must_use]fn min(self, other: Self) -> Self`

1.21.0[src]

`#[must_use]fn clamp(self, min: Self, max: Self) -> Self`

[src]

`impl PartialEq<Primitive> for Primitive`

`impl PartialOrd<Primitive> for Primitive`

`fn partial_cmp(&self, other: &Primitive) -> Option<Ordering>`

`fn lt(&self, other: &Primitive) -> bool`

`fn le(&self, other: &Primitive) -> bool`

`fn gt(&self, other: &Primitive) -> bool`

`fn ge(&self, other: &Primitive) -> bool`

`impl Serialize for Primitive`

`fn serialize<__S>(`

&self,

__serializer: __S

) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where

__S: Serializer,

&self,

__serializer: __S

) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where

__S: Serializer,

`impl StructuralEq for Primitive`

`impl StructuralPartialEq for Primitive`

## Auto Trait Implementations

`impl RefUnwindSafe for Primitive`

`impl Send for Primitive`

`impl Sync for Primitive`

`impl Unpin for Primitive`

`impl UnwindSafe for Primitive`

## Blanket Implementations

`impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where`

D: AdaptFrom<S, Swp, Dwp, T>,

Dwp: WhitePoint,

Swp: WhitePoint,

T: Component + Float,

[src]

D: AdaptFrom<S, Swp, Dwp, T>,

Dwp: WhitePoint,

Swp: WhitePoint,

T: Component + Float,

`fn adapt_into_using<M>(self, method: M) -> D where`

M: TransformMatrix<Swp, Dwp, T>,

[src]

M: TransformMatrix<Swp, Dwp, T>,

`fn adapt_into(self) -> D`

[src]

`impl<T> Any for T where`

T: 'static + ?Sized,

[src]

T: 'static + ?Sized,

`impl<T> Any for T where`

T: Any,

T: Any,

`fn get_type_id(&self) -> TypeId`

`impl<T> Borrow<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`impl<T> BorrowMut<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`fn borrow_mut(&mut self) -> &mut T`

[src]

`impl<T> Clone for T where`

T: Clone,

[src]

T: Clone,

`impl<T> Config for T where`

T: for<'a> Deserialize<'a> + Serialize,

[src]

T: for<'a> Deserialize<'a> + Serialize,

`fn load<P>(path: P) -> Result<T, ConfigError> where`

P: AsRef<Path>,

[src]

P: AsRef<Path>,

`fn load_bytes(bytes: &[u8]) -> Result<T, ConfigError>`

[src]

`fn write<P>(&self, path: P) -> Result<(), ConfigError> where`

P: AsRef<Path>,

[src]

P: AsRef<Path>,

`fn load_no_fallback<P>(path: P) -> Result<Self, ConfigError> where`

P: AsRef<Path>,

[src]

P: AsRef<Path>,

`impl<T> DeserializeOwned for T where`

T: for<'de> Deserialize<'de>,

[src]

T: for<'de> Deserialize<'de>,

`impl<T> Event for T where`

T: Send + Sync + 'static,

T: Send + Sync + 'static,

`impl<T> From<T> for T`

[src]

`impl<T, U> Into<U> for T where`

U: From<T>,

[src]

U: From<T>,

`impl<T> Resource for T where`

T: Any + Send + Sync,

T: Any + Send + Sync,

`impl<T> Same<T> for T`

`type Output = T`

Should always be `Self`

`impl<T> Scalar for T where`

T: PartialEq<T> + Copy + Any + Debug,

[src]

T: PartialEq<T> + Copy + Any + Debug,

`impl<T> Serialize for T where`

T: Serialize + ?Sized,

[src]

T: Serialize + ?Sized,

`fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<Ok, Error>`

[src]

`impl<T> SetParameter for T`

`fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where`

T: Parameter<Self>,

T: Parameter<Self>,

`impl<SS, SP> SupersetOf<SS> for SP where`

SS: SubsetOf<SP>,

SS: SubsetOf<SP>,

`fn to_subset(&self) -> Option<SS>`

`fn is_in_subset(&self) -> bool`

`unsafe fn to_subset_unchecked(&self) -> SS`

`fn from_subset(element: &SS) -> SP`

`impl<T> Supports<T> for T`

`impl<T> ToOwned for T where`

T: Clone,

[src]

T: Clone,

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`

[src]

`fn clone_into(&self, target: &mut T)`

[src]

`impl<T, U> TryFrom<U> for T where`

U: Into<T>,

[src]

U: Into<T>,

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

`impl<T, U> TryInto<U> for T where`

U: TryFrom<T>,

[src]

U: TryFrom<T>,

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

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

[src]

`impl<V, T> VZip<V> for T where`

V: MultiLane<T>,

V: MultiLane<T>,