Struct components::platform::core::Primitive

source · [−]

pub struct Primitive {}

Implementations

source

impl Primitive

source

pub fn new(mode: VerticesMode, n_vertices: i32, args: &[f64 ]) -> Primitive

source

pub fn new_p2(context: &Context, mode: VerticesMode, data: &[&P2 ]) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position attribute with a Attribute and upload your data.

For example to draw a convex polygon you can do:

VertexP2 triangle[] =
{
  { 0,   300 },
  { 150, 0,  },
  { 300, 300 }
};
prim = primitive_new_p2 (VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP2 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&P2C4 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position and color attributes with Attributes and upload your data.

For example to draw a convex polygon with a linear gradient you can do:

VertexP2C4 triangle[] =
{
  { 0,   300,  0xff, 0x00, 0x00, 0xff },
  { 150, 0,    0x00, 0xff, 0x00, 0xff },
  { 300, 300,  0xff, 0x00, 0x00, 0xff }
};
prim = primitive_new_p2c4 (VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP2C4 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p2t2(
    context: &Context,
    mode: VerticesMode,
    data: &[&P2T2 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position and texture coordinate attributes with Attributes and upload your data.

For example to draw a convex polygon with texture mapping you can do:

VertexP2T2 triangle[] =
{
  { 0,   300,  0.0, 1.0},
  { 150, 0,    0.5, 0.0},
  { 300, 300,  1.0, 1.0}
};
prim = primitive_new_p2t2 (VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP2T2 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p2t2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&P2T2C4 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position, texture coordinate and color attributes with Attributes and upload your data.

For example to draw a convex polygon with texture mapping and a linear gradient you can do:

VertexP2T2C4 triangle[] =
{
  { 0,   300,  0.0, 1.0,  0xff, 0x00, 0x00, 0xff},
  { 150, 0,    0.5, 0.0,  0x00, 0xff, 0x00, 0xff},
  { 300, 300,  1.0, 1.0,  0xff, 0x00, 0x00, 0xff}
};
prim = primitive_new_p2t2c4 (VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP2T2C4 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p3(context: &Context, mode: VerticesMode, data: &[&P3 ]) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position attribute with a Attribute and upload your data.

For example to draw a convex polygon you can do:

VertexP3 triangle[] =
{
  { 0,   300, 0 },
  { 150, 0,   0 },
  { 300, 300, 0 }
};
prim = primitive_new_p3 (VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP3 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p3c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&P3C4 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position and color attributes with Attributes and upload your data.

For example to draw a convex polygon with a linear gradient you can do:

VertexP3C4 triangle[] =
{
  { 0,   300, 0,  0xff, 0x00, 0x00, 0xff },
  { 150, 0,   0,  0x00, 0xff, 0x00, 0xff },
  { 300, 300, 0,  0xff, 0x00, 0x00, 0xff }
};
prim = primitive_new_p3c4 (VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP3C4 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p3t2(
    context: &Context,
    mode: VerticesMode,
    data: &[&P3T2 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position and texture coordinate attributes with Attributes and upload your data.

For example to draw a convex polygon with texture mapping you can do:

VertexP3T2 triangle[] =
{
  { 0,   300, 0,  0.0, 1.0},
  { 150, 0,   0,  0.5, 0.0},
  { 300, 300, 0,  1.0, 1.0}
};
prim = primitive_new_p3t2 (VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP3T2 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn new_p3t2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&P3T2C4 ]
) -> Primitive

Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary AttributeBuffer storage, describe the position, texture coordinate and color attributes with Attributes and upload your data.

For example to draw a convex polygon with texture mapping and a linear gradient you can do:

VertexP3T2C4 triangle[] =
{
  { 0,   300, 0,  0.0, 1.0,  0xff, 0x00, 0x00, 0xff},
  { 150, 0,   0,  0.5, 0.0,  0x00, 0xff, 0x00, 0xff},
  { 300, 300, 0,  1.0, 1.0,  0xff, 0x00, 0x00, 0xff}
};
prim = primitive_new_p3t2c4 (VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
primitive_draw (prim);

The value passed as n_vertices is initially used to determine how much can be read from data but it will also be used to update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to read when drawing.

The primitive API doesn’t support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). You should pass the TextureFlags::NoSlicing flag to all textures that might be used while drawing with this API. If your hardware doesn’t support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don’t have to be square)

`context`

A Context

`mode`

A VerticesMode defining how to draw the vertices

`n_vertices`

The number of vertices to read from data and also the number of vertices to read when later drawing.

`data`

An array of VertexP3T2C4 vertices

Returns

A newly allocated Primitive with a reference of 1. This can be freed using Object::unref.

source

pub fn with_attributes(
    mode: VerticesMode,
    n_vertices: i32,
    attributes: &[&Attribute ],
    n_attributes: i32
) -> Primitive

source

pub fn copy(&self) -> Option<Primitive>

Makes a copy of an existing Primitive. Note that the primitive is a shallow copy which means it will use the same attributes and attribute buffers as the original primitive.

Returns

the new primitive

source

pub fn draw(&self, framebuffer: &P, pipeline: &Pipeline) where
P: Is<Framebuffer>,

Draws the given self geometry to the specified destination framebuffer using the graphics processing state described by pipeline.

This drawing api doesn’t support high-level meta texture types such as Texture2DSliced so it is the user’s responsibility to ensure that only low-level textures that can be directly sampled by a GPU such as Texture2D, TextureRectangle or Texture3D are associated with layers of the given pipeline.

`framebuffer`

A destination Framebuffer

`pipeline`

A Pipeline state object

source

pub fn foreach_attribute(&self, callback: P) where
P: FnMut(&Primitive, &Attribute) -> i32,

Iterates all the attributes of the given Primitive.

`callback`

A PrimitiveAttributeCallback to be called for each attribute

`user_data`

Private data that will be passed to the callback

source

pub fn first_vertex(&self) -> i32

source

pub fn indices(&self) -> Option<Indices>

Returns

the indices that were set with Primitive::set_indices or None if no indices were set.

source

pub fn mode(&self) -> VerticesMode

source

pub fn n_vertices(&self) -> i32

Queries the number of vertices to read when drawing the given self. Usually this value is implicitly set when associating vertex data or indices with a Primitive.

If Primitive::set_indices has been used to associate a sequence of Indices with the given self then the number of vertices to read can also be phrased as the number of indices to read.

To be clear; it doesn’t refer to the number of vertices - in terms of data - associated with the primitive it’s just the number of vertices to read and draw.

Returns

The number of vertices to read when drawing.

source

pub fn set_attributes(&self, attributes: &[&Attribute ], n_attributes: i32)

Replaces all the attributes of the given Primitive object::

`attributes`

an array of Attribute pointers

`n_attributes`

the number of elements in attributes

source

pub fn set_first_vertex(&self, first_vertex: i32)

source

pub fn set_indices(&self, indices: &Indices, n_indices: i32)

Associates a sequence of Indices with the given self.

Indices provide a way to virtualize your real vertex data by providing a sequence of indices that index into your real vertex data. The GPU will walk though the index values to indirectly lookup the data for each vertex instead of sequentially walking through the data directly. This lets you save memory by indexing shared data multiple times instead of duplicating the data.

The value passed as n_indices will simply update the Primitive <structfield>n_vertices</structfield> property as if Primitive::set_n_vertices were called. This property defines the number of vertices to draw or, put another way, how many indices should be read from indices when drawing.

The Primitive <structfield>first_vertex</structfield> property also affects drawing with indices by defining the first entry of the indices to start drawing from.

`indices`

A Indices array

`n_indices`

The number of indices to reference when drawing

source

pub fn set_mode(&self, mode: VerticesMode)

source

pub fn set_n_vertices(&self, n_vertices: i32)

Specifies how many vertices should be read when drawing the given self.

Usually this value is set implicitly when associating vertex data or indices with a Primitive.

To be clear; it doesn’t refer to the number of vertices - in terms of data - associated with the primitive it’s just the number of vertices to read and draw.

`n_vertices`

The number of vertices to read when drawing.

source

pub fn texture_set_auto_mipmap(
primitive_texture: &PrimitiveTexture,
value: bool
)

Trait Implementations

source

impl Display for Primitive

source

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

Formats the value using the given formatter. Read more

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

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

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

Mutably borrows from an owned value. Read more

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

impl<Target, From> Getter<From> for Target where
From: AsRef<Target>,

fn get(from: &From) -> &Target

Typed getter

impl<'a, T, C, M> Inspect<'a, C, &'a C, M> for T

fn inspect(ctx: &'a mut C) -> &'a C

Inspect the context.

impl<'a, T, C, M> Inspect<'a, C, &'a mut C, M> for T

fn inspect(ctx: &'a mut C) -> &'a mut C

Inspect the context.

impl<'a, T, C, M> Inspect<'a, C, (), M> for T

fn inspect(&'a mut C)

Inspect the context.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,

fn into_color(self) -> To

Convert into color

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> SetParameter for T

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

Sets value as a parameter of self.

source

impl<T> ToString for T where
T: Display + ?Sized,

source

default fn to_string(&self) -> String

Converts the given value to a String. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct components::platform::core::Primitive

Implementations

impl Primitive

pub fn new(mode: VerticesMode, n_vertices: i32, args: &[f64]) -> Primitive

pub fn new_p2(context: &Context, mode: VerticesMode, data: &[&P2]) -> Primitive

pub fn new_p2c4( context: &Context, mode: VerticesMode, data: &[&P2C4]) -> Primitive

pub fn new_p2t2( context: &Context, mode: VerticesMode, data: &[&P2T2]) -> Primitive

pub fn new_p2t2c4( context: &Context, mode: VerticesMode, data: &[&P2T2C4]) -> Primitive

pub fn new_p3(context: &Context, mode: VerticesMode, data: &[&P3]) -> Primitive

pub fn new_p3c4( context: &Context, mode: VerticesMode, data: &[&P3C4]) -> Primitive

pub fn new_p3t2( context: &Context, mode: VerticesMode, data: &[&P3T2]) -> Primitive

pub fn new_p3t2c4( context: &Context, mode: VerticesMode, data: &[&P3T2C4]) -> Primitive

pub fn with_attributes( mode: VerticesMode, n_vertices: i32, attributes: &[&Attribute], n_attributes: i32) -> Primitive

pub fn copy(&self) -> Option<Primitive>

pub fn draw<P>(&self, framebuffer: &P, pipeline: &Pipeline) where P: Is<Framebuffer>,

pub fn foreach_attribute<P>(&self, callback: P) where P: FnMut(&Primitive, &Attribute) -> i32,

pub fn first_vertex(&self) -> i32

pub fn indices(&self) -> Option<Indices>

pub fn mode(&self) -> VerticesMode

pub fn n_vertices(&self) -> i32

pub fn set_attributes(&self, attributes: &[&Attribute], n_attributes: i32)

pub fn set_first_vertex(&self, first_vertex: i32)

pub fn set_indices(&self, indices: &Indices, n_indices: i32)

pub fn set_mode(&self, mode: VerticesMode)

pub fn set_n_vertices(&self, n_vertices: i32)

pub fn texture_set_auto_mipmap( primitive_texture: &PrimitiveTexture, value: bool)

Trait Implementations

impl Display for Primitive

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

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<T> Any for T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

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

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<T> From<T> for T

fn from(t: T) -> T

impl<Target, From> Getter<From> for Target where From: AsRef<Target>,

fn get(from: &From) -> &Target

impl<'a, T, C, M> Inspect<'a, C, &'a C, M> for T

fn inspect(ctx: &'a mut C) -> &'a C

impl<'a, T, C, M> Inspect<'a, C, &'a mut C, M> for T

fn inspect(ctx: &'a mut C) -> &'a mut C

impl<'a, T, C, M> Inspect<'a, C, (), M> for T

fn inspect(&'a mut C)

impl<T, U> Into<U> for T where U: From<T>,

fn into(self) -> U

impl<Fr, To> IntoColor<To> for Fr where To: FromColor<Fr>,

fn into_color(self) -> To

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::()

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> SetParameter for T

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

impl<T> ToString for T where T: Display + ?Sized,

default fn to_string(&self) -> String

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

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

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

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

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

impl<T> Upcast<T> for T

fn upcast(&self) -> Option<&T>

impl<V, T> VZip<V> for T where V: MultiLane<T>,

fn vzip(self) -> V

pub fn new(mode: VerticesMode, n_vertices: i32, args: &[f64 ]) -> Primitive

pub fn new_p2(context: &Context, mode: VerticesMode, data: &[&P2 ]) -> Primitive

pub fn new_p2c4(
context: &Context,
mode: VerticesMode,
data: &[&P2C4 ]
) -> Primitive

pub fn new_p2t2(
context: &Context,
mode: VerticesMode,
data: &[&P2T2 ]
) -> Primitive

pub fn new_p2t2c4(
context: &Context,
mode: VerticesMode,
data: &[&P2T2C4 ]
) -> Primitive

pub fn new_p3(context: &Context, mode: VerticesMode, data: &[&P3 ]) -> Primitive

pub fn new_p3c4(
context: &Context,
mode: VerticesMode,
data: &[&P3C4 ]
) -> Primitive

pub fn new_p3t2(
context: &Context,
mode: VerticesMode,
data: &[&P3T2 ]
) -> Primitive

pub fn new_p3t2c4(
context: &Context,
mode: VerticesMode,
data: &[&P3T2C4 ]
) -> Primitive

pub fn with_attributes(
mode: VerticesMode,
n_vertices: i32,
attributes: &[&Attribute ],
n_attributes: i32
) -> Primitive

pub fn draw<P>(&self, framebuffer: &P, pipeline: &Pipeline) where
P: Is<Framebuffer>,

pub fn foreach_attribute<P>(&self, callback: P) where
P: FnMut(&Primitive, &Attribute) -> i32,

pub fn set_attributes(&self, attributes: &[&Attribute ], n_attributes: i32)

pub fn texture_set_auto_mipmap(
primitive_texture: &PrimitiveTexture,
value: bool
)

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<Target, From> Getter<From> for Target where
From: AsRef<Target>,

impl<T, U> Into<U> for T where
U: From<T>,

impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,

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

impl<T> ToString for T where
T: Display + ?Sized,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<V, T> VZip<V> for T where
V: MultiLane<T>,