vec.h

Go to the documentation of this file.

#ifndef BJ_VEC_H
#define BJ_VEC_H
 
#include <banjo/api.h>
#include <banjo/math.h>

struct bj_vec2_t {
    bj_real x;
    bj_real y;
};
typedef struct bj_vec2_t bj_vec2;
 
#define BJ_VEC2_ZERO ((bj_vec2){BJ_FZERO, BJ_FZERO})

struct bj_vec3_t {
    bj_real x;
    bj_real y;
    bj_real z;
};
typedef struct bj_vec3_t bj_vec3;
 
#define BJ_VEC3_ZERO ((bj_vec3){BJ_FZERO, BJ_FZERO, BJ_FZERO})

struct bj_vec4_t {
    bj_real x;
    bj_real y;
    bj_real z;
    bj_real w;
};
typedef struct bj_vec4_t bj_vec4;
 
#define BJ_VEC4_ZERO ((bj_vec4){BJ_FZERO, BJ_FZERO, BJ_FZERO, BJ_FZERO})
 
static BJ_INLINE bj_vec2 bj_vec2_map(
    bj_vec2 a,
    bj_real(*f)(bj_real)
) {
    return (bj_vec2){ .x = f(a.x), .y = f(a.y), };
}

static BJ_INLINE bj_vec2 bj_vec2_add(bj_vec2 lhs, bj_vec2 rhs) {
    return (bj_vec2){ .x = lhs.x + rhs.x, .y = lhs.y + rhs.y, };
}

static BJ_INLINE bj_vec2 bj_vec2_add_scaled(
    bj_vec2 lhs,
    bj_vec2 rhs,
    bj_real s
) {
    return (bj_vec2){ .x = lhs.x + rhs.x * s, .y = lhs.y + rhs.y * s, };
}

static BJ_INLINE bj_vec2 bj_vec2_sub(
    const bj_vec2 lhs,
    const bj_vec2 rhs
) {
    return (bj_vec2){ .x = lhs.x - rhs.x, .y = lhs.y - rhs.y, };
}

static BJ_INLINE bj_vec2 bj_vec2_scale(bj_vec2 v, bj_real s) {
    return (bj_vec2){ .x = v.x * s, .y = v.y * s, };
}

static BJ_INLINE bj_vec2 bj_vec2_mul_comp(
    const bj_vec2 v,
    const bj_vec2 s
) {
    return (bj_vec2){ .x = v.x * s.x, .y = v.y * s.y, };
}

static BJ_INLINE bj_real bj_vec2_dot(bj_vec2 a, bj_vec2 b) {
    return a.x * b.x + a.y * b.y;
}

static BJ_INLINE bj_real bj_vec2_perp_dot(bj_vec2 a, bj_vec2 b) {
    return a.x*b.y - a.y*b.x;
}

static BJ_INLINE bj_real bj_vec2_len(bj_vec2 v) {
    return bj_sqrt(v.x * v.x + v.y * v.y);
}

static BJ_INLINE bj_vec2 bj_vec2_scale_to_len(bj_vec2 v, bj_real L){
    const bj_real l = bj_vec2_len(v); 
    if (bj_real_is_zero(l)){
        return (bj_vec2){BJ_FZERO,BJ_FZERO};
    }
    return bj_vec2_scale(v, L / l);
}

static BJ_INLINE bj_real bj_vec2_distance_sq(bj_vec2 a, bj_vec2 b) {
    const bj_real dx = a.x - b.x;
    const bj_real dy = a.y - b.y;
    return dx * dx + dy * dy;
}

static BJ_INLINE bj_real bj_vec2_distance(const bj_vec2 a, const bj_vec2 b) {
    return bj_sqrt(bj_vec2_distance_sq(a, b));
}

static BJ_INLINE bj_vec2 bj_vec2_normalize(bj_vec2 v){
    const bj_real l2 = v.x * v.x + v.y * v.y;
    if (bj_real_is_zero(l2)) {
        return (bj_vec2){ BJ_FZERO, BJ_FZERO };
    }
    const bj_real inv = BJ_F(1.0) / bj_sqrt(l2);
    return (bj_vec2){ v.x * inv, v.y * inv };
}

static BJ_INLINE bj_vec2 bj_vec2_normalize_unsafe(bj_vec2 v) {
    const bj_real inv = BJ_F(1.0) / bj_sqrt(v.x*v.x + v.y*v.y);
    return (bj_vec2){ v.x * inv, v.y * inv };
}
 

static BJ_INLINE bj_vec2 bj_vec2_min(bj_vec2 a, bj_vec2 b) {
    return (bj_vec2){a.x < b.x ? a.x : b.x, a.y < b.y ? a.y : b.y, };
}

static BJ_INLINE bj_vec2 bj_vec2_max(bj_vec2 a, bj_vec2 b) {
    return (bj_vec2){a.x > b.x ? a.x : b.x, a.y > b.y ? a.y : b.y, };
}
 
static BJ_INLINE bj_vec3 bj_vec3_map(
    bj_vec3 a,
    bj_real(*f)(bj_real)
) {
    return (bj_vec3){ .x = f(a.x), .y = f(a.y), .z = f(a.z), };
}

static BJ_INLINE bj_vec3 bj_vec3_add(bj_vec3 lhs, bj_vec3 rhs) {
    return (bj_vec3){ 
        .x = lhs.x + rhs.x,
        .y = lhs.y + rhs.y,
        .z = lhs.z + rhs.z,
    };
}

static BJ_INLINE bj_vec3 bj_vec3_add_scaled(
    bj_vec3 lhs,
    bj_vec3 rhs,
    bj_real s
) {
    return (bj_vec3){ 
        .x = lhs.x + rhs.x * s,
        .y = lhs.y + rhs.y * s,
        .z = lhs.z + rhs.z * s,  
    };
}
 

static BJ_INLINE bj_vec3 bj_vec3_sub(
    bj_vec3 lhs,
    bj_vec3 rhs
) {
    return (bj_vec3){ 
        .x = lhs.x - rhs.x,
        .y = lhs.y - rhs.y,
        .z = lhs.z - rhs.z, 
    };
}

static BJ_INLINE bj_vec3 bj_vec3_scale(bj_vec3 v, bj_real s) {
    return (bj_vec3){ 
        .x = v.x * s,
        .y = v.y * s,
        .z = v.z * s,
    };
}

static BJ_INLINE bj_real bj_vec3_dot(bj_vec3 a, bj_vec3 b) {
    return a.x * b.x + a.y * b.y + a.z * b.z;
}

static BJ_INLINE bj_real bj_vec3_len(bj_vec3 v) {
    return bj_sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
}

static BJ_INLINE bj_vec3 bj_vec3_scale_to_len(bj_vec3 v, bj_real L){
    const bj_real l = bj_vec3_len(v);
    if (bj_real_is_zero(l)) {
        return (bj_vec3){BJ_FZERO,BJ_FZERO,BJ_FZERO};
    }
    return bj_vec3_scale(v, L / l);
}

static BJ_INLINE bj_real bj_vec3_distance_sq(bj_vec3 a, bj_vec3 b) {
    const bj_real dx = a.x - b.x;
    const bj_real dy = a.y - b.y;
    const bj_real dz = a.z - b.z;
    return dx * dx + dy * dy + dz * dz;
}

static BJ_INLINE bj_real bj_vec3_distance(bj_vec3 a, bj_vec3 b) {
    return bj_sqrt(bj_vec3_distance_sq(a, b));
}

static BJ_INLINE bj_vec3 bj_vec3_normalize(bj_vec3 v){
    const bj_real l2 = v.x * v.x + v.y * v.y + v.z * v.z;
    if (bj_real_is_zero(l2)) {
        return (bj_vec3){ BJ_FZERO, BJ_FZERO, BJ_FZERO };
    }
    const bj_real inv = BJ_F(1.0) / bj_sqrt(l2);
    return (bj_vec3){ v.x * inv, v.y * inv, v.z * inv };
}

static BJ_INLINE bj_vec3 bj_vec3_normalize_unsafe(bj_vec3 v) {
    const bj_real inv = BJ_F(1.0) / bj_sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
    return (bj_vec3){ v.x * inv, v.y * inv, v.z * inv };
}

static BJ_INLINE bj_vec3 bj_vec3_min(bj_vec3 a, bj_vec3 b) {
    return (bj_vec3){
        a.x < b.x ? a.x : b.x,
        a.y < b.y ? a.y : b.y,
        a.z < b.z ? a.z : b.z,
    };
}

static BJ_INLINE bj_vec3 bj_vec3_max(bj_vec3 a, bj_vec3 b) {
    return (bj_vec3){a.x > b.x ? a.x : b.x, a.y > b.y ? a.y : b.y, a.z > b.z ? a.z : b.z,};
}

static BJ_INLINE bj_vec3 bj_vec3_cross(bj_vec3 l, bj_vec3 r)
{
    return (bj_vec3) {
        .x = l.y * r.z - l.z * r.y,
        .y = l.z * r.x - l.x * r.z,
        .z = l.x * r.y - l.y * r.x,
    };
}

static BJ_INLINE bj_vec3 bj_vec3_reflect(bj_vec3 v, bj_vec3 n)
{
    const bj_real p = BJ_F(2.) * bj_vec3_dot(v, n);
    return (bj_vec3) {
        .x = v.x - p * n.x,
        .y = v.y - p * n.y,
        .z = v.z - p * n.z,
    };
}
 
static BJ_INLINE bj_vec4 bj_vec4_map(
    bj_vec4 a,
    bj_real(*f)(bj_real)
) {
    return (bj_vec4){ .x = f(a.x), .y = f(a.y), .z = f(a.z), .w = f(a.w), };
}

static BJ_INLINE bj_vec4 bj_vec4_add(bj_vec4 lhs, bj_vec4 rhs) {
    return (bj_vec4){ 
        .x = lhs.x + rhs.x,
        .y = lhs.y + rhs.y,
        .z = lhs.z + rhs.z,
        .w = lhs.w + rhs.w, 
    };
}

static BJ_INLINE bj_vec4 bj_vec4_add_scaled(
    bj_vec4 lhs,
    bj_vec4 rhs,
    bj_real s
) {
    return (bj_vec4){ 
        .x = lhs.x + rhs.x * s,
        .y = lhs.y + rhs.y * s,
        .z = lhs.z + rhs.z * s,  
        .w = lhs.w + rhs.w * s,  
    };
}

static BJ_INLINE bj_vec4 bj_vec4_sub(
    bj_vec4 lhs,
    bj_vec4 rhs
) {
    return (bj_vec4){ 
        .x = lhs.x - rhs.x,
        .y = lhs.y - rhs.y,
        .z = lhs.z - rhs.z, 
        .w = lhs.w - rhs.w, 
    };
}

static BJ_INLINE bj_vec4 bj_vec4_scale(bj_vec4 v, bj_real s) {
    return (bj_vec4){ 
        .x = v.x * s,
        .y = v.y * s,
        .z = v.z * s,
        .w = v.w * s,
    };
}

static BJ_INLINE bj_real bj_vec4_dot(bj_vec4 a, bj_vec4 b) {
    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
}

static BJ_INLINE bj_real bj_vec4_len(bj_vec4 v) {
    return bj_sqrt(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w);
}

static BJ_INLINE bj_vec4 bj_vec4_normalize(bj_vec4 v) { 
    const bj_real len2 = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
    if (bj_real_is_zero(len2)) { 
        return (bj_vec4){ BJ_FZERO, BJ_FZERO, BJ_FZERO, BJ_FZERO };
    }
    const bj_real inv = BJ_F(1.0) / bj_sqrt(len2);
    return (bj_vec4){ v.x * inv, v.y * inv, v.z * inv, v.w * inv };
}

static BJ_INLINE bj_vec4 bj_vec4_normalize_unsafe(bj_vec4 v) {
    const bj_real inv = BJ_F(1.0) / bj_sqrt(v.x*v.x + v.y*v.y + v.z*v.z + v.w*v.w);
    return (bj_vec4){ v.x * inv, v.y * inv, v.z * inv, v.w * inv };
}

static BJ_INLINE bj_vec4 bj_vec4_min(bj_vec4 a, bj_vec4 b) {
    return (bj_vec4){
        a.x < b.x ? a.x : b.x,
        a.y < b.y ? a.y : b.y,
        a.z < b.z ? a.z : b.z,
        a.w < b.w ? a.w : b.w,
    };
}

static BJ_INLINE bj_vec4 bj_vec4_max(bj_vec4 a, bj_vec4 b) {
    return (bj_vec4){
        a.x > b.x ? a.x : b.x,
        a.y > b.y ? a.y : b.y,
        a.z > b.z ? a.z : b.z,
        a.w > b.w ? a.w : b.w,
    };
}

static BJ_INLINE bj_vec4 bj_vec4_cross_xyz(bj_vec4 l, bj_vec4 r){
    return (bj_vec4){ 
        l.y*r.z - l.z*r.y,
        l.z*r.x - l.x*r.z,
        l.x*r.y - l.y*r.x,
        BJ_FZERO
    };
}

static BJ_INLINE bj_vec4 bj_vec4_reflect(bj_vec4 v, bj_vec4 n)
{
    bj_real p = BJ_F(2.0) * bj_vec4_dot(v, n);
    return (bj_vec4) {
        .x = v.x - p * n.x,
        .y = v.y - p * n.y,
        .z = v.z - p * n.z,
        .w = v.w - p * n.w,
    };
}
 
 
#endif