GLSL mathematics for Rust programming language.
glm-rs is yet another Rust math library for graphics applications. Inspired by the great GLM library for C++, the goal is to provide familiar math API to porgrammers who knows GLSL as well.
Like GLM, following GLSL conventions is a strict policy of glm-rs too. glm crate implements all GLSL data types, operators and built-in functions. However, Rust is not a C-like language, and the syntax/semantics distances from Rust to GLSL is way longer than from C++ to GLSL. This is the major reason of following feature and syntax differences to GLSL specification,
- Precision qualifiers is not supported,
- Half float type is not available, yet,
There is no vector swizzle operators. For example, you can't do this,
let mut my_vec2 = my_vec4.wz; // and, my_vec2.yx = my_vec4.xx;
Part of swizzle operators can be done but must be in a very tedious way at the moment. The plan is to implemente accessing swizzle operators after Rust macro supports concatenating identifiers.
Because Rust does not support function name overloading, loads of convenient constructor functions can't be implemented. For example, you can't do this,
let v2 = vec2(1., 2.); // compile error: this function takes 3 parameters but 2 parameters were supplied [E0061] let v3 = vec3(v2, 3.);
This will be fixed in future version by introducing functions like
no_run fn vec21(x: Vec2, y: f32) -> Vec3, in which function names indicate the forms of result vectors. - Also because of lacking of function name overloading, following built-in functions are added,
_sstands for scalar, which means this is a variant of original function that some parameters are specific to be scalar, instead a generic type.
See documentation of these functions for detail. - Most explicit conversion functions, like
dmat4x3etc., do not work, for the same reason as above. This is rather inconvenient, and the plan is introducing functions like
to_dmat4x3in future version. - No implicit conversion. - Explicit type conversion function
boolis renamed to
boolean. - Many explicit type conversion functions for vector types are introduced. In GLSL spec, these fucntions have the same name as vector type constructors, which is not allowed in Rust. The naming rule is to get a vector type conversion fucntion, adds a
to_before the constructor function. For example,
let v = to_vec2(1_f32); assert_eq!(v, vec2(1., 1.));
- Lots of convertion functions are still missing (e.g., from matrices to vectors). These functions are syntax sugar actually, and will be fixed along with the constructor issue in future version.
GLSL uses out parameter for returning multiple results of functions. In Rust, we can do this by returning a tuple. Following functions' signatures are changed because of this,
The rule of changing is the out parameter is the second member of the return tuple. - Function parameters of matrix related functions (e.g.,
cross) are passed by reference, instead of by value as in the GLSL spec. For example,
let m = mat2(1., 2., 3., 4.); // instead of `inverse(m)`, let inv = inverse(&m);
- Built-in function
modis renamed to
fmod, because mod is a Rust keyword.
Built-in funcions defined in GLSL specification chapter 8.
Functions that extend the functionalities of GLSL data types.
Trait for comparing types that are derived from float numbers.
Trait for primitive float number type.
Marker trait for primitive integer number type.
Trait for primitive number type.
Generic boolean vector type.
Generic float number type.
Generic type of vectors of float number.
Generic interger type.
Generic Matrix type.
Generic numeric type.
Trait of all vector types that are GenNum.
Generic type of square matrix.
Generic vector type.
This trait provides parameterized function
Marker trait for primitive types.
Trait for numerical types that have negative values.
Returns the result of
Returns the result of