print_n_panic/Microtransactions64
0
0
Fork 0
mirror of https://github.com/Print-and-Panic/Microtransactions64.git synced 2026-01-21 10:17:19 -08:00
Code Issues Packages Projects Releases Wiki Activity

Some vector macros in math_util.h

Browse Source
This commit is contained in:
Arceveti
2021-09-20 17:10:08 -07:00
parent 6fadffac53
commit eedca61a73
1 changed files with 310 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
src/engine/math_util.h
View File

@@ -6,6 +6,8 @@
#include "types.h"
#define BIT(i) (1 << (i))
#define BITMASK(size) ((BIT(size)) - 1)
/*
* The sine and cosine tables overlap, but "#define gCosineTable (gSineTable +
@@ -29,12 +31,315 @@ extern f32 gCosineTable[];
#define sins(x) gSineTable[(u16) (x) >> 4]
#define coss(x) gCosineTable[(u16) (x) >> 4]
#define min(a, b) ((a) <= (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
#define ABS(x) ((x) > 0.f ? (x) : -(x))
#define DEG_PER_RAD 57.29577950560105
#define RAD_PER_DEG (1.0 / DEG_PER_RAD)
#define sqr(x) ((x) * (x))
#define angle_to_degrees( x) (f32)(((Angle)(x) / 65536.0f) * 360.0f)
#define degrees_to_angle( x) (Angle)(((f32)(x) * 0x10000 ) / 360 )
#define angle_to_radians( x) (f32)(((Angle)(x) * M_PI ) / 0x8000)
#define radians_to_angle( x) (Angle)(((f32)(x) / M_PI ) * 0x8000)
#define degrees_to_radians(x) (f32)( (f32)(x) * RAD_PER_DEG )
#define radians_to_degrees(x) (f32)( (f32)(x) * DEG_PER_RAD )
#define ABSF(x) ((x) > 0.0f ? (x) : -(x))
#define ABSI(x) ((x) > 0 ? (x) : -(x))
#define ABS(x) ABSF((x))
#define min(a, b) MIN((a), (b)) // ((a) < (b) ? (a) : (b))
#define max(a, b) MAX((a), (b)) // ((a) > (b) ? (a) : (b))
#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
// from limits.h
#define S8_MAX __SCHAR_MAX__
#define S8_MIN (-S8_MAX - 1)
#define U8_MAX (S8_MAX * 2 + 1)
#define S16_MAX __SHRT_MAX__
#define S16_MIN (-S16_MAX - 1)
#define U16_MAX (S16_MAX * 2 + 1)
#define S32_MAX __INT_MAX__
#define S32_MIN (-S32_MAX - 1)
#define U32_MAX (S32_MAX * 2U + 1U)
#define S64_MAX __LONG_LONG_MAX__
#define S64_MIN (-S64_MAX - 1LL)
#define U64_MAX (S64_MAX * 2ULL + 1ULL)
#define F32_MAX __FLT_MAX__
#define F32_MIN __FLT_MIN__
#define F64_MAX __DBL_MAX__
#define F64_MIN __DBL_MIN__
#define CLAMP_U8( x) CLAMP((x), 0x0, U8_MAX)
#define CLAMP_S8( x) CLAMP((x), S8_MIN, S8_MAX)
#define CLAMP_U16(x) CLAMP((x), 0x0, U16_MAX)
#define CLAMP_S16(x) CLAMP((x), S16_MIN, S16_MAX)
#define CLAMP_U32(x) CLAMP((x), 0x0, U32_MAX)
#define CLAMP_S32(x) CLAMP((x), S32_MIN, S32_MAX)
#define CLAMP_U64(x) CLAMP((x), 0x0, U64_MAX)
#define CLAMP_S64(x) CLAMP((x), S64_MIN, S64_MAX)
#define CLAMP_F32(x) CLAMP((x), F32_MIN, F32_MAX)
#define CLAMP_F64(x) CLAMP((x), F64_MIN, F64_MAX)
#define SWAP(a, b) { ((a) ^= (b)); ((b) ^= (a)); ((a) ^= (b)); }
#define sqr(x) ( (x) * (x))
#define cube(x) ( sqr(x) * (x))
#define quad(x) (cube(x) * (x))
#define average_2(a, b ) (((a) + (b) ) / 2.0f)
#define average_3(a, b, c ) (((a) + (b) + (c) ) / 3.0f)
#define average_4(a, b, c, d) (((a) + (b) + (c) + (d)) / 4.0f)
#define vec2_same(v, s) (((v)[0]) = ((v)[1]) = (s))
#define vec3_same(v, s) (((v)[0]) = ((v)[1]) = ((v)[2]) = (s))
#define vec4_same(v, s) (((v)[0]) = ((v)[1]) = ((v)[2]) = ((v)[3]) = (s))
#define vec2_zero(v) (vec2_same((v), 0))
#define vec3_zero(v) (vec3_same((v), 0))
#define vec4_zero(v) (vec4_same((v), 0))
#define vec2_c(v) ( (v)[0] + (v)[1])
#define vec3_c(v) (vec2_c(v) + (v)[2])
#define vec4_c(v) (vec3_c(v) + (v)[3])
#define vec2_average(v) (vec2_c(v) / 2.0f)
#define vec3_average(v) (vec3_c(v) / 3.0f)
#define vec4_average(v) (vec4_c(v) / 4.0f)
#define vec2_sumsq(v) ( sqr((v)[0]) + sqr((v)[1]))
#define vec3_sumsq(v) (vec2_sumsq(v) + sqr((v)[2]))
#define vec4_sumsq(v) (vec3_sumsq(v) + sqr((v)[3]))
#define vec2_mag(v) (sqrtf(vec2_sumsq(v)))
#define vec3_mag(v) (sqrtf(vec3_sumsq(v)))
#define vec4_mag(v) (sqrtf(vec4_sumsq(v)))
#define vec3_yaw(from, to) (atan2s(((to)[2] - (from)[2]), ((to)[0] - (from)[0])))
#define vec2_dot(a, b) (((a)[0] * (b)[0]) + ((a)[1] * (b)[1]))
#define vec3_dot(a, b) (vec2_dot((a), (b)) + ((a)[2] * (b)[2]))
#define vec4_dot(a, b) (vec3_dot((a), (b)) + ((a)[3] * (b)[3]))
/// Make vector 'dest' the cross product of vectors a and b.
#define vec3_cross(dst, a, b) { \
(dst)[0] = (((a)[1] * (b)[2]) - ((a)[2] * (b)[1])); \
(dst)[1] = (((a)[2] * (b)[0]) - ((a)[0] * (b)[2])); \
(dst)[2] = (((a)[0] * (b)[1]) - ((a)[1] * (b)[0])); \
}
#define vec2_set(dst, x, y) { \
(dst)[0] = (x); \
(dst)[1] = (y); \
}
#define vec3_set(dst, x, y, z) { \
vec2_set((dst), (x), (y)); \
(dst)[2] = (z); \
}
#define vec4_set(dst, x, y, z, w) { \
vec3_set((dst), (x), (y), (z)); \
(dst)[3] = (w); \
}
#define vec2_copy(dst, src) { \
(dst)[0] = (src)[0]; \
(dst)[1] = (src)[1]; \
}
#define vec3_copy(dst, src) { \
vec2_copy((dst), (src)); \
(dst)[2] = (src)[2]; \
}
#define vec4_copy(dst, src) { \
vec3_copy((dst), (src)); \
(dst)[3] = (src)[3]; \
}
#define vec3_copy_y_off(dst, src, y) { \
(dst)[0] = (src)[0]; \
(dst)[1] = ((src)[1] + (y)); \
(dst)[2] = (src)[2]; \
}
#define vec2_copy_roundf(dst, src) { \
(dst)[0] = roundf((src)[0]); \
(dst)[1] = roundf((src)[1]); \
}
#define vec3_copy_roundf(dst, src) { \
vec2_copy_roundf((dst), (src)); \
(dst)[2] = roundf((src)[2]); \
}
#define vec4_copy_roundf(dst, src) { \
vec3_copy_roundf((dst), (src)); \
(dst)[3] = roundf((src)[3]); \
}
#define vec2_copy_inverse(dst, src) { \
(dst)[0] = (src)[1]; \
(dst)[1] = (src)[0]; \
}
#define vec3_copy_inverse(dst, src) { \
(dst)[0] = (src)[2]; \
(dst)[1] = (src)[1]; \
(dst)[2] = (src)[0]; \
}
#define vec4_copy_inverse(dst, src) { \
(dst)[0] = (src)[3]; \
(dst)[1] = (src)[2]; \
(dst)[2] = (src)[1]; \
(dst)[3] = (src)[0]; \
}
#define vec3_copy_offset_m1(dst, src) { \
(dst)[0] = (src)[1]; \
(dst)[1] = (src)[2]; \
(dst)[2] = (src)[0]; \
}
#define vec2_copy_negative(dst, src) { \
(dst)[0] = -(src)[0]; \
(dst)[1] = -(src)[1]; \
}
#define vec3_copy_negative(dst, src) { \
vec2_copy_negative((dst), (src)); \
(dst)[2] = -(src)[2]; \
}
#define vec4_copy_negative(dst, src) { \
vec3_copy_negative((dst), (src)); \
(dst)[3] = -(src)[3]; \
}
#define vec2_sum(dst, src1, src2) { \
(dst)[0] = ((src1)[0] + (src2)[0]); \
(dst)[1] = ((src1)[1] + (src2)[1]); \
}
#define vec3_sum(dst, src1, src2) { \
vec2_sum((dst), (src1), (src2)); \
(dst)[2] = ((src1)[2] + (src2)[2]); \
}
#define vec4_sum(dst, src1, src2) { \
vec3_sum((dst), (src1), (src2)); \
(dst)[3] = ((src1)[3] + (src2)[3]); \
}
#define vec2_add(dst, src) vec2_sum((dst), (dst), (src))
#define vec3_add(dst, src) vec3_sum((dst), (dst), (src))
#define vec4_add(dst, src) vec4_sum((dst), (dst), (src))
#define vec2_sum_val(dst, src, x) { \
(dst)[0] = ((src)[0] + (x)); \
(dst)[1] = ((src)[1] + (x)); \
}
#define vec3_sum_val(dst, src, x) { \
vec2_sum_val((dst), (src), (x)); \
(dst)[2] = ((src)[2] + (x)); \
}
#define vec4_sum_val(dst, src, x) { \
vec3_sum_val((dst), (src), (x)); \
(dst)[3] = ((src)[2] + (x)); \
}
#define vec2_add_val(dst, x) vec2_sum_val((dst), (dst), (x))
#define vec3_add_val(dst, x) vec3_sum_val((dst), (dst), (x))
#define vec4_add_val(dst, x) vec4_sum_val((dst), (dst), (x))
#define vec2_diff(dst, src1, src2) { \
(dst)[0] = ((src1)[0] - (src2)[0]); \
(dst)[1] = ((src1)[1] - (src2)[1]); \
}
#define vec3_diff(dst, src1, src2) { \
vec2_diff((dst), (src1), (src2)); \
(dst)[2] = ((src1)[2] - (src2)[2]); \
}
#define vec4_diff(dst, src1, src2) { \
vec3_diff((dst), (src1), (src2)); \
(dst)[3] = ((src1)[3] - (src2)[3]); \
}
#define vec2_sub(dst, src) vec2_diff((dst), (dst), (src))
#define vec3_sub(dst, src) vec3_diff((dst), (dst), (src))
#define vec4_sub(dst, src) vec4_diff((dst), (dst), (src))
#define vec2_diff_val(dst, src, x) { \
(dst)[0] = ((src)[0] - (x)); \
(dst)[1] = ((src)[1] - (x)); \
}
#define vec3_diff_val(dst, src, x) { \
vec2_diff_val((dst), (src), (x)); \
(dst)[2] = ((src)[2] - (x)); \
}
#define vec4_diff_val(dst, src, x) { \
vec3_diff_val((dst), (src), (x)); \
(dst)[3] = ((src)[3] - (x)); \
}
#define vec2_sub_val(dst, x) vec2_diff_val((dst), (dst), (x))
#define vec3_sub_val(dst, x) vec3_diff_val((dst), (dst), (x))
#define vec4_sub_val(dst, x) vec4_diff_val((dst), (dst), (x))
#define vec2_prod(dst, src1, src2) { \
(dst)[0] = ((src1)[0] * (src2)[0]); \
(dst)[1] = ((src1)[1] * (src2)[1]); \
}
#define vec3_prod(dst, src1, src2) { \
vec2_prod((dst), (src1), (src2)); \
(dst)[2] = ((src1)[2] * (src2)[2]); \
}
#define vec4_prod(dst, src1, src2) { \
vec3_prod((dst), (src1), (src2)); \
(dst)[3] = ((src1)[3] * (src2)[3]); \
}
#define vec2_mul(dst, src) vec2_prod((dst), (dst), (src))
#define vec3_mul(dst, src) vec3_prod((dst), (dst), (src))
#define vec4_mul(dst, src) vec4_prod((dst), (dst), (src))
#define vec2_prod_val(dst, src, x) { \
(dst)[0] = ((src)[0] * (x)); \
(dst)[1] = ((src)[1] * (x)); \
}
#define vec3_prod_val(dst, src, x) { \
vec2_prod_val((dst), (src), (x)); \
(dst)[2] = ((src)[2] * (x)); \
}
#define vec4_prod_val(dst, src, x) { \
vec3_prod_val((dst), (src), (x)); \
(dst)[3] = ((src)[3] * (x)); \
}
#define vec2_mul_val(dst, x) vec2_prod_val(dst, dst, x)
#define vec3_mul_val(dst, x) vec3_prod_val(dst, dst, x)
#define vec4_mul_val(dst, x) vec4_prod_val(dst, dst, x)
#define vec2_quot(dst, src1, src2) { \
(dst)[0] = ((src1)[0] / (src2)[0]); \
(dst)[1] = ((src1)[1] / (src2)[1]); \
}
#define vec3_quot(dst, src1, src2) { \
vec2_quot((dst), (src1), (src2)); \
(dst)[2] = ((src1)[2] / (src2)[2]); \
}
#define vec4_quot(dst, src1, src2) { \
vec3_quot((dst), (src1), (src2)); \
(dst)[3] = ((src1)[3] / (src2)[3]); \
}
#define vec2_div(dst, src) vec2_quot((dst), (dst), (src))
#define vec3_div(dst, src) vec3_quot((dst), (dst), (src))
#define vec4_div(dst, src) vec4_quot((dst), (dst), (src))
#define vec2_quot_val(dst, src, x) { \
(dst)[0] = ((src)[0] / (x)); \
(dst)[1] = ((src)[1] / (x)); \
}
#define vec3_quot_val(dst, src, x) { \
vec2_quot_val((dst), (src), (x)); \
(dst)[2] = ((src)[2] / (x)); \
}
#define vec4_quot_val(dst, src, x) { \
vec3_quot_val((dst), (src), (x)); \
(dst)[3] = ((src)[3] / (x)); \
}
#define vec2_div_val(dst, x) vec2_quot_val((dst), (dst), (x))
#define vec3_div_val(dst, x) vec3_quot_val((dst), (dst), (x))
#define vec4_div_val(dst, x) vec4_quot_val((dst), (dst), (x))
#define RAYCAST_FIND_FLOOR (0x1)
#define RAYCAST_FIND_WALL (0x2)