Struct cogl::Primitive

pub struct Primitive(_, _);

Implementations

impl Primitive

pub fn new_p2(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP2]
) -> 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:

CoglVertexP2 triangle[] =
{
  { 0,   300 },
  { 150, 0,  },
  { 300, 300 }
};
prim = cogl_primitive_new_p2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP2C4]
) -> 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:

CoglVertexP2C4 triangle[] =
{
  { 0,   300,  0xff, 0x00, 0x00, 0xff },
  { 150, 0,    0x00, 0xff, 0x00, 0xff },
  { 300, 300,  0xff, 0x00, 0x00, 0xff }
};
prim = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p2t2(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP2T2]
) -> 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:

CoglVertexP2T2 triangle[] =
{
  { 0,   300,  0.0, 1.0},
  { 150, 0,    0.5, 0.0},
  { 300, 300,  1.0, 1.0}
};
prim = cogl_primitive_new_p2t2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p2t2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP2T2C4]
) -> 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:

CoglVertexP2T2C4 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 = cogl_primitive_new_p2t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p3(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP3]
) -> 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:

CoglVertexP3 triangle[] =
{
  { 0,   300, 0 },
  { 150, 0,   0 },
  { 300, 300, 0 }
};
prim = cogl_primitive_new_p3 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p3c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP3C4]
) -> 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:

CoglVertexP3C4 triangle[] =
{
  { 0,   300, 0,  0xff, 0x00, 0x00, 0xff },
  { 150, 0,   0,  0x00, 0xff, 0x00, 0xff },
  { 300, 300, 0,  0xff, 0x00, 0x00, 0xff }
};
prim = cogl_primitive_new_p3c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p3t2(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP3T2]
) -> 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:

CoglVertexP3T2 triangle[] =
{
  { 0,   300, 0,  0.0, 1.0},
  { 150, 0,   0,  0.5, 0.0},
  { 300, 300, 0,  1.0, 1.0}
};
prim = cogl_primitive_new_p3t2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

<note>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)</note>

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.

pub fn new_p3t2c4(
    context: &Context,
    mode: VerticesMode,
    data: &[&VertexP3T2C4]
) -> 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:

CoglVertexP3T2C4 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 = cogl_primitive_new_p3t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
cogl_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.

<note>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)</note>

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.

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

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

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

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

Iterates all the attributes of the given Primitive.

callback

A CoglPrimitiveAttributeCallback to be called for each attribute

user_data

Private data that will be passed to the callback

pub fn get_first_vertex(&self) -> i32

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

Returns

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

pub fn get_mode(&self) -> VerticesMode

pub fn get_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.

<note>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.</note>

Returns

The number of vertices to read when drawing.

pub fn set_first_vertex(&self, first_vertex: i32)

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.

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

indices

A Indices array

n_indices

The number of indices to reference when drawing

pub fn set_mode(&self, mode: VerticesMode)

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.

<note>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.</note>

n_vertices

The number of vertices to read when drawing.

Trait Implementations

impl Clone for Primitive

fn clone(&self) -> Primitive

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Primitive

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

Formats the value using the given formatter.

impl Display for Primitive

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

Formats the value using the given formatter.

impl Eq for Primitive

impl Hash for Primitive

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl IsA<Object> for Primitive

impl Ord for Primitive

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

This method returns an Ordering between self and other.

#[must_use]

pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: ObjectType> PartialEq<T> for Primitive

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

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

#[must_use]

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

This method tests for !=.

impl<T: ObjectType> PartialOrd<T> for Primitive

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

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Primitive

fn static_type() -> Type

Returns the type identifier of Self.