Math operations module

Contents

OpenGL gamedev friendly library for math.

Classes

union zpl_vec2
union zpl_vec3
union zpl_vec4
union zpl_mat2
union zpl_mat3
union zpl_mat4
union zpl_quat
struct zpl_rect2
struct zpl_rect3
struct zpl_aabb2
struct zpl_aabb3

Typedefs

using zpl_vec2 = union zpl_vec2
using zpl_vec3 = union zpl_vec3
using zpl_vec4 = union zpl_vec4
using zpl_mat2 = union zpl_mat2
using zpl_mat3 = union zpl_mat3
using zpl_mat4 = union zpl_mat4
using zpl_quat = union zpl_quat
using zpl_float2 = f32[2]
using zpl_float3 = f32[3]
using zpl_float4 = f32[4]
using zpl_rect2 = struct zpl_rect2
using zpl_rect3 = struct zpl_rect3
using zpl_aabb2 = struct zpl_aabb2
using zpl_aabb3 = struct zpl_aabb3
using zpl_half = short

Functions

auto zpl_to_radians(f32 degrees) -> f32
auto zpl_to_degrees(f32 radians) -> f32
auto zpl_angle_diff(f32 radians_a, f32 radians_b) -> f32
auto zpl_copy_sign(f32 x, f32 y) -> f32
auto zpl_remainder(f32 x, f32 y) -> f32
auto zpl_mod(f32 x, f32 y) -> f32
auto zpl_copy_sign64(f64 x, f64 y) -> f64
auto zpl_floor64(f64 x) -> f64
auto zpl_ceil64(f64 x) -> f64
auto zpl_round64(f64 x) -> f64
auto zpl_remainder64(f64 x, f64 y) -> f64
auto zpl_abs64(f64 x) -> f64
auto zpl_sign64(f64 x) -> f64
auto zpl_mod64(f64 x, f64 y) -> f64
auto zpl_sqrt(f32 a) -> f32
auto zpl_rsqrt(f32 a) -> f32
auto zpl_quake_rsqrt(f32 a) -> f32
auto zpl_sin(f32 radians) -> f32
auto zpl_cos(f32 radians) -> f32
auto zpl_tan(f32 radians) -> f32
auto zpl_arcsin(f32 a) -> f32
auto zpl_arccos(f32 a) -> f32
auto zpl_arctan(f32 a) -> f32
auto zpl_arctan2(f32 y, f32 x) -> f32
auto zpl_exp(f32 x) -> f32
auto zpl_exp2(f32 x) -> f32
auto zpl_log(f32 x) -> f32
auto zpl_log2(f32 x) -> f32
auto zpl_fast_exp(f32 x) -> f32
auto zpl_fast_exp2(f32 x) -> f32
auto zpl_pow(f32 x, f32 y) -> f32
auto zpl_round(f32 x) -> f32
auto zpl_floor(f32 x) -> f32
auto zpl_ceil(f32 x) -> f32
auto zpl_half_to_float(zpl_half value) -> f32
auto zpl_float_to_half(f32 value) -> zpl_half
auto zpl_vec2f_zero(void) -> zpl_vec2
auto zpl_vec2f(f32 x, f32 y) -> zpl_vec2
auto zpl_vec2fv(f32 x[2]) -> zpl_vec2
auto zpl_vec3f_zero(void) -> zpl_vec3
auto zpl_vec3f(f32 x, f32 y, f32 z) -> zpl_vec3
auto zpl_vec3fv(f32 x[3]) -> zpl_vec3
auto zpl_vec4f_zero(void) -> zpl_vec4
auto zpl_vec4f(f32 x, f32 y, f32 z, f32 w) -> zpl_vec4
auto zpl_vec4fv(f32 x[4]) -> zpl_vec4
auto zpl_vec2_add(zpl_vec2* d, zpl_vec2 v0, zpl_vec2 v1) -> void
auto zpl_vec2_sub(zpl_vec2* d, zpl_vec2 v0, zpl_vec2 v1) -> void
auto zpl_vec2_mul(zpl_vec2* d, zpl_vec2 v, f32 s) -> void
auto zpl_vec2_div(zpl_vec2* d, zpl_vec2 v, f32 s) -> void
auto zpl_vec3_add(zpl_vec3* d, zpl_vec3 v0, zpl_vec3 v1) -> void
auto zpl_vec3_sub(zpl_vec3* d, zpl_vec3 v0, zpl_vec3 v1) -> void
auto zpl_vec3_mul(zpl_vec3* d, zpl_vec3 v, f32 s) -> void
auto zpl_vec3_div(zpl_vec3* d, zpl_vec3 v, f32 s) -> void
auto zpl_vec4_add(zpl_vec4* d, zpl_vec4 v0, zpl_vec4 v1) -> void
auto zpl_vec4_sub(zpl_vec4* d, zpl_vec4 v0, zpl_vec4 v1) -> void
auto zpl_vec4_mul(zpl_vec4* d, zpl_vec4 v, f32 s) -> void
auto zpl_vec4_div(zpl_vec4* d, zpl_vec4 v, f32 s) -> void
auto zpl_vec2_addeq(zpl_vec2* d, zpl_vec2 v) -> void
auto zpl_vec2_subeq(zpl_vec2* d, zpl_vec2 v) -> void
auto zpl_vec2_muleq(zpl_vec2* d, f32 s) -> void
auto zpl_vec2_diveq(zpl_vec2* d, f32 s) -> void
auto zpl_vec3_addeq(zpl_vec3* d, zpl_vec3 v) -> void
auto zpl_vec3_subeq(zpl_vec3* d, zpl_vec3 v) -> void
auto zpl_vec3_muleq(zpl_vec3* d, f32 s) -> void
auto zpl_vec3_diveq(zpl_vec3* d, f32 s) -> void
auto zpl_vec4_addeq(zpl_vec4* d, zpl_vec4 v) -> void
auto zpl_vec4_subeq(zpl_vec4* d, zpl_vec4 v) -> void
auto zpl_vec4_muleq(zpl_vec4* d, f32 s) -> void
auto zpl_vec4_diveq(zpl_vec4* d, f32 s) -> void
auto zpl_vec2_dot(zpl_vec2 v0, zpl_vec2 v1) -> f32
auto zpl_vec3_dot(zpl_vec3 v0, zpl_vec3 v1) -> f32
auto zpl_vec4_dot(zpl_vec4 v0, zpl_vec4 v1) -> f32
auto zpl_vec2_cross(f32* d, zpl_vec2 v0, zpl_vec2 v1) -> void
auto zpl_vec3_cross(zpl_vec3* d, zpl_vec3 v0, zpl_vec3 v1) -> void
auto zpl_vec2_mag2(zpl_vec2 v) -> f32
auto zpl_vec3_mag2(zpl_vec3 v) -> f32
auto zpl_vec4_mag2(zpl_vec4 v) -> f32
auto zpl_vec2_mag(zpl_vec2 v) -> f32
auto zpl_vec3_mag(zpl_vec3 v) -> f32
auto zpl_vec4_mag(zpl_vec4 v) -> f32
auto zpl_vec2_norm(zpl_vec2* d, zpl_vec2 v) -> void
auto zpl_vec3_norm(zpl_vec3* d, zpl_vec3 v) -> void
auto zpl_vec4_norm(zpl_vec4* d, zpl_vec4 v) -> void
auto zpl_vec2_norm0(zpl_vec2* d, zpl_vec2 v) -> void
auto zpl_vec3_norm0(zpl_vec3* d, zpl_vec3 v) -> void
auto zpl_vec4_norm0(zpl_vec4* d, zpl_vec4 v) -> void
auto zpl_vec2_reflect(zpl_vec2* d, zpl_vec2 i, zpl_vec2 n) -> void
auto zpl_vec3_reflect(zpl_vec3* d, zpl_vec3 i, zpl_vec3 n) -> void
auto zpl_vec2_refract(zpl_vec2* d, zpl_vec2 i, zpl_vec2 n, f32 eta) -> void
auto zpl_vec3_refract(zpl_vec3* d, zpl_vec3 i, zpl_vec3 n, f32 eta) -> void
auto zpl_vec2_aspect_ratio(zpl_vec2 v) -> f32
auto zpl_mat2_identity(zpl_mat2* m) -> void
auto zpl_float22_identity(f32 m[2][2]) -> void
auto zpl_mat2_transpose(zpl_mat2* m) -> void
auto zpl_mat2_mul(zpl_mat2* out, zpl_mat2* m1, zpl_mat2* m2) -> void
auto zpl_mat2_mul_vec2(zpl_vec2* out, zpl_mat2* m, zpl_vec2 in) -> void
auto zpl_mat2_inverse(zpl_mat2* out, zpl_mat2* in) -> void
auto zpl_mat2_determinate(zpl_mat2* m) -> f32
auto zpl_mat2_v(zpl_vec2 m[2]) -> zpl_mat2*
auto zpl_mat2_f(f32 m[2][2]) -> zpl_mat2*
auto zpl_float22_m(zpl_mat2* m) -> zpl_float2*
auto zpl_float22_v(zpl_vec2 m[2]) -> zpl_float2*
auto zpl_float22_4(f32 m[4]) -> zpl_float2*
auto zpl_float22_transpose(f32(*vec)[2]) -> void
auto zpl_float22_mul(f32(*out)[2], f32(*mat1)[2], f32(*mat2)[2]) -> void
auto zpl_float22_mul_vec2(zpl_vec2* out, f32 m[2][2], zpl_vec2 in) -> void
auto zpl_mat3_identity(zpl_mat3* m) -> void
auto zpl_float33_identity(f32 m[3][3]) -> void
auto zpl_mat3_transpose(zpl_mat3* m) -> void
auto zpl_mat3_mul(zpl_mat3* out, zpl_mat3* m1, zpl_mat3* m2) -> void
auto zpl_mat3_mul_vec3(zpl_vec3* out, zpl_mat3* m, zpl_vec3 in) -> void
auto zpl_mat3_inverse(zpl_mat3* out, zpl_mat3* in) -> void
auto zpl_mat3_determinate(zpl_mat3* m) -> f32
auto zpl_mat3_v(zpl_vec3 m[3]) -> zpl_mat3*
auto zpl_mat3_f(f32 m[3][3]) -> zpl_mat3*
auto zpl_float33_m(zpl_mat3* m) -> zpl_float3*
auto zpl_float33_v(zpl_vec3 m[3]) -> zpl_float3*
auto zpl_float33_9(f32 m[9]) -> zpl_float3*
auto zpl_float33_transpose(f32(*vec)[3]) -> void
auto zpl_float33_mul(f32(*out)[3], f32(*mat1)[3], f32(*mat2)[3]) -> void
auto zpl_float33_mul_vec3(zpl_vec3* out, f32 m[3][3], zpl_vec3 in) -> void
auto zpl_mat4_identity(zpl_mat4* m) -> void
auto zpl_float44_identity(f32 m[4][4]) -> void
auto zpl_mat4_transpose(zpl_mat4* m) -> void
auto zpl_mat4_mul(zpl_mat4* out, zpl_mat4* m1, zpl_mat4* m2) -> void
auto zpl_mat4_mul_vec4(zpl_vec4* out, zpl_mat4* m, zpl_vec4 in) -> void
auto zpl_mat4_inverse(zpl_mat4* out, zpl_mat4* in) -> void
auto zpl_mat4_v(zpl_vec4 m[4]) -> zpl_mat4*
auto zpl_mat4_f(f32 m[4][4]) -> zpl_mat4*
auto zpl_float44_m(zpl_mat4* m) -> zpl_float4*
auto zpl_float44_v(zpl_vec4 m[4]) -> zpl_float4*
auto zpl_float44_16(f32 m[16]) -> zpl_float4*
auto zpl_float44_transpose(f32(*vec)[4]) -> void
auto zpl_float44_mul(f32(*out)[4], f32(*mat1)[4], f32(*mat2)[4]) -> void
auto zpl_float44_mul_vec4(zpl_vec4* out, f32 m[4][4], zpl_vec4 in) -> void
auto zpl_mat4_translate(zpl_mat4* out, zpl_vec3 v) -> void
auto zpl_mat4_rotate(zpl_mat4* out, zpl_vec3 v, f32 angle_radians) -> void
auto zpl_mat4_scale(zpl_mat4* out, zpl_vec3 v) -> void
auto zpl_mat4_scalef(zpl_mat4* out, f32 s) -> void
auto zpl_mat4_ortho2d(zpl_mat4* out, f32 left, f32 right, f32 bottom, f32 top) -> void
auto zpl_mat4_ortho3d(zpl_mat4* out, f32 left, f32 right, f32 bottom, f32 top, f32 z_near, f32 z_far) -> void
auto zpl_mat4_perspective(zpl_mat4* out, f32 fovy, f32 aspect, f32 z_near, f32 z_far) -> void
auto zpl_mat4_infinite_perspective(zpl_mat4* out, f32 fovy, f32 aspect, f32 z_near) -> void
auto zpl_mat4_look_at(zpl_mat4* out, zpl_vec3 eye, zpl_vec3 centre, zpl_vec3 up) -> void
auto zpl_quatf(f32 x, f32 y, f32 z, f32 w) -> zpl_quat
auto zpl_quatfv(f32 e[4]) -> zpl_quat
auto zpl_quat_axis_angle(zpl_vec3 axis, f32 angle_radians) -> zpl_quat
auto zpl_quat_euler_angles(f32 pitch, f32 yaw, f32 roll) -> zpl_quat
auto zpl_quat_identity(void) -> zpl_quat
auto zpl_quat_add(zpl_quat* d, zpl_quat q0, zpl_quat q1) -> void
auto zpl_quat_sub(zpl_quat* d, zpl_quat q0, zpl_quat q1) -> void
auto zpl_quat_mul(zpl_quat* d, zpl_quat q0, zpl_quat q1) -> void
auto zpl_quat_div(zpl_quat* d, zpl_quat q0, zpl_quat q1) -> void
auto zpl_quat_mulf(zpl_quat* d, zpl_quat q, f32 s) -> void
auto zpl_quat_divf(zpl_quat* d, zpl_quat q, f32 s) -> void
auto zpl_quat_addeq(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_subeq(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_muleq(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_diveq(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_muleqf(zpl_quat* d, f32 s) -> void
auto zpl_quat_diveqf(zpl_quat* d, f32 s) -> void
auto zpl_quat_dot(zpl_quat q0, zpl_quat q1) -> f32
auto zpl_quat_mag(zpl_quat q) -> f32
auto zpl_quat_norm(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_conj(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_inverse(zpl_quat* d, zpl_quat q) -> void
auto zpl_quat_axis(zpl_vec3* axis, zpl_quat q) -> void
auto zpl_quat_angle(zpl_quat q) -> f32
auto zpl_quat_pitch(zpl_quat q) -> f32
auto zpl_quat_yaw(zpl_quat q) -> f32
auto zpl_quat_roll(zpl_quat q) -> f32
auto zpl_quat_rotate_vec3(zpl_vec3* d, zpl_quat q, zpl_vec3 v) -> void
auto zpl_mat4_from_quat(zpl_mat4* out, zpl_quat q) -> void
auto zpl_quat_from_mat4(zpl_quat* out, zpl_mat4* m) -> void
auto zpl_lerp(f32 a, f32 b, f32 t) -> f32
auto zpl_unlerp(f32 t, f32 a, f32 b) -> f32
auto zpl_smooth_step(f32 a, f32 b, f32 t) -> f32
auto zpl_smoother_step(f32 a, f32 b, f32 t) -> f32
auto zpl_vec2_lerp(zpl_vec2* d, zpl_vec2 a, zpl_vec2 b, f32 t) -> void
auto zpl_vec3_lerp(zpl_vec3* d, zpl_vec3 a, zpl_vec3 b, f32 t) -> void
auto zpl_vec4_lerp(zpl_vec4* d, zpl_vec4 a, zpl_vec4 b, f32 t) -> void
auto zpl_vec2_cslerp(zpl_vec2* d, zpl_vec2 a, zpl_vec2 v0, zpl_vec2 b, zpl_vec2 v1, f32 t) -> void
auto zpl_vec3_cslerp(zpl_vec3* d, zpl_vec3 a, zpl_vec3 v0, zpl_vec3 b, zpl_vec3 v1, f32 t) -> void
auto zpl_vec2_dcslerp(zpl_vec2* d, zpl_vec2 a, zpl_vec2 v0, zpl_vec2 b, zpl_vec2 v1, f32 t) -> void
auto zpl_vec3_dcslerp(zpl_vec3* d, zpl_vec3 a, zpl_vec3 v0, zpl_vec3 b, zpl_vec3 v1, f32 t) -> void
auto zpl_quat_lerp(zpl_quat* d, zpl_quat a, zpl_quat b, f32 t) -> void
auto zpl_quat_nlerp(zpl_quat* d, zpl_quat a, zpl_quat b, f32 t) -> void
auto zpl_quat_slerp(zpl_quat* d, zpl_quat a, zpl_quat b, f32 t) -> void
auto zpl_quat_nquad(zpl_quat* d, zpl_quat p, zpl_quat a, zpl_quat b, zpl_quat q, f32 t) -> void
auto zpl_quat_squad(zpl_quat* d, zpl_quat p, zpl_quat a, zpl_quat b, zpl_quat q, f32 t) -> void
auto zpl_quat_slerp_approx(zpl_quat* d, zpl_quat a, zpl_quat b, f32 t) -> void
auto zpl_quat_squad_approx(zpl_quat* d, zpl_quat p, zpl_quat a, zpl_quat b, zpl_quat q, f32 t) -> void
auto zpl_rect2f(zpl_vec2 pos, zpl_vec2 dim) -> zpl_rect2
auto zpl_rect3f(zpl_vec3 pos, zpl_vec3 dim) -> zpl_rect3
auto zpl_rect2_contains(zpl_rect2 a, f32 x, f32 y) -> int
auto zpl_rect2_contains_vec2(zpl_rect2 a, zpl_vec2 p) -> int
auto zpl_rect2_intersects(zpl_rect2 a, zpl_rect2 b) -> int
auto zpl_rect2_intersection_result(zpl_rect2 a, zpl_rect2 b, zpl_rect2* intersection) -> int

Defines

#define ZPL_CONSTANTS
#define ZPL_EPSILON
#define ZPL_ZERO
#define ZPL_ONE
#define ZPL_TWO_THIRDS
#define ZPL_TAU
#define ZPL_PI
#define ZPL_ONE_OVER_TAU
#define ZPL_ONE_OVER_PI
#define ZPL_TAU_OVER_2
#define ZPL_TAU_OVER_4
#define ZPL_TAU_OVER_8
#define ZPL_E
#define ZPL_SQRT_TWO
#define ZPL_SQRT_THREE
#define ZPL_SQRT_FIVE
#define ZPL_LOG_TWO
#define ZPL_LOG_TEN
#define zpl_square(x)
#define zpl_cube(x)
#define zpl_sign(x)
#define ZPL_MURMUR64_DEFAULT_SEED