sbgl_math.h File Reference

Single-header math library for SBgl. More...

#include <math.h>
#include <stdbool.h>
#include <stdint.h>

Include dependency graph for sbgl_math.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	sbgl_OrthoParams
	Parameters for orthographic projection. More...
union	sbgl_Vec2
	2D Vector. More...
union	sbgl_Vec3
	3D Vector, 16-byte aligned and padded for SIMD safety. More...
union	sbgl_Vec4
	4D Vector, 16-byte aligned. More...
union	sbgl_Quat
	Quaternion, 16-byte aligned. More...
struct	sbgl_Mat4
	4x4 Matrix, 16-byte aligned, column-major. More...

Macros
#define	SBGL_ALIGN(n)
#define	SBGL_PI   3.14159265358979323846f

Functions
static sbgl_Vec2	sbgl_Vec2Set (float x, float y)
	Creates a Vec2.
static sbgl_Vec3	sbgl_Vec3Set (float x, float y, float z)
	Creates a Vec3, correctly padded.
static sbgl_Vec4	sbgl_Vec4Set (float x, float y, float z, float w)
	Creates a Vec4.
static sbgl_Quat	sbgl_QuatSet (float x, float y, float z, float w)
	Creates a Quat.
static float	sbgl_InvSqrt (float x)
	Approximate Inverse Square Root algorithm.
static sbgl_Vec3	sbgl_Vec3Add (sbgl_Vec3 a, sbgl_Vec3 b)
	Adds two Vec3 vectors.
static sbgl_Vec3	sbgl_Vec3Sub (sbgl_Vec3 a, sbgl_Vec3 b)
	Subtracts b from a.
static sbgl_Vec3	sbgl_Vec3Mul (sbgl_Vec3 a, float s)
	Multiplies a Vec3 by a scalar.
static float	sbgl_Vec3Dot (sbgl_Vec3 a, sbgl_Vec3 b)
	Computes the dot product of two Vec3 vectors.
static sbgl_Vec3	sbgl_Vec3Cross (sbgl_Vec3 a, sbgl_Vec3 b)
	Computes the cross product of two Vec3 vectors.
static float	sbgl_Vec3Length (sbgl_Vec3 v)
	Returns the length of a Vec3.
static sbgl_Vec3	sbgl_Vec3Normalize (sbgl_Vec3 v)
	Normalizes a Vec3.
static sbgl_Vec4	sbgl_Vec4Add (sbgl_Vec4 a, sbgl_Vec4 b)
	Adds two Vec4 vectors.
static sbgl_Vec4	sbgl_Vec4Mul (sbgl_Vec4 a, float s)
	Multiplies a Vec4 by a scalar.
static sbgl_Quat	sbgl_QuatIdentity (void)
	Returns an identity quaternion.
static sbgl_Quat	sbgl_QuatMul (sbgl_Quat a, sbgl_Quat b)
	Multiplies two quaternions.
static sbgl_Quat	sbgl_QuatFromAxisAngle (sbgl_Vec3 axis, float angle_rad)
	Creates a quaternion from an axis and an angle (in radians).
static sbgl_Mat4	sbgl_Mat4Identity (void)
	Returns an identity matrix.
static sbgl_Mat4	sbgl_QuatToMat4 (sbgl_Quat q)
	Converts a quaternion to a rotation matrix.
static sbgl_Mat4	sbgl_Mat4Mul (sbgl_Mat4 a, sbgl_Mat4 b)
	Multiplies two matrices.
static sbgl_Vec4	sbgl_Mat4MulVec4 (sbgl_Mat4 m, sbgl_Vec4 v)
	Multiplies a matrix by a Vec4.
static sbgl_Mat4	sbgl_Mat4Translate (sbgl_Vec3 v)
	Creates a translation matrix.
static sbgl_Mat4	sbgl_Mat4Scale (sbgl_Vec3 v)
	Creates a scaling matrix.
static sbgl_Mat4	sbgl_Mat4Perspective (float fov_y_rad, float aspect, float near, float far)
	Creates a perspective projection matrix.
static sbgl_Mat4	sbgl_Mat4Rotate (float angle_rad, sbgl_Vec3 axis)
	Creates a rotation matrix from axis and angle.
static sbgl_Mat4	sbgl_Mat4Orthographic (sbgl_OrthoParams p)
	Creates an orthographic projection matrix.
static sbgl_Mat4	sbgl_Mat4LookAt (sbgl_Vec3 eye, sbgl_Vec3 center, sbgl_Vec3 up)
	Creates a look-at view matrix.

Detailed Description

Single-header math library for SBgl.

Provides SIMD-ready vector, matrix, and quaternion operations using aligned memory layouts and static inline functions.

Definition in file sbgl_math.h.

Macro Definition Documentation

SBGL_ALIGN

#define SBGL_ALIGN

(

n

)

Value:

__attribute__((aligned(n)))

Definition at line 19 of file sbgl_math.h.

SBGL_PI

#define SBGL_PI   3.14159265358979323846f

Definition at line 22 of file sbgl_math.h.

Function Documentation

sbgl_InvSqrt()

static float sbgl_InvSqrt ( float x )

inlinestatic

Approximate Inverse Square Root algorithm.

Uses C99-compliant union punning to avoid strict-aliasing violations.

Definition at line 114 of file sbgl_math.h.

                                          {
    union {
        float f;
        uint32_t i;
    } pun;
 
    float xhalf = 0.5f * x;
    pun.f = x;
    pun.i = 0x5f3759df - (pun.i >> 1);
    pun.f = pun.f * (1.5f - xhalf * pun.f * pun.f);
    // Second iteration for better precision
    pun.f = pun.f * (1.5f - xhalf * pun.f * pun.f);
    return pun.f;
}

sbgl_Mat4Identity()

static sbgl_Mat4 sbgl_Mat4Identity ( void )

inlinestatic

Returns an identity matrix.

Definition at line 200 of file sbgl_math.h.

                                                {
    sbgl_Mat4 res = { 0 };
    res.m[0][0] = 1.0f;
    res.m[1][1] = 1.0f;
    res.m[2][2] = 1.0f;
    res.m[3][3] = 1.0f;
    return res;
}

sbgl_Mat4LookAt()

static sbgl_Mat4 sbgl_Mat4LookAt ( sbgl_Vec3 eye, sbgl_Vec3 center, sbgl_Vec3 up )

inlinestatic

Creates a look-at view matrix.

Definition at line 308 of file sbgl_math.h.

                                                                                       {
    sbgl_Vec3 f = sbgl_Vec3Normalize(sbgl_Vec3Sub(center, eye));
    sbgl_Vec3 s = sbgl_Vec3Normalize(sbgl_Vec3Cross(f, up));
    sbgl_Vec3 u = sbgl_Vec3Cross(s, f);
 
    sbgl_Mat4 res = sbgl_Mat4Identity();
    res.m[0][0] = s.x;
    res.m[1][0] = s.y;
    res.m[2][0] = s.z;
    res.m[0][1] = u.x;
    res.m[1][1] = u.y;
    res.m[2][1] = u.z;
    res.m[0][2] = -f.x;
    res.m[1][2] = -f.y;
    res.m[2][2] = -f.z;
    res.m[3][0] = -sbgl_Vec3Dot(s, eye);
    res.m[3][1] = -sbgl_Vec3Dot(u, eye);
    res.m[3][2] = sbgl_Vec3Dot(f, eye);
    return res;
}

sbgl_Mat4Mul()

static sbgl_Mat4 sbgl_Mat4Mul ( sbgl_Mat4 a, sbgl_Mat4 b )

inlinestatic

Multiplies two matrices.

Definition at line 240 of file sbgl_math.h.

                                                               {
    sbgl_Mat4 res = { 0 };
    for (int c = 0; c < 4; ++c) {
        for (int r = 0; r < 4; ++r) {
            res.m[c][r] = a.m[0][r] * b.m[c][0] + a.m[1][r] * b.m[c][1] + a.m[2][r] * b.m[c][2] +
                          a.m[3][r] * b.m[c][3];
        }
    }
    return res;
}

sbgl_Mat4MulVec4()

static sbgl_Vec4 sbgl_Mat4MulVec4 ( sbgl_Mat4 m, sbgl_Vec4 v )

inlinestatic

Multiplies a matrix by a Vec4.

Definition at line 252 of file sbgl_math.h.

                                                                   {
    return (sbgl_Vec4){ { m.m[0][0] * v.x + m.m[1][0] * v.y + m.m[2][0] * v.z + m.m[3][0] * v.w,
                          m.m[0][1] * v.x + m.m[1][1] * v.y + m.m[2][1] * v.z + m.m[3][1] * v.w,
                          m.m[0][2] * v.x + m.m[1][2] * v.y + m.m[2][2] * v.z + m.m[3][2] * v.w,
                          m.m[0][3] * v.x + m.m[1][3] * v.y + m.m[2][3] * v.z + m.m[3][3] * v.w } };
}

sbgl_Mat4Orthographic()

static sbgl_Mat4 sbgl_Mat4Orthographic ( sbgl_OrthoParams p )

inlinestatic

Creates an orthographic projection matrix.

Definition at line 296 of file sbgl_math.h.

                                                                  {
    sbgl_Mat4 res = sbgl_Mat4Identity();
    res.m[0][0] = 2.0f / (p.right - p.left);
    res.m[1][1] = 2.0f / (p.top - p.bottom);
    res.m[2][2] = -2.0f / (p.far_p - p.near_p);
    res.m[3][0] = -(p.right + p.left) / (p.right - p.left);
    res.m[3][1] = -(p.top + p.bottom) / (p.top - p.bottom);
    res.m[3][2] = -(p.far_p + p.near_p) / (p.far_p - p.near_p);
    return res;
}

sbgl_Mat4Perspective()

static sbgl_Mat4 sbgl_Mat4Perspective ( float fov_y_rad, float aspect, float near, float far )

inlinestatic

Creates a perspective projection matrix.

Definition at line 278 of file sbgl_math.h.

                                                                                                   {
    float f = 1.0f / tanf(fov_y_rad / 2.0f);
    sbgl_Mat4 res = { 0 };
    res.m[0][0] = f / aspect;
    res.m[1][1] = f;
    res.m[2][2] = far / (near - far);
    res.m[2][3] = -1.0f;
    res.m[3][2] = (far * near) / (near - far);
    return res;
}

sbgl_Mat4Rotate()

static sbgl_Mat4 sbgl_Mat4Rotate ( float angle_rad, sbgl_Vec3 axis )

inlinestatic

Creates a rotation matrix from axis and angle.

Definition at line 290 of file sbgl_math.h.

                                                                         {
    sbgl_Quat q = sbgl_QuatFromAxisAngle(axis, angle_rad);
    return sbgl_QuatToMat4(q);
}

sbgl_Mat4Scale()

static sbgl_Mat4 sbgl_Mat4Scale ( sbgl_Vec3 v )

inlinestatic

Creates a scaling matrix.

Definition at line 269 of file sbgl_math.h.

                                                    {
    sbgl_Mat4 res = sbgl_Mat4Identity();
    res.m[0][0] = v.x;
    res.m[1][1] = v.y;
    res.m[2][2] = v.z;
    return res;
}

sbgl_Mat4Translate()

static sbgl_Mat4 sbgl_Mat4Translate ( sbgl_Vec3 v )

inlinestatic

Creates a translation matrix.

Definition at line 260 of file sbgl_math.h.

                                                        {
    sbgl_Mat4 res = sbgl_Mat4Identity();
    res.m[3][0] = v.x;
    res.m[3][1] = v.y;
    res.m[3][2] = v.z;
    return res;
}

sbgl_QuatFromAxisAngle()

static sbgl_Quat sbgl_QuatFromAxisAngle ( sbgl_Vec3 axis, float angle_rad )

inlinestatic

Creates a quaternion from an axis and an angle (in radians).

Definition at line 193 of file sbgl_math.h.

                                                                                {
    float s = sinf(angle_rad / 2.0f);
    sbgl_Vec3 n = sbgl_Vec3Normalize(axis);
    return (sbgl_Quat){ { n.x * s, n.y * s, n.z * s, cosf(angle_rad / 2.0f) } };
}

sbgl_QuatIdentity()

static sbgl_Quat sbgl_QuatIdentity ( void )

inlinestatic

Returns an identity quaternion.

Definition at line 182 of file sbgl_math.h.

{ return (sbgl_Quat){ { 0, 0, 0, 1.0f } }; }

sbgl_QuatMul()

static sbgl_Quat sbgl_QuatMul ( sbgl_Quat a, sbgl_Quat b )

inlinestatic

Multiplies two quaternions.

Definition at line 185 of file sbgl_math.h.

                                                               {
    return (sbgl_Quat){ { a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
                          a.w * b.y + a.y * b.w + a.z * b.x - a.x * b.z,
                          a.w * b.z + a.z * b.w + a.x * b.y - a.y * b.x,
                          a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z } };
}

sbgl_QuatSet()

static sbgl_Quat sbgl_QuatSet ( float x, float y, float z, float w )

inlinestatic

Creates a Quat.

Definition at line 103 of file sbgl_math.h.

                                                                         {
    return (sbgl_Quat){ { x, y, z, w } };
}

sbgl_QuatToMat4()

static sbgl_Mat4 sbgl_QuatToMat4 ( sbgl_Quat q )

inlinestatic

Converts a quaternion to a rotation matrix.

Definition at line 210 of file sbgl_math.h.

                                                     {
    sbgl_Mat4 res = sbgl_Mat4Identity();
    float xx = q.x * q.x;
    float yy = q.y * q.y;
    float zz = q.z * q.z;
    float xy = q.x * q.y;
    float xz = q.x * q.z;
    float yz = q.y * q.z;
    float wx = q.w * q.x;
    float wy = q.w * q.y;
    float wz = q.w * q.z;
 
    res.m[0][0] = 1.0f - 2.0f * (yy + zz);
    res.m[0][1] = 2.0f * (xy + wz);
    res.m[0][2] = 2.0f * (xz - wy);
 
    res.m[1][0] = 2.0f * (xy - wz);
    res.m[1][1] = 1.0f - 2.0f * (xx + zz);
    res.m[1][2] = 2.0f * (yz + wx);
 
    res.m[2][0] = 2.0f * (xz + wy);
    res.m[2][1] = 2.0f * (yz - wx);
    res.m[2][2] = 1.0f - 2.0f * (xx + yy);
 
    return res;
}

sbgl_Vec2Set()

static sbgl_Vec2 sbgl_Vec2Set ( float x, float y )

inlinestatic

Creates a Vec2.

Definition at line 90 of file sbgl_math.h.

{ return (sbgl_Vec2){ { x, y } }; }

sbgl_Vec3Add()

static sbgl_Vec3 sbgl_Vec3Add ( sbgl_Vec3 a, sbgl_Vec3 b )

inlinestatic

Adds two Vec3 vectors.

Definition at line 132 of file sbgl_math.h.

                                                               {
    return (sbgl_Vec3){ { a.x + b.x, a.y + b.y, a.z + b.z, 0.0f } };
}

sbgl_Vec3Cross()

static sbgl_Vec3 sbgl_Vec3Cross ( sbgl_Vec3 a, sbgl_Vec3 b )

inlinestatic

Computes the cross product of two Vec3 vectors.

Definition at line 152 of file sbgl_math.h.

                                                                 {
    return (sbgl_Vec3){
        { a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x, 0.0f }
    };
}

sbgl_Vec3Dot()

static float sbgl_Vec3Dot ( sbgl_Vec3 a, sbgl_Vec3 b )

inlinestatic

Computes the dot product of two Vec3 vectors.

Definition at line 147 of file sbgl_math.h.

                                                           {
    return a.x * b.x + a.y * b.y + a.z * b.z;
}

sbgl_Vec3Length()

static float sbgl_Vec3Length ( sbgl_Vec3 v )

inlinestatic

Returns the length of a Vec3.

Definition at line 159 of file sbgl_math.h.

{ return sqrtf(sbgl_Vec3Dot(v, v)); }

sbgl_Vec3Mul()

static sbgl_Vec3 sbgl_Vec3Mul ( sbgl_Vec3 a, float s )

inlinestatic

Multiplies a Vec3 by a scalar.

Definition at line 142 of file sbgl_math.h.

                                                           {
    return (sbgl_Vec3){ { a.x * s, a.y * s, a.z * s, 0.0f } };
}

sbgl_Vec3Normalize()

static sbgl_Vec3 sbgl_Vec3Normalize ( sbgl_Vec3 v )

inlinestatic

Normalizes a Vec3.

Definition at line 162 of file sbgl_math.h.

                                                        {
    float len_sq = sbgl_Vec3Dot(v, v);
    if (len_sq < 0.000001f)
        return (sbgl_Vec3){ { 0 } };
    return sbgl_Vec3Mul(v, sbgl_InvSqrt(len_sq));
}

sbgl_Vec3Set()

static sbgl_Vec3 sbgl_Vec3Set ( float x, float y, float z )

inlinestatic

Creates a Vec3, correctly padded.

Definition at line 93 of file sbgl_math.h.

                                                                {
    return (sbgl_Vec3){ { x, y, z, 0.0f } };
}

sbgl_Vec3Sub()

static sbgl_Vec3 sbgl_Vec3Sub ( sbgl_Vec3 a, sbgl_Vec3 b )

inlinestatic

Subtracts b from a.

Definition at line 137 of file sbgl_math.h.

                                                               {
    return (sbgl_Vec3){ { a.x - b.x, a.y - b.y, a.z - b.z, 0.0f } };
}

sbgl_Vec4Add()

static sbgl_Vec4 sbgl_Vec4Add ( sbgl_Vec4 a, sbgl_Vec4 b )

inlinestatic

Adds two Vec4 vectors.

Definition at line 170 of file sbgl_math.h.

                                                               {
    return (sbgl_Vec4){ { a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w } };
}

sbgl_Vec4Mul()

static sbgl_Vec4 sbgl_Vec4Mul ( sbgl_Vec4 a, float s )

inlinestatic

Multiplies a Vec4 by a scalar.

Definition at line 175 of file sbgl_math.h.

                                                           {
    return (sbgl_Vec4){ { a.x * s, a.y * s, a.z * s, a.w * s } };
}

sbgl_Vec4Set()

static sbgl_Vec4 sbgl_Vec4Set ( float x, float y, float z, float w )

inlinestatic

Creates a Vec4.

Definition at line 98 of file sbgl_math.h.

                                                                         {
    return (sbgl_Vec4){ { x, y, z, w } };
}