Struct dx::platform::core::Primitive

pub struct 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

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.

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.

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.

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.

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.

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.

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.

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.

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

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: Is<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 PrimitiveAttributeCallback to be called for each attribute

user_data

Private data that will be passed to the callback

pub fn first_vertex(&self) -> i32

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

Returns

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

pub fn mode(&self) -> VerticesMode

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.

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

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.

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

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.

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.

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

Trait Implementations

impl Display for Primitive

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

Formats the value using the given formatter.