math_types.h · C++ API · 1/2

inline constexpr float degrees(float rad)

const float* data() const

float* data()

float determinant() const

static Mat4 fromQuat(const Quat& q)

static Mat4 fromTRS(const Vec3& pos, const Quat& rot, const Vec3& scl)

static Mat4 identity()

Mat4 inverse() const

static Mat4 lookAt(const Vec3& eye, const Vec3& center, const Vec3& up)

Mat4()

float& operator()(int row, int col)

float operator()(int row, int col) const

Mat4 operator*(const Mat4& b) const

Vec4 operator*(const Vec4& v) const

static Mat4 ortho(float left, float right, float bottom, float top, float zNear, float zFar)

static Mat4 perspective(float fovY, float aspect, float zNear, float zFar)

Vec3 position() const

static Mat4 rotateX(float rad)

static Mat4 rotateY(float rad)

static Mat4 rotateZ(float rad)

static Mat4 scale(const Vec3& s)

Vec3 transformPoint(const Vec3& p) const

Vec3 transformVector(const Vec3& v) const

static Mat4 translate(const Vec3& t)

Mat4 transposed() const

static Mat4 zero()

inline Vec3 operator*(float s, const Vec3& v)

Quat conjugate() const

static Quat fromAxisAngle(const Vec3& axis, float radians)

static Quat fromEuler(float pitch, float yaw, float roll)

static Quat identity()

Quat inverse() const

float length() const

float lengthSq() const

Quat normalized() const

Quat operator*(const Quat& q) const

constexpr Quat() = default;

constexpr Quat(float x_, float y_, float z_, float w_) : x(x_), y(y_), z(z_), w(w_)

Vec3 rotate(const Vec3& v) const

static Quat slerp(const Quat& a, const Quat& b, float t)

inline constexpr float radians(float deg)

float dot(const Vec2& v) const

float length() const

float lengthSq() const

Vec2 normalized() const

Vec2 operator-(const Vec2& v) const

Vec2 operator*(float s) const

Vec2 operator+(const Vec2& v) const

constexpr Vec2() = default;

constexpr Vec2(float x_, float y_) : x(x_), y(y_)

Vec3 cross(const Vec3& v) const

float dot(const Vec3& v) const

static constexpr Vec3 forward()

float length() const

float lengthSq() const

static Vec3 lerp(const Vec3& a, const Vec3& b, float t)

Vec3 normalized() const

static constexpr Vec3 one()

Vec3 operator-() const

Vec3 operator-(const Vec3& v) const

Vec3& operator-=(const Vec3& v)

bool operator!=(const Vec3& v) const

Vec3 operator*(float s) const

Vec3& operator*=(float s)

Vec3 operator/(float s) const

Vec3 operator+(const Vec3& v) const

Vec3& operator+=(const Vec3& v)

bool operator==(const Vec3& v) const

static constexpr Vec3 right()

static constexpr Vec3 up()

constexpr explicit Vec3(float s) : x(s), y(s), z(s)

constexpr Vec3() = default;

constexpr Vec3(float x_, float y_, float z_) : x(x_), y(y_), z(z_)

static constexpr Vec3 zero()

float dot(const Vec4& v) const

Vec4 operator*(float s) const

Vec4 operator+(const Vec4& v) const

constexpr Vec4(const Vec3& v, float w_) : x(v.x), y(v.y), z(v.z), w(w_)

constexpr Vec4() = default;

constexpr Vec4(float x_, float y_, float z_, float w_) : x(x_), y(y_), z(z_), w(w_)