math_types.h

Go to the documentation of this file.

 
#pragma once
 
#include "defines.h"
 
typedef enum axis_3d {
    AXIS_X = 0,
    AXIS_Y = 1,
    AXIS_Z = 2,
    AXIS_XY,
    AXIS_XZ,
    AXIS_YX,
    AXIS_YZ,
    AXIS_ZX,
    AXIS_ZY
} axis_3d;
 
typedef union vec2_u {
    f32 elements[2];
    struct {
        union {
            f32 x,
                r,
                s,
                u;
        };
        union {
            f32 y,
                g,
                t,
                v;
        };
    };
} vec2;
 
typedef union uvec2_u {
    u32 elements[2];
    union {
        struct {
            union {
                u32 x,
                    r,
                    s;
            };
            union {
                u32 y,
                    g,
                    t;
            };
        };
    };
} uvec2;
 
typedef union ivec2_u {
    i32 elements[2];
    union {
        struct {
            union {
                i32 x,
                    r,
                    s;
            };
            union {
                i32 y,
                    g,
                    t;
            };
        };
    };
} ivec2;
 
typedef union vec3_u {
    f32 elements[3];
    struct {
        union {
            f32 x,
                r,
                s,
                u;
        };
        union {
            f32 y,
                g,
                t,
                v;
        };
        union {
            f32 z,
                b,
                p,
                w;
        };
    };
} vec3;
 
typedef union uvec3_u {
    u32 elements[3];
    union {
        struct {
            union {
                u32 x,
                    r,
                    s;
            };
            union {
                u32 y,
                    g,
                    t;
            };
            union {
                u32 z,
                    b,
                    p;
            };
        };
    };
} uvec3;
 
typedef union ivec3_u {
    i32 elements[3];
    union {
        struct {
            union {
                i32 x,
                    r,
                    s;
            };
            union {
                i32 y,
                    g,
                    t;
            };
            union {
                i32 z,
                    b,
                    p;
            };
        };
    };
} ivec3;
 
typedef union vec4_u {
    f32 elements[4];
    union {
        struct {
            union {
                f32 x,
                    r,
                    s;
            };
            union {
                f32 y,
                    g,
                    t;
            };
            union {
                f32 z,
                    b,
                    p,
                    width;
            };
            union {
                f32 w,
                    a,
                    q,
                    height;
            };
        };
    };
} vec4;
 
typedef vec4 quat;
 
typedef vec4 rect_2d;
 
typedef union uvec4_u {
    u32 elements[4];
    union {
        struct {
            union {
                u32 x,
                    r,
                    s;
            };
            union {
                u32 y,
                    g,
                    t;
            };
            union {
                u32 z,
                    b,
                    p,
                    width;
            };
            union {
                u32 w,
                    a,
                    q,
                    height;
            };
        };
    };
} uvec4;
 
typedef union ivec4_u {
    i32 elements[4];
    union {
        struct {
            union {
                i32 x,
                    r,
                    s;
            };
            union {
                i32 y,
                    g,
                    t;
            };
            union {
                i32 z,
                    b,
                    p,
                    width;
            };
            union {
                i32 w,
                    a,
                    q,
                    height;
            };
        };
    };
} ivec4;
 
typedef union mat3_u {
    f32 data[12];
} mat3;
 
typedef union mat4_u {
    f32 data[16];
} mat4;
 
typedef struct extents_2d {
    vec2 min;
    vec2 max;
} extents_2d;
 
typedef struct extents_3d {
    vec3 min;
    vec3 max;
} extents_3d;
 
typedef extents_3d aabb;
 
typedef struct obb {
    vec3 center;
    // Orthonormal basis vectors
    vec3 axis[3];
    vec3 half_extents;
} obb;
 
typedef struct vertex_3d {
    vec3 position;
    vec3 normal;
    vec2 texcoord;
    vec4 colour;
    vec4 tangent;
} vertex_3d;
 
typedef struct skinned_vertex_3d {
    vec3 position;
    vec3 normal;
    vec2 texcoord;
    vec4 colour;
    vec4 tangent;
    ivec4 bone_ids;
    vec4 weights;
} skinned_vertex_3d;
 
typedef struct vertex_2d {
    vec2 position;
    vec2 texcoord;
} vertex_2d;
 
typedef struct position_vertex_3d {
    vec4 position;
} position_vertex_3d;
 
typedef struct colour_vertex_3d {
    vec4 position;
    vec4 colour;
} colour_vertex_3d;
 
typedef struct plane_3d {
    vec3 normal;
    f32 distance;
} plane_3d;
 
#define KFRUSTUM_SIDE_COUNT 6
 
typedef enum kfrustum_side {
    KFRUSTUM_SIDE_TOP = 0,
    KFRUSTUM_SIDE_BOTTOM = 1,
    KFRUSTUM_SIDE_RIGHT = 2,
    KFRUSTUM_SIDE_LEFT = 3,
    KFRUSTUM_SIDE_FAR = 4,
    KFRUSTUM_SIDE_NEAR = 5,
} kfrustum_side;
 
typedef struct kfrustum {
    // Top, bottom, right, left, far, near
    plane_3d sides[KFRUSTUM_SIDE_COUNT];
} kfrustum;
 
typedef union vec2i_t {
    i32 elements[2];
    struct {
        union {
            i32 x,
                r,
                s,
                u;
        };
        union {
            i32 y,
                g,
                t,
                v;
        };
    };
} vec2i;
 
typedef union vec3i_t {
    i32 elements[3];
    union {
        struct {
            union {
                i32 x,
                    r,
                    s;
            };
            union {
                i32 y,
                    g,
                    t;
            };
            union {
                i32 z,
                    b,
                    p;
            };
        };
    };
} vec3i;
 
typedef union vec4i_t {
    i32 elements[4];
    union {
        struct {
            union {
                i32 x,
                    r,
                    s;
            };
            union {
                i32 y,
                    g,
                    t;
            };
            union {
                i32 z,
                    b,
                    p,
                    width;
            };
            union {
                i32 w,
                    a,
                    q,
                    height;
            };
        };
    };
} vec4i;
 
// integer-based 2D rectangle.
typedef vec4i rect_2di;
 
typedef struct triangle {
    vec3 verts[3];
} triangle;
 
typedef enum ray_flag_bits {
    RAY_FLAG_NONE = 0,
    RAY_FLAG_IGNORE_IF_INSIDE_BIT = 1 << 0
} ray_flag_bits;
 
typedef u32 ray_flags;
 
typedef struct ray {
    vec3 origin;
    vec3 direction;
    f32 max_distance;
    ray_flags flags;
} ray;
 
typedef enum raycast_hit_type {
    RAYCAST_HIT_TYPE_BVH_AABB,
    RAYCAST_HIT_TYPE_SURFACE,
    // Was a BVH AABB hit, but against a base node.
    RAYCAST_HIT_TYPE_BVH_AABB_BASE_NODE
} raycast_hit_type;
 
typedef struct raycast_hit {
    raycast_hit_type type;
    f32 distance;
    u64 user;
    vec3 position;
    vec3 normal;
} raycast_hit;
 
typedef struct raycast_result {
    raycast_hit* hits;
} raycast_result;
 
typedef struct ksphere {
    vec3 position;
    f32 radius;
} ksphere;