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 {
    bj_real x; 
    bj_real y; 
};

#define BJ_VEC2_ZERO ((struct bj_vec2){BJ_FZERO, BJ_FZERO})

struct bj_vec3 {
    bj_real x; 
    bj_real y; 
    bj_real z; 
};

#define BJ_VEC3_ZERO ((struct bj_vec3){BJ_FZERO, BJ_FZERO, BJ_FZERO})

struct bj_vec4 {
    bj_real x; 
    bj_real y; 
    bj_real z; 
    bj_real w; 
};

#define BJ_VEC4_ZERO ((struct bj_vec4){BJ_FZERO, BJ_FZERO, BJ_FZERO, BJ_FZERO})

static BJ_INLINE struct bj_vec2 bj_vec2_map(
    struct bj_vec2 a,
    bj_real(*f)(bj_real)
) {
    return (struct bj_vec2){ .x = f(a.x), .y = f(a.y), };
}

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

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

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

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

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

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

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

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

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

static BJ_INLINE bj_real bj_vec2_distance_sq(struct bj_vec2 a, struct 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 struct bj_vec2 a, const struct bj_vec2 b) {
    return bj_sqrt(bj_vec2_distance_sq(a, b));
}

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

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

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

static BJ_INLINE struct bj_vec2 bj_vec2_max(struct bj_vec2 a, struct bj_vec2 b) {
    return (struct bj_vec2){a.x > b.x ? a.x : b.x, a.y > b.y ? a.y : b.y, };
}

static BJ_INLINE struct bj_vec3 bj_vec3_map(
    struct bj_vec3 a,
    bj_real(*f)(bj_real)
) {
    return (struct bj_vec3){ .x = f(a.x), .y = f(a.y), .z = f(a.z), };
}

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

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

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

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

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

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

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

static BJ_INLINE bj_real bj_vec3_distance_sq(struct bj_vec3 a, struct 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(struct bj_vec3 a, struct bj_vec3 b) {
    return bj_sqrt(bj_vec3_distance_sq(a, b));
}

static BJ_INLINE struct bj_vec3 bj_vec3_normalize(struct 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 (struct bj_vec3){ BJ_FZERO, BJ_FZERO, BJ_FZERO };
    }
    const bj_real inv = BJ_F(1.0) / bj_sqrt(l2);
    return (struct bj_vec3){ v.x * inv, v.y * inv, v.z * inv };
}

static BJ_INLINE struct bj_vec3 bj_vec3_normalize_unsafe(struct 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 (struct bj_vec3){ v.x * inv, v.y * inv, v.z * inv };
}

static BJ_INLINE struct bj_vec3 bj_vec3_min(struct bj_vec3 a, struct bj_vec3 b) {
    return (struct 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 struct bj_vec3 bj_vec3_max(struct bj_vec3 a, struct bj_vec3 b) {
    return (struct 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 struct bj_vec3 bj_vec3_cross(struct bj_vec3 l, struct bj_vec3 r)
{
    return (struct 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 struct bj_vec3 bj_vec3_reflect(struct bj_vec3 v, struct bj_vec3 n)
{
    const bj_real p = BJ_F(2.) * bj_vec3_dot(v, n);
    return (struct bj_vec3) {
        .x = v.x - p * n.x,
        .y = v.y - p * n.y,
        .z = v.z - p * n.z,
    };
}

static BJ_INLINE struct bj_vec4 bj_vec4_map(
    struct bj_vec4 a,
    bj_real(*f)(bj_real)
) {
    return (struct bj_vec4){ .x = f(a.x), .y = f(a.y), .z = f(a.z), .w = f(a.w), };
}

static BJ_INLINE struct bj_vec4 bj_vec4_add(struct bj_vec4 lhs, struct bj_vec4 rhs) {
    return (struct 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 struct bj_vec4 bj_vec4_add_scaled(
    struct bj_vec4 lhs,
    struct bj_vec4 rhs,
    bj_real s
) {
    return (struct 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 struct bj_vec4 bj_vec4_sub(
    struct bj_vec4 lhs,
    struct bj_vec4 rhs
) {
    return (struct 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 struct bj_vec4 bj_vec4_scale(struct bj_vec4 v, bj_real s) {
    return (struct 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(struct bj_vec4 a, struct 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(struct 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 struct bj_vec4 bj_vec4_normalize(struct 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 (struct bj_vec4){ BJ_FZERO, BJ_FZERO, BJ_FZERO, BJ_FZERO };
    }
    const bj_real inv = BJ_F(1.0) / bj_sqrt(len2);
    return (struct bj_vec4){ v.x * inv, v.y * inv, v.z * inv, v.w * inv };
}

static BJ_INLINE struct bj_vec4 bj_vec4_normalize_unsafe(struct 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 (struct bj_vec4){ v.x * inv, v.y * inv, v.z * inv, v.w * inv };
}

static BJ_INLINE struct bj_vec4 bj_vec4_min(struct bj_vec4 a, struct bj_vec4 b) {
    return (struct 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 struct bj_vec4 bj_vec4_max(struct bj_vec4 a, struct bj_vec4 b) {
    return (struct 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 struct bj_vec4 bj_vec4_cross_xyz(struct bj_vec4 l, struct bj_vec4 r){
    return (struct 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 struct bj_vec4 bj_vec4_reflect(struct bj_vec4 v, struct bj_vec4 n)
{
    bj_real p = BJ_F(2.0) * bj_vec4_dot(v, n);
    return (struct 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