GauStudio

To enable swizzling (e.g., vec.xyz(), vec.rgba), define GLM_FORCE_SWIZZLE before including GLM headers.

Warning: Enabling swizzling can significantly increase binary size and compilation time.

Implementation Modes:

1. Standard C++98: Uses member functions (e.g., ColorRGBA.bgr()). These return copies and cannot be used as L-values (you cannot assign to them).
2. Language Extensions (Visual C++, GCC, Clang): Uses anonymous struct/union extensions to allow both L-value and R-value swizzling (e.g., ColorRGBA.bgra = ColorRGBA.rgba;).

Note: When using extension-based swizzling, the resulting types are not standard vector types and must be explicitly converted via a constructor vec4(Color.rgba) or operator Color.rgba() before being passed to functions like clamp().

#define GLM_FORCE_SWIZZLE
#include <glm/glm.hpp>

// C++98 style (R-value only)
glm::vec3 const ColorBGR = ColorRGBA.bgr();

// Extension style (L-value and R-value)
// Only guaranteed to work with Visual C++!
glm::vec4 ColorBGRA = ColorRGBA.bgra;

GLM provides core functionality and various extensions (prefixed with GLM_EXT_, GLM_GTX_, or GLM_GTC_).

Common Extensions

• Matrix Operations: GLM_EXT_matrix_integer, GLM_EXT_matrix_clip_space, GLM_GTX_matrix_factorisation.
• Vector Operations: GLM_EXT_vector_reciprocal, GLM_EXT_vector_intX, GLM_EXT_vector_uintX, GLM_EXT_vector_relational.
• Quaternion Support: GLM_GTC_quaternion, GLM_GTX_quaternion.
• Color & Packing: GLM_GTC_packing, GLM_GTX_color_encoding, GLM_GTX_texture.

Key Functions and Improvements

• Math Utilities: glm::clamp, glm::repeat, glm::mirrorClamp, glm::mirrorRepeat (added in 0.9.9.8).
• Rounding: glm::iround and glm::uround (added in 0.9.9.9).
• Matrix Mixing: glm::mix implementation for matrices (added in 0.9.9.4).
• SIMD/Hardware Support: Support for Neon (ARM) and SYCL (added in 0.9.9.6).

To minimize compilation times, avoid global headers and instead include only the specific core features you need. GLM provides individual headers for vectors, matrices, and various mathematical function groups based on the GLSL specification.

// Include GLM core features
#include <glm/vec2.hpp>           // vec2
#include <glm/vec3.hpp>           // vec3
#include <glm/mat4x4.hpp>         // mat4
#include <glm/trigonometric.hpp>  // radians

// Include GLM extension
#include <glm/ext/matrix_transform.hpp> // perspective, translate, rotate

glm::mat4 transform(glm::vec2 const& Orientation, glm::vec3 const& Translate, glm::vec3 const& Up)
{
    glm::mat4 Proj = glm::perspective(glm::radians(45.f), 1.33f, 0.1f, 10.f);
    glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.f), Translate);
    glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Orientation.y, Up);
    glm::mat4 View = glm::rotate(ViewRotateX, Orientation.x, Up);
    glm::mat4 Model = glm::mat4(1.0f);
    return Proj * View * Model;
}

GLM is a header-only library. For convenience, you can include the main <glm/glm.hpp> header to access core GLSL mathematics functionality, and <glm/ext.hpp> to access extensions like perspective, translate, and rotate.

Warning: Including these global headers can significantly increase compilation times because they pull in a large amount of code. Use them primarily for small projects or when build speed is not a priority.

#include <glm/glm.hpp> // vec2, vec3, mat4, radians
#include <glm/ext.hpp> // perspective, translate, rotate

glm::mat4 transform(glm::vec2 const& Orientation, glm::vec3 const& Translate, glm::vec3 const& Up)
{
    glm::mat4 Proj = glm::perspective(glm::radians(45.f), 1.33f, 0.1f, 10.f);
    glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.f), Translate);
    glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Orientation.y, Up);
    glm::mat4 View = glm::rotate(ViewRotateX, Orientation.x, Up);
    glm::mat4 Model = glm::mat4(1.0f);
    return Proj * View * Model;
}