### 14 releases (4 breaking)

✓ Uses Rust 2018 edition

0.8.2 | Nov 6, 2019 |
---|---|

0.8.0 | Oct 14, 2019 |

0.7.1 | Jul 8, 2019 |

#**23** in Game development

**783** downloads per month

Used in **1** crate

**MIT/Apache**

195KB

5K
SLoC

# glam

A simple and fast 3D math library for games and graphics.

## Development status

is in alpha stage. Minimal base functionality has been implemented
and the look and feel of the API has solidified.`glam`

## Features

- Only single precision floating point (

) arithmetic is supported`f32` - vectors:

,`Vec3`

,`Vec3``Vec4` - square matrices:

,`Mat2`

,`Mat3``Mat4` - a quaternion type:
`Quat`

### SIMD

The

, `Vec3`

and `Vec4`

types use SSE2 on x86/x86_64 architectures. `Quat`

and `Mat3`

also use SSE2 for some functionality such as inverse and transpose.
Not everything has a SIMD implementation yet.`Mat4`

Note that this does result in some wasted space in the case of

and `Vec3`

as the SIMD vector type is 16 bytes large and 16 byte aligned.`Mat3`

outperforms similar Rust libraries such as `glam`

and
`cgmath`

for common operations as tested by the
`nalgebra-glm`

project.`mathbench`

If you are more concerned with size than speed you can build glam with the
feature

enabled to disable SIMD usage.`scalar-math`

The

and `Vec2`

types do not have a SIMD implemenation. `Mat2`

may benefit
from a SIMD impelemtation in the future.`Mat2`

Due to the use of SIMD, vector elements may only be get and set via accessor
methods, e.g.

and `Vec3 ::`x

`(`

`)`

`Vec3``::`set_x`(``)`

. If getting or setting more than
one element it is more efficient to convert from tuples or arrays:`let` `(`x`,` y`,` z`)` `=` v`.``into``(``)``;`

### Optional features

- for interoperating with other 3D math libraries`mint`

- implementations of`rand`

trait for all`Distribution`

types. This is primarily used for unit testing`glam`

- implementations of`serde`

and`Serialize`

for all`Deserialize`

types. Note that serialization should work between builds of`glam`

with and without SIMD enabled`glam`

### Feature gates

- compiles with SIMD support disabled`scalar-math`

- adds assertions which check the validity of parameters passed to`glam-assert`

to help catch runtime errors`glam`

## Conventions

### Column vectors

interprets vectors as column matrices (also known as "column vectors")
meaning when transforming a vector with a matrix the matrix goes on the left,
e.g. `glam`

. DirectX uses row vectors, OpenGL uses column vectors. There
are pros and cons to both.`v ' = Mv`

### Column-major order

Matrices are stored in column major format. Each column vector is stored in contiguous memory.

### Co-ordinate system

When relevant, a left-handed co-ordinate system is used:

- right`+`X

- up`+`Y

- forward`+`Z

The co-ordinate system primary affects functions that deal with Euler angle rotations.

Rotations follow the left-hand rule.

## Design Philosophy

The design of this library is guided by a desire for simplicity and good performance.

- Only single precision floating point (

) arithmetic is supported`f32` - No traits or generics for simplicity of implementation and usage
- All dependencies are optional (e.g.

,`mint`

and`rand`

)`serde` - Follows the Rust API Guidelines where possible
- Aiming for 100% test coverage
- Common functionality is benchmarked using Criterion.rs

## Future work

- Writing documentation
- Experiment with a using a 4x3 matrix as a 3D transform type that can be more
efficient than

for certain operations like inverse and multiplies`Mat4`

support`no-std`- Experiment with replacing SSE2 code with

from the`f32x4`

library - this will mean other architectures get SIMD support`packed_simd`

## Naming

is a play on the name of the popular C++ library `glam`

.`glm`

## License

Licensed under either of

- Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

## Contribution

Contributions in any form (issues, pull requests, etc.) to this project must adhere to Rust's Code of Conduct.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

## Support

If you are interested in contributing or have a request or suggestion create an issue on github.