### 12 releases

✓ Uses Rust 2018 edition

0.0.11 | Mar 1, 2019 |
---|---|

0.0.10 | Aug 30, 2018 |

0.0.9 | Jan 21, 2018 |

0.0.8 | Nov 25, 2017 |

0.0.1 | Aug 20, 2017 |

#**31** in Graphics APIs

**72** downloads per month

Used in **1** crate

**MIT**license

401KB

10K
SLoC

**Plexus** is a Rust library for 2D and 3D mesh processing.

## Primitives and Iterator Expressions

Streams of geometric data can be generated from primitives like cubes and
spheres using iterator expressions. Primitives emit topological structures like

s or `Triangle`

s, which contain arbitrary data in their vertices. These
can be transformed and decomposed via tessellation and other operations.`Quad`

`use` `nalgebra``::`Point3`;`
`use` `plexus``::``buffer``::`MeshBuffer3`;`
`use` `plexus``::``prelude``::``*``;`
`use` `plexus``::``primitive``::``sphere``::`UvSphere`;`
`//` Example module in the local crate that provides basic rendering.
`use` `render``::``{``self``,` Color`,` Vertex`}``;`
`//` Construct a linear buffer of index and vertex data from a sphere primitive.
`let` buffer `=` `UvSphere``::`new`(``16``,` `16``)`
`.``polygons_with_position``(``)`
`.``map_vertices``(``|``position``|` `->` `Point3``<``f64``>` `{` position`.``into``(``)` `}``)`
`.``map_vertices``(``|``position``|` `Vertex``::`new`(`position`,` `Color``::`white`(``)``)``)`
`.``triangulate``(``)`
`.``collect``::``<`MeshBuffer3`<``u32`, Vertex`>``>``(``)``;`
`render``::`draw`(`buffer`.``as_index_slice``(``)``,` buffer`.``as_vertex_slice``(``)``)``;`

For an example of rendering, see the viewer example.

## Half-Edge Graph Meshes

, represented as a half-edge
graph, supports
arbitrary geometry for vertices, arcs (half-edges), edges, and faces. Graphs
are persistent and can be traversed and manipulated in ways that iterator
expressions and linear buffers cannot, such as circulation, extrusion, merging,
and joining.`MeshGraph`

`use` `nalgebra``::`Point3`;`
`use` `plexus``::``graph``::`MeshGraph`;`
`use` `plexus``::``prelude``::``*``;`
`use` `plexus``::``primitive``::``sphere``::``{`Bounds`,` UvSphere`}``;`
`//` Construct a mesh from a sphere primitive. The vertex geometry is convertible
`//` to `Point3` via the `FromGeometry` trait in this example.
`let` `mut` graph `=` `UvSphere``::`new`(``8``,` `8``)`
`.``polygons_with_position_from``(``Bounds``::`unit_width`(``)``)`
`.``collect``::``<`MeshGraph`<`Point3`<``f64``>``>``>``(``)``;`
`//` Extrude a face in the mesh.
`let` abc `=` graph`.``faces``(``)``.``nth``(``0``)``.``unwrap``(``)``.``key``(``)``;`
`if` `let` `Ok``(`face`)` `=` graph`.``face_mut``(`abc`)``.``unwrap``(``)``.``extrude``(``1.``0``)` `{`
`//` ...
`}`

Plexus avoids exposing very basic topological operations like inserting individual vertices, because they can easily be done incorrectly. Instead, meshes are typically manipulated with higher-level operations like splitting and joining.

## Geometric Traits

Graphs support arbitrary geometry for vertices, arcs, edges, and faces
(including no geometry at all) via optional traits. Implementing these traits
enables geometric features, but only one trait is required:

.`Geometry`

`use` `decorum``::``R64``;`
`use` `nalgebra``::``{`Point3`,` Vector3`}``;`
`use` `plexus``::``geometry``::``convert``::`AsPosition`;`
`use` `plexus``::``geometry``::`Geometry`;`
`#``[``derive``(``Clone``,` Copy`,` Eq`,` Hash`,` PartialEq`)``]`
`pub` `struct` `VertexGeometry` `{`
`pub` `position``:` `Point3``<`R64`>`,
`pub` `normal``:` `Vector3``<`R64`>`,
`}`
`impl` `Geometry ``for`` ``VertexGeometry` `{`
`type` `Vertex` `=` `Self``;`
`type` `Arc` `=` `(``)``;`
`type` `Edge` `=` `(``)``;`
`type` `Face` `=` `(``)``;`
`}`
`impl` `AsPosition ``for`` ``VertexGeometry` `{`
`type` `Target` `=` `Point3``<`R64`>``;`
`fn` `as_position``(``&``self``)`` ``->` `&``Self``::`Target `{`
`&``self``.`position
`}`
`fn` `as_position_mut``(``&``mut` `self``)`` ``->` `&``mut` `Self``::`Target `{`
`&``mut` `self``.`position
`}`
`}`

Geometric operations are vertex-based. By implementing

to expose
positional data from vertices and implementing geometric traits for that
positional data, operations like extrusion are exposed.`AsPosition`

Geometric traits are optionally implemented for types in the
cgmath,
mint, and
nalgebra crates so that common types can be
used out-of-the-box for vertex geometry. See the

,
`geometry-cgmath`

, and `geometry-mint`

crate features. By default, the
`geometry-nalgebra`

feature is enabled. Both 2D and 3D geometry are supported
by mesh operations.`geometry-nalgebra`

#### Dependencies

~3MB

~52K SLoC