at_math.h

Go to the documentation of this file.

 
#ifndef AT_MATH_H
#define AT_MATH_H
 
#define EPSILON 1e-6f
 
#include <math.h>
#include <float.h>
#include <stdbool.h>


typedef union {
    struct {
        float x, y, z;
    }; 
    float arr[3]; 
} AT_Vec3;

typedef struct {
    int x; 
    int y; 
    int z; 
} AT_Vec3i;

typedef struct {
    AT_Vec3 min; 
    AT_Vec3 max; 
    AT_Vec3 midpoint;
    float SA;
} AT_AABB;

typedef struct {
    AT_Vec3 v1;   
    AT_Vec3 v2;   
    AT_Vec3 v3;   
    AT_AABB aabb; 
    bool left;
} AT_Triangle;

static inline AT_Vec3 AT_vec3(float x, float y, float z)
{
    return (AT_Vec3){{x, y, z}};
}

static inline AT_Vec3 AT_vec3_zero(void)
{
    return (AT_Vec3){{0.0f, 0.0f, 0.0f}};
}

static inline AT_Vec3 AT_vec3_add(AT_Vec3 a, AT_Vec3 b)
{
    return (AT_Vec3){{a.x + b.x, a.y + b.y, a.z + b.z}};
}

static inline AT_Vec3 AT_vec3_sub(AT_Vec3 a, AT_Vec3 b)
{
    return (AT_Vec3){{a.x - b.x, a.y - b.y, a.z - b.z}};
}

static inline AT_Vec3 AT_vec3_mul(AT_Vec3 a, AT_Vec3 b)
{
    return (AT_Vec3){{a.x * b.x, a.y * b.y, a.z * b.z}};
}

static inline AT_Vec3 AT_vec3_inv(AT_Vec3 v)
{
    return (AT_Vec3){
        {(fabsf(v.x) < EPSILON ? FLT_MAX : (1.0f / fabsf(v.x))),
         (fabsf(v.y) < EPSILON ? FLT_MAX : (1.0f / fabsf(v.y))),
         (fabsf(v.z) < EPSILON ? FLT_MAX : (1.0f / fabsf(v.z)))}
    };
}

static inline AT_Vec3 AT_vec3_scale(AT_Vec3 v, float s)
{
    return (AT_Vec3){{v.x * s, v.y * s, v.z * s}};
}

static inline float AT_vec3_dot(AT_Vec3 a, AT_Vec3 b)
{
    return a.x * b.x + a.y * b.y + a.z * b.z;
}

static inline AT_Vec3 AT_vec3_cross(AT_Vec3 a, AT_Vec3 b)
{
    return (AT_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}
    };
}

static inline float AT_vec3_length(AT_Vec3 v)
{
    return sqrtf(AT_vec3_dot(v, v));
}

static inline AT_Vec3 AT_vec3_normalize(AT_Vec3 v)
{
    float len = AT_vec3_length(v);
    return (len > 0.0f) ? AT_vec3_scale(v, 1.0f / len) : AT_vec3_zero();
}

static inline float AT_vec3_distance(AT_Vec3 a, AT_Vec3 b)
{
    return sqrt((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y) + (b.z - a.z) * (b.z - a.z));
}

static inline float AT_vec3_distance_sq(AT_Vec3 a, AT_Vec3 b)
{
    return (b.x - a.x) * (b.x - a.x) +
           (b.y - a.y) * (b.y - a.y) +
           (b.z - a.z) * (b.z - a.z);
}
 
/* \brief Computes per axis step distance used in DDA.
   \relates AT_Vec3
   \ingroup vec
 
   \param v Vector being traversed.
 
  \retval AT_Vec3 Per axis step distance.
 */
static inline AT_Vec3 AT_vec3_delta(AT_Vec3 v)
{
    return (AT_Vec3){
        {v.x != 0.0f ? fabsf(1.0f / v.x) : FLT_MAX,
         v.y != 0.0f ? fabsf(1.0f / v.y) : FLT_MAX,
         v.z != 0.0f ? fabsf(1.0f / v.z) : FLT_MAX}
    };
}
 
#endif // AT_MATH_H