core/math/linalg/glsl

math_linalg_glsl

Types

bvec2 :: [2]boolSource

bvec3 :: [3]boolSource

bvec4 :: [4]boolSource

dmat2 :: matrix[2, 2]f64Source

Double Precision (f64) Floating Point Types

dmat2x2 :: dmat2Source

dmat2x3 :: matrix[3, 2]f64Source

dmat2x4 :: matrix[4, 2]f64Source

dmat3 :: matrix[3, 3]f64Source

dmat3x2 :: matrix[2, 3]f64Source

dmat3x3 :: dmat3Source

dmat3x4 :: matrix[4, 3]f64Source

dmat4 :: matrix[4, 4]f64Source

dmat4x2 :: matrix[2, 4]f64Source

dmat4x3 :: matrix[3, 4]f64Source

dmat4x4 :: dmat4Source

dquat :: quaternion256Source

dvec2 :: [2]f64Source

dvec3 :: [3]f64Source

dvec4 :: [4]f64Source

ivec2 :: [2]i32Source

ivec3 :: [3]i32Source

ivec4 :: [4]i32Source

mat2 :: matrix[2, 2]f32Source

Odin matrices are stored internally as Column-Major, which matches OpenGL/GLSL by default

mat2x2 :: mat2Source

mat2x3 :: matrix[3, 2]f32Source

mat2x4 :: matrix[4, 2]f32Source

mat3 :: matrix[3, 3]f32Source

mat3x2 :: matrix[2, 3]f32Source

IMPORTANT NOTE: These data types are "backwards" in normal mathematical terms but they match how GLSL and OpenGL defines them in name Odin: matrix[R, C]f32 GLSL: matCxR

mat3x3 :: mat3Source

mat3x4 :: matrix[4, 3]f32Source

mat4 :: matrix[4, 4]f32Source

mat4x2 :: matrix[2, 4]f32Source

mat4x3 :: matrix[3, 4]f32Source

mat4x4 :: mat4Source

quat :: quaternion128Source

uvec2 :: [2]u32Source

uvec3 :: [3]u32Source

uvec4 :: [4]u32Source

vec2 :: [2]f32Source

vec3 :: [3]f32Source

vec4 :: [4]f32Source

Constants

E :: 2.71828182845904523536Source

F32_EPSILON :: 1e-7Source

F64_EPSILON :: 1e-15Source

LN10 :: 2.30258509299404568401799145468436421Source

LN2 :: 0.693147180559945309417232121458176568Source

PI :: 3.14159265358979323846264338327950288Source

SQRT_FIVE :: 2.23606797749978969640917366873127623Source

SQRT_THREE :: 1.73205080756887729352744634150587236Source

SQRT_TWO :: 1.41421356237309504880168872420969808Source

TAU :: 6.28318530717958647692528676655900576Source

e :: ESource

rsqrt :: inversesqrtSource

transpose :: intrinsics.transposeSource

π :: PISource

τ :: TAUSource

Procedures

593

abs_dvec2 :: proc(x: dvec2) -> (dvec2)Source

abs_dvec3 :: proc(x: dvec3) -> (dvec3)Source

abs_dvec4 :: proc(x: dvec4) -> (dvec4)Source

abs_f32 :: proc(x: f32) -> (f32)Source

abs_f64 :: proc(x: f64) -> (f64)Source

abs_i32 :: proc(x: i32) -> (i32)Source

abs_ivec2 :: proc(x: ivec2) -> (ivec2)Source

abs_ivec3 :: proc(x: ivec3) -> (ivec3)Source

abs_ivec4 :: proc(x: ivec4) -> (ivec4)Source

abs_u32 :: proc(x: u32) -> (u32)Source

abs_uvec2 :: proc(x: uvec2) -> (uvec2)Source

abs_uvec3 :: proc(x: uvec3) -> (uvec3)Source

abs_uvec4 :: proc(x: uvec4) -> (uvec4)Source

abs_vec2 :: proc(x: vec2) -> (vec2)Source

abs_vec3 :: proc(x: vec3) -> (vec3)Source

abs_vec4 :: proc(x: vec4) -> (vec4)Source

acos_dvec2 :: proc(x: dvec2) -> (dvec2)Source

acos_dvec3 :: proc(x: dvec3) -> (dvec3)Source

acos_dvec4 :: proc(x: dvec4) -> (dvec4)Source

acos_f32 :: proc(x: f32) -> (f32)Source

acos_f64 :: proc(x: f64) -> (f64)Source

acos_vec2 :: proc(x: vec2) -> (vec2)Source

acos_vec3 :: proc(x: vec3) -> (vec3)Source

acos_vec4 :: proc(x: vec4) -> (vec4)Source

acosh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

acosh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

acosh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

acosh_f32 :: proc(x: f32) -> (f32)Source

acosh_f64 :: proc(x: f64) -> (f64)Source

acosh_vec2 :: proc(x: vec2) -> (vec2)Source

acosh_vec3 :: proc(x: vec3) -> (vec3)Source

acosh_vec4 :: proc(x: vec4) -> (vec4)Source

adjugate_matrix1x1 :: proc(x: M) -> (y: M)Source

adjugate_matrix2x2 :: proc(x: M) -> (y: M)Source

adjugate_matrix3x3 :: proc(m: M) -> (y: M)Source

adjugate_matrix4x4 :: proc(x: M) -> (y: M)Source

all_bool :: proc(v: bool) -> (bool)Source

all_bvec2 :: proc(v: bvec2) -> (bool)Source

all_bvec3 :: proc(v: bvec3) -> (bool)Source

all_bvec4 :: proc(v: bvec4) -> (bool)Source

any_bool :: proc(v: bool) -> (bool)Source

any_bvec2 :: proc(v: bvec2) -> (bool)Source

any_bvec3 :: proc(v: bvec3) -> (bool)Source

any_bvec4 :: proc(v: bvec4) -> (bool)Source

asin_dvec2 :: proc(x: dvec2) -> (dvec2)Source

asin_dvec3 :: proc(x: dvec3) -> (dvec3)Source

asin_dvec4 :: proc(x: dvec4) -> (dvec4)Source

asin_f32 :: proc(x: f32) -> (f32)Source

asin_f64 :: proc(x: f64) -> (f64)Source

asin_vec2 :: proc(x: vec2) -> (vec2)Source

asin_vec3 :: proc(x: vec3) -> (vec3)Source

asin_vec4 :: proc(x: vec4) -> (vec4)Source

asinh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

asinh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

asinh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

asinh_f32 :: proc(x: f32) -> (f32)Source

asinh_f64 :: proc(x: f64) -> (f64)Source

asinh_vec2 :: proc(x: vec2) -> (vec2)Source

asinh_vec3 :: proc(x: vec3) -> (vec3)Source

asinh_vec4 :: proc(x: vec4) -> (vec4)Source

atan2_dvec2 :: proc(y: dvec2, x: dvec2) -> (dvec2)Source

atan2_dvec3 :: proc(y: dvec3, x: dvec3) -> (dvec3)Source

atan2_dvec4 :: proc(y: dvec4, x: dvec4) -> (dvec4)Source

atan2_f32 :: proc(y: f32, x: f32) -> (f32)Source

atan2_f64 :: proc(y: f64, x: f64) -> (f64)Source

atan2_vec2 :: proc(y: vec2, x: vec2) -> (vec2)Source

atan2_vec3 :: proc(y: vec3, x: vec3) -> (vec3)Source

atan2_vec4 :: proc(y: vec4, x: vec4) -> (vec4)Source

atan_dvec2 :: proc(x: dvec2) -> (dvec2)Source

atan_dvec3 :: proc(x: dvec3) -> (dvec3)Source

atan_dvec4 :: proc(x: dvec4) -> (dvec4)Source

atan_f32 :: proc(x: f32) -> (f32)Source

atan_f64 :: proc(x: f64) -> (f64)Source

atan_vec2 :: proc(x: vec2) -> (vec2)Source

atan_vec3 :: proc(x: vec3) -> (vec3)Source

atan_vec4 :: proc(x: vec4) -> (vec4)Source

atanh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

atanh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

atanh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

atanh_f32 :: proc(x: f32) -> (f32)Source

atanh_f64 :: proc(x: f64) -> (f64)Source

atanh_vec2 :: proc(x: vec2) -> (vec2)Source

atanh_vec3 :: proc(x: vec3) -> (vec3)Source

atanh_vec4 :: proc(x: vec4) -> (vec4)Source

ceil_dvec2 :: proc(x: dvec2) -> (dvec2)Source

ceil_dvec3 :: proc(x: dvec3) -> (dvec3)Source

ceil_dvec4 :: proc(x: dvec4) -> (dvec4)Source

ceil_f32 :: proc(x: f32) -> (f32)Source

ceil_f64 :: proc(x: f64) -> (f64)Source

ceil_vec2 :: proc(x: vec2) -> (vec2)Source

ceil_vec3 :: proc(x: vec3) -> (vec3)Source

ceil_vec4 :: proc(x: vec4) -> (vec4)Source

clamp_dvec2 :: proc(x: dvec2, y: dvec2, z: dvec2) -> (dvec2)Source

clamp_dvec3 :: proc(x: dvec3, y: dvec3, z: dvec3) -> (dvec3)Source

clamp_dvec4 :: proc(x: dvec4, y: dvec4, z: dvec4) -> (dvec4)Source

clamp_f32 :: proc(x: f32, y: f32, z: f32) -> (f32)Source

clamp_f64 :: proc(x: f64, y: f64, z: f64) -> (f64)Source

clamp_i32 :: proc(x: i32, y: i32, z: i32) -> (i32)Source

clamp_ivec2 :: proc(x: ivec2, y: ivec2, z: ivec2) -> (ivec2)Source

clamp_ivec3 :: proc(x: ivec3, y: ivec3, z: ivec3) -> (ivec3)Source

clamp_ivec4 :: proc(x: ivec4, y: ivec4, z: ivec4) -> (ivec4)Source

clamp_u32 :: proc(x: u32, y: u32, z: u32) -> (u32)Source

clamp_uvec2 :: proc(x: uvec2, y: uvec2, z: uvec2) -> (uvec2)Source

clamp_uvec3 :: proc(x: uvec3, y: uvec3, z: uvec3) -> (uvec3)Source

clamp_uvec4 :: proc(x: uvec4, y: uvec4, z: uvec4) -> (uvec4)Source

clamp_vec2 :: proc(x: vec2, y: vec2, z: vec2) -> (vec2)Source

clamp_vec3 :: proc(x: vec3, y: vec3, z: vec3) -> (vec3)Source

clamp_vec4 :: proc(x: vec4, y: vec4, z: vec4) -> (vec4)Source

cofactor_matrix1x1 :: proc(x: M) -> (y: M)Source

cofactor_matrix2x2 :: proc(x: M) -> (y: M)Source

cofactor_matrix3x3 :: proc(m: M) -> (y: M)Source

cofactor_matrix4x4 :: proc(x: M) -> (y: M)Source

cos_dvec2 :: proc(x: dvec2) -> (dvec2)Source

cos_dvec3 :: proc(x: dvec3) -> (dvec3)Source

cos_dvec4 :: proc(x: dvec4) -> (dvec4)Source

cos_f32 :: proc(x: f32) -> (f32)Source

cos_f64 :: proc(x: f64) -> (f64)Source

cos_vec2 :: proc(x: vec2) -> (vec2)Source

cos_vec3 :: proc(x: vec3) -> (vec3)Source

cos_vec4 :: proc(x: vec4) -> (vec4)Source

cosh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

cosh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

cosh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

cosh_f32 :: proc(x: f32) -> (f32)Source

cosh_f64 :: proc(x: f64) -> (f64)Source

cosh_vec2 :: proc(x: vec2) -> (vec2)Source

cosh_vec3 :: proc(x: vec3) -> (vec3)Source

cosh_vec4 :: proc(x: vec4) -> (vec4)Source

cross_dvec3 :: proc(a: dvec3, b: dvec3) -> (c: dvec3)Source

cross_ivec3 :: proc(a: ivec3, b: ivec3) -> (c: ivec3)Source

cross_vec3 :: proc(a: vec3, b: vec3) -> (c: vec3)Source

degrees_dvec2 :: proc(radians: dvec2) -> (dvec2)Source

degrees_dvec3 :: proc(radians: dvec3) -> (dvec3)Source

degrees_dvec4 :: proc(radians: dvec4) -> (dvec4)Source

degrees_f32 :: proc(radians: f32) -> (f32)Source

degrees_f64 :: proc(radians: f64) -> (f64)Source

degrees_vec2 :: proc(radians: vec2) -> (vec2)Source

degrees_vec3 :: proc(radians: vec3) -> (vec3)Source

degrees_vec4 :: proc(radians: vec4) -> (vec4)Source

determinant_matrix1x1 :: proc(m: M) -> (det: T)Source

determinant_matrix2x2 :: proc(m: M) -> (det: T)Source

determinant_matrix3x3 :: proc(m: M) -> (det: T)Source

determinant_matrix4x4 :: proc(m: M) -> (det: T)Source

distance_dvec2 :: proc(x: dvec2, y: dvec2) -> (f64)Source

distance_dvec3 :: proc(x: dvec3, y: dvec3) -> (f64)Source

distance_dvec4 :: proc(x: dvec4, y: dvec4) -> (f64)Source

distance_f32 :: proc(x: f32, y: f32) -> (f32)Source

distance_f64 :: proc(x: f64, y: f64) -> (f64)Source

distance_vec2 :: proc(x: vec2, y: vec2) -> (f32)Source

distance_vec3 :: proc(x: vec3, y: vec3) -> (f32)Source

distance_vec4 :: proc(x: vec4, y: vec4) -> (f32)Source

dmat4FromDquat :: proc(q: dquat) -> (m: dmat4)Source

dmat4LookAt :: proc(eye: dvec3, centre: dvec3, up: dvec3) -> (m: dmat4)Source

dmat4Orientation :: proc(normal: dvec3, up: dvec3) -> (dmat4)Source

dmat4Ortho3d :: proc(
	left:   f64,
	right:  f64,
	bottom: f64,
	top:    f64,
	near:   f64,
	far:    f64,
) -> (m: dmat4)

Source

dmat4Perspective :: proc(fovy: f64, aspect: f64, near: f64, far: f64) -> (m: dmat4)Source

dmat4PerspectiveInfinite :: proc(fovy: f64, aspect: f64, near: f64) -> (m: dmat4)Source

dmat4Rotate :: proc(v: dvec3, radians: f64) -> (rot: dmat4)Source

dmat4Scale :: proc(v: dvec3) -> (m: dmat4)Source

dmat4Translate :: proc(v: dvec3) -> (m: dmat4)Source

dot_dquat :: proc(a: dquat, b: dquat) -> (f64)Source

dot_dvec2 :: proc(a: dvec2, b: dvec2) -> (f64)Source

dot_dvec3 :: proc(a: dvec3, b: dvec3) -> (f64)Source

dot_dvec4 :: proc(a: dvec4, b: dvec4) -> (f64)Source

dot_f32 :: proc(a: f32, b: f32) -> (f32)Source

dot_f64 :: proc(a: f64, b: f64) -> (f64)Source

dot_i32 :: proc(a: i32, b: i32) -> (i32)Source

dot_ivec2 :: proc(a: ivec2, b: ivec2) -> (i32)Source

dot_ivec3 :: proc(a: ivec3, b: ivec3) -> (i32)Source

dot_ivec4 :: proc(a: ivec4, b: ivec4) -> (i32)Source

dot_quat :: proc(a: quat, b: quat) -> (f32)Source

dot_u32 :: proc(a: u32, b: u32) -> (u32)Source

dot_uvec2 :: proc(a: uvec2, b: uvec2) -> (u32)Source

dot_uvec3 :: proc(a: uvec3, b: uvec3) -> (u32)Source

dot_uvec4 :: proc(a: uvec4, b: uvec4) -> (u32)Source

dot_vec2 :: proc(a: vec2, b: vec2) -> (f32)Source

dot_vec3 :: proc(a: vec3, b: vec3) -> (f32)Source

dot_vec4 :: proc(a: vec4, b: vec4) -> (f32)Source

dquatAxisAngle :: proc(axis: dvec3, radians: f64) -> (q: dquat)Source

dquatFromDmat4 :: proc(m: dmat4) -> (q: dquat)Source

dquatFromdMat3 :: proc(m: dmat3) -> (q: dquat)Source

dquatMulDvec3 :: proc(q: dquat, v: dvec3) -> (dvec3)Source

dquatNlerp :: proc(a: dquat, b: dquat, t: f64) -> (c: dquat)Source

dquatSlerp :: proc(x: dquat, y: dquat, t: f64) -> (q: dquat)Source

equal_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

equal_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

equal_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

equal_f32 :: proc(a: f32, b: f32) -> (bool)Source

equal_f64 :: proc(a: f64, b: f64) -> (bool)Source

equal_i32 :: proc(a: i32, b: i32) -> (bool)Source

equal_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

equal_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

equal_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

equal_u32 :: proc(a: u32, b: u32) -> (bool)Source

equal_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

equal_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

equal_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

equal_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

equal_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

equal_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

exp2_dvec2 :: proc(x: dvec2) -> (dvec2)Source

exp2_dvec3 :: proc(x: dvec3) -> (dvec3)Source

exp2_dvec4 :: proc(x: dvec4) -> (dvec4)Source

exp2_f32 :: proc(x: f32) -> (f32)Source

exp2_f64 :: proc(x: f64) -> (f64)Source

exp2_vec2 :: proc(x: vec2) -> (vec2)Source

exp2_vec3 :: proc(x: vec3) -> (vec3)Source

exp2_vec4 :: proc(x: vec4) -> (vec4)Source

exp_dvec2 :: proc(x: dvec2) -> (dvec2)Source

exp_dvec3 :: proc(x: dvec3) -> (dvec3)Source

exp_dvec4 :: proc(x: dvec4) -> (dvec4)Source

exp_f32 :: proc(x: f32) -> (f32)Source

exp_f64 :: proc(x: f64) -> (f64)Source

exp_vec2 :: proc(x: vec2) -> (vec2)Source

exp_vec3 :: proc(x: vec3) -> (vec3)Source

exp_vec4 :: proc(x: vec4) -> (vec4)Source

faceForward_dvec2 :: proc(N: dvec2, I: dvec2, Nref: dvec2) -> (dvec2)Source

faceForward_dvec3 :: proc(N: dvec3, I: dvec3, Nref: dvec3) -> (dvec3)Source

faceForward_dvec4 :: proc(N: dvec4, I: dvec4, Nref: dvec4) -> (dvec4)Source

faceForward_f32 :: proc(N: f32, I: f32, Nref: f32) -> (f32)Source

faceForward_f64 :: proc(N: f64, I: f64, Nref: f64) -> (f64)Source

faceForward_vec2 :: proc(N: vec2, I: vec2, Nref: vec2) -> (vec2)Source

faceForward_vec3 :: proc(N: vec3, I: vec3, Nref: vec3) -> (vec3)Source

faceForward_vec4 :: proc(N: vec4, I: vec4, Nref: vec4) -> (vec4)Source

floor_dvec2 :: proc(x: dvec2) -> (dvec2)Source

floor_dvec3 :: proc(x: dvec3) -> (dvec3)Source

floor_dvec4 :: proc(x: dvec4) -> (dvec4)Source

floor_f32 :: proc(x: f32) -> (f32)Source

floor_f64 :: proc(x: f64) -> (f64)Source

floor_vec2 :: proc(x: vec2) -> (vec2)Source

floor_vec3 :: proc(x: vec3) -> (vec3)Source

floor_vec4 :: proc(x: vec4) -> (vec4)Source

fract_dvec2 :: proc(x: dvec2) -> (dvec2)Source

fract_dvec3 :: proc(x: dvec3) -> (dvec3)Source

fract_dvec4 :: proc(x: dvec4) -> (dvec4)Source

fract_f32 :: proc(x: f32) -> (f32)Source

fract_f64 :: proc(x: f64) -> (f64)Source

fract_vec2 :: proc(x: vec2) -> (vec2)Source

fract_vec3 :: proc(x: vec3) -> (vec3)Source

fract_vec4 :: proc(x: vec4) -> (vec4)Source

greaterThanEqual_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

greaterThanEqual_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

greaterThanEqual_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

greaterThanEqual_f32 :: proc(a: f32, b: f32) -> (bool)Source

greaterThanEqual_f64 :: proc(a: f64, b: f64) -> (bool)Source

greaterThanEqual_i32 :: proc(a: i32, b: i32) -> (bool)Source

greaterThanEqual_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

greaterThanEqual_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

greaterThanEqual_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

greaterThanEqual_u32 :: proc(a: u32, b: u32) -> (bool)Source

greaterThanEqual_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

greaterThanEqual_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

greaterThanEqual_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

greaterThanEqual_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

greaterThanEqual_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

greaterThanEqual_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

greaterThan_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

greaterThan_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

greaterThan_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

greaterThan_f32 :: proc(a: f32, b: f32) -> (bool)Source

greaterThan_f64 :: proc(a: f64, b: f64) -> (bool)Source

greaterThan_i32 :: proc(a: i32, b: i32) -> (bool)Source

greaterThan_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

greaterThan_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

greaterThan_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

greaterThan_u32 :: proc(a: u32, b: u32) -> (bool)Source

greaterThan_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

greaterThan_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

greaterThan_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

greaterThan_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

greaterThan_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

greaterThan_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

hermitian_adjoint :: proc(m) -> (M)Source

identity :: proc(M: typeid) -> (M)Source

/ Matrix Utilities

inverse_dmat2 :: proc(m: dmat2) -> (dmat2)Source

inverse_dmat3 :: proc(m: dmat3) -> (dmat3)Source

inverse_dmat4 :: proc(m: dmat4) -> (dmat4)Source

inverse_dquat :: proc(q: dquat) -> (dquat)Source

inverse_mat2 :: proc(m: mat2) -> (mat2)Source

inverse_mat3 :: proc(m: mat3) -> (mat3)Source

inverse_mat4 :: proc(m: mat4) -> (mat4)Source

inverse_matrix1x1 :: proc(x: M) -> (y: M)Source

inverse_matrix2x2 :: proc(x: M) -> (y: M)Source

inverse_matrix3x3 :: proc(x: M) -> (y: M)Source

inverse_matrix4x4 :: proc(x: M) -> (y: M)Source

inverse_quat :: proc(q: quat) -> (quat)Source

inverse_transpose_matrix1x1 :: proc(x: M) -> (y: M)Source

inverse_transpose_matrix2x2 :: proc(x: M) -> (y: M)Source

inverse_transpose_matrix3x3 :: proc(x: M) -> (y: M)Source

inverse_transpose_matrix4x4 :: proc(x: M) -> (y: M)Source

inversesqrt_dvec2 :: proc(x: dvec2) -> (dvec2)Source

inversesqrt_dvec3 :: proc(x: dvec3) -> (dvec3)Source

inversesqrt_dvec4 :: proc(x: dvec4) -> (dvec4)Source

inversesqrt_f32 :: proc(x: f32) -> (f32)Source

inversesqrt_f64 :: proc(x: f64) -> (f64)Source

inversesqrt_vec2 :: proc(x: vec2) -> (vec2)Source

inversesqrt_vec3 :: proc(x: vec3) -> (vec3)Source

inversesqrt_vec4 :: proc(x: vec4) -> (vec4)Source

length_dquat :: proc(x: dquat) -> (f64)Source

length_dvec2 :: proc(x: dvec2) -> (f64)Source

length_dvec3 :: proc(x: dvec3) -> (f64)Source

length_dvec4 :: proc(x: dvec4) -> (f64)Source

length_f32 :: proc(x: f32) -> (f32)Source

length_f64 :: proc(x: f64) -> (f64)Source

length_quat :: proc(x: quat) -> (f32)Source

length_vec2 :: proc(x: vec2) -> (f32)Source

length_vec3 :: proc(x: vec3) -> (f32)Source

length_vec4 :: proc(x: vec4) -> (f32)Source

lerp_dvec2 :: proc(x: dvec2, y: dvec2, t: dvec2) -> (dvec2)Source

lerp_dvec3 :: proc(x: dvec3, y: dvec3, t: dvec3) -> (dvec3)Source

lerp_dvec4 :: proc(x: dvec4, y: dvec4, t: dvec4) -> (dvec4)Source

lerp_f32 :: proc(x: f32, y: f32, t: f32) -> (f32)Source

lerp_f64 :: proc(x: f64, y: f64, t: f64) -> (f64)Source

lerp_vec2 :: proc(x: vec2, y: vec2, t: vec2) -> (vec2)Source

lerp_vec3 :: proc(x: vec3, y: vec3, t: vec3) -> (vec3)Source

lerp_vec4 :: proc(x: vec4, y: vec4, t: vec4) -> (vec4)Source

lessThanEqual_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

lessThanEqual_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

lessThanEqual_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

lessThanEqual_f32 :: proc(a: f32, b: f32) -> (bool)Source

lessThanEqual_f64 :: proc(a: f64, b: f64) -> (bool)Source

lessThanEqual_i32 :: proc(a: i32, b: i32) -> (bool)Source

lessThanEqual_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

lessThanEqual_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

lessThanEqual_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

lessThanEqual_u32 :: proc(a: u32, b: u32) -> (bool)Source

lessThanEqual_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

lessThanEqual_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

lessThanEqual_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

lessThanEqual_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

lessThanEqual_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

lessThanEqual_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

lessThan_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

lessThan_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

lessThan_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

lessThan_f32 :: proc(a: f32, b: f32) -> (bool)Source

lessThan_f64 :: proc(a: f64, b: f64) -> (bool)Source

lessThan_i32 :: proc(a: i32, b: i32) -> (bool)Source

lessThan_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

lessThan_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

lessThan_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

lessThan_u32 :: proc(a: u32, b: u32) -> (bool)Source

lessThan_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

lessThan_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

lessThan_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

lessThan_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

lessThan_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

lessThan_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

log_dvec2 :: proc(x: dvec2) -> (dvec2)Source

log_dvec3 :: proc(x: dvec3) -> (dvec3)Source

log_dvec4 :: proc(x: dvec4) -> (dvec4)Source

log_f32 :: proc(x: f32) -> (f32)Source

log_f64 :: proc(x: f64) -> (f64)Source

log_vec2 :: proc(x: vec2) -> (vec2)Source

log_vec3 :: proc(x: vec3) -> (vec3)Source

log_vec4 :: proc(x: vec4) -> (vec4)Source

mat4FromQuat :: proc(q: quat) -> (m: mat4)Source

mat4LookAt :: proc(eye: vec3, centre: vec3, up: vec3) -> (m: mat4)Source

mat4Orientation :: proc(normal: vec3, up: vec3) -> (mat4)Source

mat4Ortho3d :: proc(
	left:   f32,
	right:  f32,
	bottom: f32,
	top:    f32,
	near:   f32,
	far:    f32,
) -> (m: mat4)

Source

mat4Perspective :: proc(fovy: f32, aspect: f32, near: f32, far: f32) -> (m: mat4)Source

mat4PerspectiveInfinite :: proc(fovy: f32, aspect: f32, near: f32) -> (m: mat4)Source

mat4Rotate :: proc(v: vec3, radians: f32) -> (rot: mat4)Source

mat4Scale :: proc(v: vec3) -> (m: mat4)Source

mat4Translate :: proc(v: vec3) -> (m: mat4)Source

matrix_minor :: proc(m, any_int, column: int) -> (minor: T)Source

max_dvec2 :: proc(x: dvec2, y: dvec2) -> (dvec2)Source

max_dvec3 :: proc(x: dvec3, y: dvec3) -> (dvec3)Source

max_dvec4 :: proc(x: dvec4, y: dvec4) -> (dvec4)Source

max_f32 :: proc(x: f32, y: f32) -> (f32)Source

max_f64 :: proc(x: f64, y: f64) -> (f64)Source

max_i32 :: proc(x: i32, y: i32) -> (i32)Source

max_ivec2 :: proc(x: ivec2, y: ivec2) -> (ivec2)Source

max_ivec3 :: proc(x: ivec3, y: ivec3) -> (ivec3)Source

max_ivec4 :: proc(x: ivec4, y: ivec4) -> (ivec4)Source

max_u32 :: proc(x: u32, y: u32) -> (u32)Source

max_uvec2 :: proc(x: uvec2, y: uvec2) -> (uvec2)Source

max_uvec3 :: proc(x: uvec3, y: uvec3) -> (uvec3)Source

max_uvec4 :: proc(x: uvec4, y: uvec4) -> (uvec4)Source

max_vec2 :: proc(x: vec2, y: vec2) -> (vec2)Source

max_vec3 :: proc(x: vec3, y: vec3) -> (vec3)Source

max_vec4 :: proc(x: vec4, y: vec4) -> (vec4)Source

min_dvec2 :: proc(x: dvec2, y: dvec2) -> (dvec2)Source

min_dvec3 :: proc(x: dvec3, y: dvec3) -> (dvec3)Source

min_dvec4 :: proc(x: dvec4, y: dvec4) -> (dvec4)Source

min_f32 :: proc(x: f32, y: f32) -> (f32)Source

min_f64 :: proc(x: f64, y: f64) -> (f64)Source

min_i32 :: proc(x: i32, y: i32) -> (i32)Source

min_ivec2 :: proc(x: ivec2, y: ivec2) -> (ivec2)Source

min_ivec3 :: proc(x: ivec3, y: ivec3) -> (ivec3)Source

min_ivec4 :: proc(x: ivec4, y: ivec4) -> (ivec4)Source

min_u32 :: proc(x: u32, y: u32) -> (u32)Source

min_uvec2 :: proc(x: uvec2, y: uvec2) -> (uvec2)Source

min_uvec3 :: proc(x: uvec3, y: uvec3) -> (uvec3)Source

min_uvec4 :: proc(x: uvec4, y: uvec4) -> (uvec4)Source

min_vec2 :: proc(x: vec2, y: vec2) -> (vec2)Source

min_vec3 :: proc(x: vec3, y: vec3) -> (vec3)Source

min_vec4 :: proc(x: vec4, y: vec4) -> (vec4)Source

mix_dvec2 :: proc(x: dvec2, y: dvec2, t: dvec2) -> (dvec2)Source

mix_dvec3 :: proc(x: dvec3, y: dvec3, t: dvec3) -> (dvec3)Source

mix_dvec4 :: proc(x: dvec4, y: dvec4, t: dvec4) -> (dvec4)Source

mix_f32 :: proc(x: f32, y: f32, t: f32) -> (f32)Source

mix_f64 :: proc(x: f64, y: f64, t: f64) -> (f64)Source

mix_vec2 :: proc(x: vec2, y: vec2, t: vec2) -> (vec2)Source

mix_vec3 :: proc(x: vec3, y: vec3, t: vec3) -> (vec3)Source

mix_vec4 :: proc(x: vec4, y: vec4, t: vec4) -> (vec4)Source

mod_dvec2 :: proc(x: dvec2, y: dvec2) -> (dvec2)Source

mod_dvec3 :: proc(x: dvec3, y: dvec3) -> (dvec3)Source

mod_dvec4 :: proc(x: dvec4, y: dvec4) -> (dvec4)Source

mod_f32 :: proc(x: f32, y: f32) -> (f32)Source

mod_f64 :: proc(x: f64, y: f64) -> (f64)Source

mod_vec2 :: proc(x: vec2, y: vec2) -> (vec2)Source

mod_vec3 :: proc(x: vec3, y: vec3) -> (vec3)Source

mod_vec4 :: proc(x: vec4, y: vec4) -> (vec4)Source

normalize_dquat :: proc(x: dquat) -> (dquat)Source

normalize_dvec2 :: proc(x: dvec2) -> (dvec2)Source

normalize_dvec3 :: proc(x: dvec3) -> (dvec3)Source

normalize_dvec4 :: proc(x: dvec4) -> (dvec4)Source

normalize_f32 :: proc(x: f32) -> (f32)Source

normalize_f64 :: proc(x: f64) -> (f64)Source

normalize_quat :: proc(x: quat) -> (quat)Source

normalize_vec2 :: proc(x: vec2) -> (vec2)Source

normalize_vec3 :: proc(x: vec3) -> (vec3)Source

normalize_vec4 :: proc(x: vec4) -> (vec4)Source

notEqual_dvec2 :: proc(a: dvec2, b: dvec2) -> (bvec2)Source

notEqual_dvec3 :: proc(a: dvec3, b: dvec3) -> (bvec3)Source

notEqual_dvec4 :: proc(a: dvec4, b: dvec4) -> (bvec4)Source

notEqual_f32 :: proc(a: f32, b: f32) -> (bool)Source

notEqual_f64 :: proc(a: f64, b: f64) -> (bool)Source

notEqual_i32 :: proc(a: i32, b: i32) -> (bool)Source

notEqual_ivec2 :: proc(a: ivec2, b: ivec2) -> (bvec2)Source

notEqual_ivec3 :: proc(a: ivec3, b: ivec3) -> (bvec3)Source

notEqual_ivec4 :: proc(a: ivec4, b: ivec4) -> (bvec4)Source

notEqual_u32 :: proc(a: u32, b: u32) -> (bool)Source

notEqual_uvec2 :: proc(a: uvec2, b: uvec2) -> (bvec2)Source

notEqual_uvec3 :: proc(a: uvec3, b: uvec3) -> (bvec3)Source

notEqual_uvec4 :: proc(a: uvec4, b: uvec4) -> (bvec4)Source

notEqual_vec2 :: proc(a: vec2, b: vec2) -> (bvec2)Source

notEqual_vec3 :: proc(a: vec3, b: vec3) -> (bvec3)Source

notEqual_vec4 :: proc(a: vec4, b: vec4) -> (bvec4)Source

not_bool :: proc(v: bool) -> (bool)Source

not_bvec2 :: proc(v: bvec2) -> (bvec2)Source

not_bvec3 :: proc(v: bvec3) -> (bvec3)Source

not_bvec4 :: proc(v: bvec4) -> (bvec4)Source

pow_dvec2 :: proc(x: dvec2, y: dvec2) -> (dvec2)Source

pow_dvec3 :: proc(x: dvec3, y: dvec3) -> (dvec3)Source

pow_dvec4 :: proc(x: dvec4, y: dvec4) -> (dvec4)Source

pow_f32 :: proc(x: f32, y: f32) -> (f32)Source

pow_f64 :: proc(x: f64, y: f64) -> (f64)Source

pow_vec2 :: proc(x: vec2, y: vec2) -> (vec2)Source

pow_vec3 :: proc(x: vec3, y: vec3) -> (vec3)Source

pow_vec4 :: proc(x: vec4, y: vec4) -> (vec4)Source

quatAxisAngle :: proc(axis: vec3, radians: f32) -> (q: quat)Source

quatFromMat3 :: proc(m: mat3) -> (q: quat)Source

quatFromMat4 :: proc(m: mat4) -> (q: quat)Source

quatMulVec3 :: proc(q: quat, v: vec3) -> (vec3)Source

quatNlerp :: proc(a: quat, b: quat, t: f32) -> (c: quat)Source

quatSlerp :: proc(x: quat, y: quat, t: f32) -> (q: quat)Source

radians_dvec2 :: proc(degrees: dvec2) -> (dvec2)Source

radians_dvec3 :: proc(degrees: dvec3) -> (dvec3)Source

radians_dvec4 :: proc(degrees: dvec4) -> (dvec4)Source

radians_f32 :: proc(degrees: f32) -> (f32)Source

radians_f64 :: proc(degrees: f64) -> (f64)Source

radians_vec2 :: proc(degrees: vec2) -> (vec2)Source

radians_vec3 :: proc(degrees: vec3) -> (vec3)Source

radians_vec4 :: proc(degrees: vec4) -> (vec4)Source

reflect_dvec2 :: proc(I: dvec2, N: dvec2) -> (dvec2)Source

reflect_dvec3 :: proc(I: dvec3, N: dvec3) -> (dvec3)Source

reflect_dvec4 :: proc(I: dvec4, N: dvec4) -> (dvec4)Source

reflect_f32 :: proc(I: f32, N: f32) -> (f32)Source

reflect_f64 :: proc(I: f64, N: f64) -> (f64)Source

reflect_vec2 :: proc(I: vec2, N: vec2) -> (vec2)Source

reflect_vec3 :: proc(I: vec3, N: vec3) -> (vec3)Source

reflect_vec4 :: proc(I: vec4, N: vec4) -> (vec4)Source

refract_dvec2 :: proc(i: dvec2, n: dvec2, eta: dvec2) -> (dvec2)Source

refract_dvec3 :: proc(i: dvec3, n: dvec3, eta: dvec3) -> (dvec3)Source

refract_dvec4 :: proc(i: dvec4, n: dvec4, eta: dvec4) -> (dvec4)Source

refract_f32 :: proc(i: f32, n: f32, eta: f32) -> (f32)Source

refract_f64 :: proc(i: f64, n: f64, eta: f64) -> (f64)Source

refract_vec2 :: proc(i: vec2, n: vec2, eta: vec2) -> (vec2)Source

refract_vec3 :: proc(i: vec3, n: vec3, eta: vec3) -> (vec3)Source

refract_vec4 :: proc(i: vec4, n: vec4, eta: vec4) -> (vec4)Source

round_dvec2 :: proc(x: dvec2) -> (dvec2)Source

round_dvec3 :: proc(x: dvec3) -> (dvec3)Source

round_dvec4 :: proc(x: dvec4) -> (dvec4)Source

round_f32 :: proc(x: f32) -> (f32)Source

round_f64 :: proc(x: f64) -> (f64)Source

round_vec2 :: proc(x: vec2) -> (vec2)Source

round_vec3 :: proc(x: vec3) -> (vec3)Source

round_vec4 :: proc(x: vec4) -> (vec4)Source

saturate_dvec2 :: proc(v: dvec2) -> (dvec2)Source

saturate_dvec3 :: proc(v: dvec3) -> (dvec3)Source

saturate_dvec4 :: proc(v: dvec4) -> (dvec4)Source

saturate_f32 :: proc(v: f32) -> (f32)Source

saturate_f64 :: proc(v: f64) -> (f64)Source

saturate_i32 :: proc(v: i32) -> (i32)Source

saturate_ivec2 :: proc(v: ivec2) -> (ivec2)Source

saturate_ivec3 :: proc(v: ivec3) -> (ivec3)Source

saturate_ivec4 :: proc(v: ivec4) -> (ivec4)Source

saturate_u32 :: proc(v: u32) -> (u32)Source

saturate_uvec2 :: proc(v: uvec2) -> (uvec2)Source

saturate_uvec3 :: proc(v: uvec3) -> (uvec3)Source

saturate_uvec4 :: proc(v: uvec4) -> (uvec4)Source

saturate_vec2 :: proc(v: vec2) -> (vec2)Source

saturate_vec3 :: proc(v: vec3) -> (vec3)Source

saturate_vec4 :: proc(v: vec4) -> (vec4)Source

scalarTripleProduct_dvec3 :: proc(a: dvec3, b: dvec3, c: dvec3) -> (f64)Source

scalarTripleProduct_ivec3 :: proc(a: ivec3, b: ivec3, c: ivec3) -> (i32)Source

scalarTripleProduct_vec3 :: proc(a: vec3, b: vec3, c: vec3) -> (f32)Source

sign_dvec2 :: proc(x: dvec2) -> (dvec2)Source

sign_dvec3 :: proc(x: dvec3) -> (dvec3)Source

sign_dvec4 :: proc(x: dvec4) -> (dvec4)Source

sign_f32 :: proc(x: f32) -> (f32)Source

sign_f64 :: proc(x: f64) -> (f64)Source

sign_i32 :: proc(x: i32) -> (i32)Source

sign_ivec2 :: proc(x: ivec2) -> (ivec2)Source

sign_ivec3 :: proc(x: ivec3) -> (ivec3)Source

sign_ivec4 :: proc(x: ivec4) -> (ivec4)Source

sign_u32 :: proc(x: u32) -> (u32)Source

sign_uvec2 :: proc(x: uvec2) -> (uvec2)Source

sign_uvec3 :: proc(x: uvec3) -> (uvec3)Source

sign_uvec4 :: proc(x: uvec4) -> (uvec4)Source

sign_vec2 :: proc(x: vec2) -> (vec2)Source

sign_vec3 :: proc(x: vec3) -> (vec3)Source

sign_vec4 :: proc(x: vec4) -> (vec4)Source

sin_dvec2 :: proc(x: dvec2) -> (dvec2)Source

sin_dvec3 :: proc(x: dvec3) -> (dvec3)Source

sin_dvec4 :: proc(x: dvec4) -> (dvec4)Source

sin_f32 :: proc(x: f32) -> (f32)Source

sin_f64 :: proc(x: f64) -> (f64)Source

sin_vec2 :: proc(x: vec2) -> (vec2)Source

sin_vec3 :: proc(x: vec3) -> (vec3)Source

sin_vec4 :: proc(x: vec4) -> (vec4)Source

sinh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

sinh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

sinh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

sinh_f32 :: proc(x: f32) -> (f32)Source

sinh_f64 :: proc(x: f64) -> (f64)Source

sinh_vec2 :: proc(x: vec2) -> (vec2)Source

sinh_vec3 :: proc(x: vec3) -> (vec3)Source

sinh_vec4 :: proc(x: vec4) -> (vec4)Source

smoothstep_dvec2 :: proc(edge0: dvec2, edge1: dvec2, x: dvec2) -> (dvec2)Source

smoothstep_dvec3 :: proc(edge0: dvec3, edge1: dvec3, x: dvec3) -> (dvec3)Source

smoothstep_dvec4 :: proc(edge0: dvec4, edge1: dvec4, x: dvec4) -> (dvec4)Source

smoothstep_f32 :: proc(edge0: f32, edge1: f32, x: f32) -> (f32)Source

smoothstep_f64 :: proc(edge0: f64, edge1: f64, x: f64) -> (f64)Source

smoothstep_vec2 :: proc(edge0: vec2, edge1: vec2, x: vec2) -> (vec2)Source

smoothstep_vec3 :: proc(edge0: vec3, edge1: vec3, x: vec3) -> (vec3)Source

smoothstep_vec4 :: proc(edge0: vec4, edge1: vec4, x: vec4) -> (vec4)Source

sqrt_dvec2 :: proc(x: dvec2) -> (dvec2)Source

sqrt_dvec3 :: proc(x: dvec3) -> (dvec3)Source

sqrt_dvec4 :: proc(x: dvec4) -> (dvec4)Source

sqrt_f32 :: proc(x: f32) -> (f32)Source

sqrt_f64 :: proc(x: f64) -> (f64)Source

sqrt_vec2 :: proc(x: vec2) -> (vec2)Source

sqrt_vec3 :: proc(x: vec3) -> (vec3)Source

sqrt_vec4 :: proc(x: vec4) -> (vec4)Source

step_dvec2 :: proc(edge: dvec2, x: dvec2) -> (dvec2)Source

step_dvec3 :: proc(edge: dvec3, x: dvec3) -> (dvec3)Source

step_dvec4 :: proc(edge: dvec4, x: dvec4) -> (dvec4)Source

step_f32 :: proc(edge: f32, x: f32) -> (f32)Source

step_f64 :: proc(edge: f64, x: f64) -> (f64)Source

step_vec2 :: proc(edge: vec2, x: vec2) -> (vec2)Source

step_vec3 :: proc(edge: vec3, x: vec3) -> (vec3)Source

step_vec4 :: proc(edge: vec4, x: vec4) -> (vec4)Source

tan_dvec2 :: proc(x: dvec2) -> (dvec2)Source

tan_dvec3 :: proc(x: dvec3) -> (dvec3)Source

tan_dvec4 :: proc(x: dvec4) -> (dvec4)Source

tan_f32 :: proc(x: f32) -> (f32)Source

tan_f64 :: proc(x: f64) -> (f64)Source

tan_vec2 :: proc(x: vec2) -> (vec2)Source

tan_vec3 :: proc(x: vec3) -> (vec3)Source

tan_vec4 :: proc(x: vec4) -> (vec4)Source

tanh_dvec2 :: proc(x: dvec2) -> (dvec2)Source

tanh_dvec3 :: proc(x: dvec3) -> (dvec3)Source

tanh_dvec4 :: proc(x: dvec4) -> (dvec4)Source

tanh_f32 :: proc(x: f32) -> (f32)Source

tanh_f64 :: proc(x: f64) -> (f64)Source

tanh_vec2 :: proc(x: vec2) -> (vec2)Source

tanh_vec3 :: proc(x: vec3) -> (vec3)Source

tanh_vec4 :: proc(x: vec4) -> (vec4)Source

trace :: proc(m) -> (trace: T)Source

trunc_dvec2 :: proc(x: dvec2) -> (dvec2)Source

trunc_dvec3 :: proc(x: dvec3) -> (dvec3)Source

trunc_dvec4 :: proc(x: dvec4) -> (dvec4)Source

trunc_f32 :: proc(x: f32) -> (f32)Source

trunc_f64 :: proc(x: f64) -> (f64)Source

trunc_vec2 :: proc(x: vec2) -> (vec2)Source

trunc_vec3 :: proc(x: vec3) -> (vec3)Source

trunc_vec4 :: proc(x: vec4) -> (vec4)Source

vectorTripleProduct_dvec3 :: proc(a: dvec3, b: dvec3, c: dvec3) -> (dvec3)Source

vectorTripleProduct_ivec3 :: proc(a: ivec3, b: ivec3, c: ivec3) -> (ivec3)Source

vectorTripleProduct_vec3 :: proc(a: vec3, b: vec3, c: vec3) -> (vec3)Source

Procedure Groups

abs :: proc{abs_i32, abs_u32, abs_f32, abs_f64, abs_vec2, abs_vec3, abs_vec4, abs_dvec2, abs_dvec3, abs_dvec4, abs_ivec2, abs_ivec3, abs_ivec4, abs_uvec2, abs_uvec3, abs_uvec4}

Source

acos :: proc{acos_f32, acos_f64, acos_vec2, acos_vec3, acos_vec4, acos_dvec2, acos_dvec3, acos_dvec4}Source

acosh :: proc{acosh_f32, acosh_f64, acosh_vec2, acosh_vec3, acosh_vec4, acosh_dvec2, acosh_dvec3, acosh_dvec4}Source

adjugate :: proc{adjugate_matrix1x1, adjugate_matrix2x2, adjugate_matrix3x3, adjugate_matrix4x4}Source

all :: proc{all_bool, all_bvec2, all_bvec3, all_bvec4}Source

any :: proc{any_bool, any_bvec2, any_bvec3, any_bvec4}Source

asin :: proc{asin_f32, asin_f64, asin_vec2, asin_vec3, asin_vec4, asin_dvec2, asin_dvec3, asin_dvec4}Source

asinh :: proc{asinh_f32, asinh_f64, asinh_vec2, asinh_vec3, asinh_vec4, asinh_dvec2, asinh_dvec3, asinh_dvec4}Source

atan :: proc{atan_f32, atan_f64, atan_vec2, atan_vec3, atan_vec4, atan_dvec2, atan_dvec3, atan_dvec4, atan2_f32, atan2_f64, atan2_vec2, atan2_vec3, atan2_vec4, atan2_dvec2, atan2_dvec3, atan2_dvec4}

Source

atan2 :: proc{atan2_f32, atan2_f64, atan2_vec2, atan2_vec3, atan2_vec4, atan2_dvec2, atan2_dvec3, atan2_dvec4}Source

atanh :: proc{atanh_f32, atanh_f64, atanh_vec2, atanh_vec3, atanh_vec4, atanh_dvec2, atanh_dvec3, atanh_dvec4}Source

ceil :: proc{ceil_f32, ceil_f64, ceil_vec2, ceil_vec3, ceil_vec4, ceil_dvec2, ceil_dvec3, ceil_dvec4}Source

clamp :: proc{clamp_i32, clamp_u32, clamp_f32, clamp_f64, clamp_vec2, clamp_vec3, clamp_vec4, clamp_dvec2, clamp_dvec3, clamp_dvec4, clamp_ivec2, clamp_ivec3, clamp_ivec4, clamp_uvec2, clamp_uvec3, clamp_uvec4}

Source

cofactor :: proc{cofactor_matrix1x1, cofactor_matrix2x2, cofactor_matrix3x3, cofactor_matrix4x4}Source

cos :: proc{cos_f32, cos_f64, cos_vec2, cos_vec3, cos_vec4, cos_dvec2, cos_dvec3, cos_dvec4}Source

cosh :: proc{cosh_f32, cosh_f64, cosh_vec2, cosh_vec3, cosh_vec4, cosh_dvec2, cosh_dvec3, cosh_dvec4}Source

cross :: proc{cross_vec3, cross_dvec3, cross_ivec3}Source

degrees :: proc{degrees_f32, degrees_f64, degrees_vec2, degrees_vec3, degrees_vec4, degrees_dvec2, degrees_dvec3, degrees_dvec4}

Source

determinant :: proc{determinant_matrix1x1, determinant_matrix2x2, determinant_matrix3x3, determinant_matrix4x4}Source

distance :: proc{distance_f32, distance_f64, distance_vec2, distance_vec3, distance_vec4, distance_dvec2, distance_dvec3, distance_dvec4}

Source

dot :: proc{dot_i32, dot_u32, dot_f32, dot_f64, dot_vec2, dot_vec3, dot_vec4, dot_dvec2, dot_dvec3, dot_dvec4, dot_ivec2, dot_ivec3, dot_ivec4, dot_uvec2, dot_uvec3, dot_uvec4, dot_quat, dot_dquat}

Source

equal :: proc{equal_f32, equal_f64, equal_i32, equal_u32, equal_vec2, equal_dvec2, equal_ivec2, equal_uvec2, equal_vec3, equal_dvec3, equal_ivec3, equal_uvec3, equal_vec4, equal_dvec4, equal_ivec4, equal_uvec4}

Source

exp :: proc{exp_f32, exp_f64, exp_vec2, exp_vec3, exp_vec4, exp_dvec2, exp_dvec3, exp_dvec4}Source

exp2 :: proc{exp2_f32, exp2_f64, exp2_vec2, exp2_vec3, exp2_vec4, exp2_dvec2, exp2_dvec3, exp2_dvec4}Source

faceForward :: proc{faceForward_f32, faceForward_f64, faceForward_vec2, faceForward_vec3, faceForward_vec4, faceForward_dvec2, faceForward_dvec3, faceForward_dvec4}

Source

floor :: proc{floor_f32, floor_f64, floor_vec2, floor_vec3, floor_vec4, floor_dvec2, floor_dvec3, floor_dvec4}Source

fract :: proc{fract_f32, fract_f64, fract_vec2, fract_vec3, fract_vec4, fract_dvec2, fract_dvec3, fract_dvec4}Source

greaterThan :: proc{greaterThan_f32, greaterThan_f64, greaterThan_i32, greaterThan_u32, greaterThan_vec2, greaterThan_dvec2, greaterThan_ivec2, greaterThan_uvec2, greaterThan_vec3, greaterThan_dvec3, greaterThan_ivec3, greaterThan_uvec3, greaterThan_vec4, greaterThan_dvec4, greaterThan_ivec4, greaterThan_uvec4}

Source

greaterThanEqual :: proc{greaterThanEqual_f32, greaterThanEqual_f64, greaterThanEqual_i32, greaterThanEqual_u32, greaterThanEqual_vec2, greaterThanEqual_dvec2, greaterThanEqual_ivec2, greaterThanEqual_uvec2, greaterThanEqual_vec3, greaterThanEqual_dvec3, greaterThanEqual_ivec3, greaterThanEqual_uvec3, greaterThanEqual_vec4, greaterThanEqual_dvec4, greaterThanEqual_ivec4, greaterThanEqual_uvec4}

Source

inverse :: proc{inverse_matrix1x1, inverse_matrix2x2, inverse_matrix3x3, inverse_matrix4x4}Source

inverse_transpose :: proc{inverse_transpose_matrix1x1, inverse_transpose_matrix2x2, inverse_transpose_matrix3x3, inverse_transpose_matrix4x4}

Source

inversesqrt :: proc{inversesqrt_f32, inversesqrt_f64, inversesqrt_vec2, inversesqrt_vec3, inversesqrt_vec4, inversesqrt_dvec2, inversesqrt_dvec3, inversesqrt_dvec4}

Source

length :: proc{length_f32, length_f64, length_vec2, length_vec3, length_vec4, length_dvec2, length_dvec3, length_dvec4, length_quat, length_dquat}

Source

lerp :: proc{lerp_f32, lerp_f64, lerp_vec2, lerp_vec3, lerp_vec4, lerp_dvec2, lerp_dvec3, lerp_dvec4}Source

lessThan :: proc{lessThan_f32, lessThan_f64, lessThan_i32, lessThan_u32, lessThan_vec2, lessThan_dvec2, lessThan_ivec2, lessThan_uvec2, lessThan_vec3, lessThan_dvec3, lessThan_ivec3, lessThan_uvec3, lessThan_vec4, lessThan_dvec4, lessThan_ivec4, lessThan_uvec4}

Source

Vector Relational Procedures

lessThanEqual :: proc{lessThanEqual_f32, lessThanEqual_f64, lessThanEqual_i32, lessThanEqual_u32, lessThanEqual_vec2, lessThanEqual_dvec2, lessThanEqual_ivec2, lessThanEqual_uvec2, lessThanEqual_vec3, lessThanEqual_dvec3, lessThanEqual_ivec3, lessThanEqual_uvec3, lessThanEqual_vec4, lessThanEqual_dvec4, lessThanEqual_ivec4, lessThanEqual_uvec4}

Source

log :: proc{log_f32, log_f64, log_vec2, log_vec3, log_vec4, log_dvec2, log_dvec3, log_dvec4}Source

max :: proc{max_i32, max_u32, max_f32, max_f64, max_vec2, max_vec3, max_vec4, max_dvec2, max_dvec3, max_dvec4, max_ivec2, max_ivec3, max_ivec4, max_uvec2, max_uvec3, max_uvec4}

Source

min :: proc{min_i32, min_u32, min_f32, min_f64, min_vec2, min_vec3, min_vec4, min_dvec2, min_dvec3, min_dvec4, min_ivec2, min_ivec3, min_ivec4, min_uvec2, min_uvec3, min_uvec4}

Source

mix :: proc{mix_f32, mix_f64, mix_vec2, mix_vec3, mix_vec4, mix_dvec2, mix_dvec3, mix_dvec4}Source

mod :: proc{mod_f32, mod_f64, mod_vec2, mod_vec3, mod_vec4, mod_dvec2, mod_dvec3, mod_dvec4}Source

nlerp :: proc{quatNlerp, dquatNlerp}Source

normalize :: proc{normalize_f32, normalize_f64, normalize_vec2, normalize_vec3, normalize_vec4, normalize_dvec2, normalize_dvec3, normalize_dvec4, normalize_quat, normalize_dquat}

Source

not :: proc{not_bool, not_bvec2, not_bvec3, not_bvec4}Source

notEqual :: proc{notEqual_f32, notEqual_f64, notEqual_i32, notEqual_u32, notEqual_vec2, notEqual_dvec2, notEqual_ivec2, notEqual_uvec2, notEqual_vec3, notEqual_dvec3, notEqual_ivec3, notEqual_uvec3, notEqual_vec4, notEqual_dvec4, notEqual_ivec4, notEqual_uvec4}

Source

pow :: proc{pow_f32, pow_f64, pow_vec2, pow_vec3, pow_vec4, pow_dvec2, pow_dvec3, pow_dvec4}Source

radians :: proc{radians_f32, radians_f64, radians_vec2, radians_vec3, radians_vec4, radians_dvec2, radians_dvec3, radians_dvec4}

Source

reflect :: proc{reflect_f32, reflect_f64, reflect_vec2, reflect_vec3, reflect_vec4, reflect_dvec2, reflect_dvec3, reflect_dvec4}

Source

refract :: proc{refract_f32, refract_f64, refract_vec2, refract_vec3, refract_vec4, refract_dvec2, refract_dvec3, refract_dvec4}

Source

round :: proc{round_f32, round_f64, round_vec2, round_vec3, round_vec4, round_dvec2, round_dvec3, round_dvec4}Source

saturate :: proc{saturate_i32, saturate_u32, saturate_f32, saturate_f64, saturate_vec2, saturate_vec3, saturate_vec4, saturate_dvec2, saturate_dvec3, saturate_dvec4, saturate_ivec2, saturate_ivec3, saturate_ivec4, saturate_uvec2, saturate_uvec3, saturate_uvec4}

Source

scalarTripleProduct :: proc{scalarTripleProduct_vec3, scalarTripleProduct_dvec3, scalarTripleProduct_ivec3}Source

sign :: proc{sign_i32, sign_u32, sign_f32, sign_f64, sign_vec2, sign_vec3, sign_vec4, sign_dvec2, sign_dvec3, sign_dvec4, sign_ivec2, sign_ivec3, sign_ivec4, sign_uvec2, sign_uvec3, sign_uvec4}

Source

sin :: proc{sin_f32, sin_f64, sin_vec2, sin_vec3, sin_vec4, sin_dvec2, sin_dvec3, sin_dvec4}Source

sinh :: proc{sinh_f32, sinh_f64, sinh_vec2, sinh_vec3, sinh_vec4, sinh_dvec2, sinh_dvec3, sinh_dvec4}Source

slerp :: proc{quatSlerp, dquatSlerp}Source

smoothstep :: proc{smoothstep_f32, smoothstep_f64, smoothstep_vec2, smoothstep_vec3, smoothstep_vec4, smoothstep_dvec2, smoothstep_dvec3, smoothstep_dvec4}

Source

sqrt :: proc{sqrt_f32, sqrt_f64, sqrt_vec2, sqrt_vec3, sqrt_vec4, sqrt_dvec2, sqrt_dvec3, sqrt_dvec4}Source

step :: proc{step_f32, step_f64, step_vec2, step_vec3, step_vec4, step_dvec2, step_dvec3, step_dvec4}Source

tan :: proc{tan_f32, tan_f64, tan_vec2, tan_vec3, tan_vec4, tan_dvec2, tan_dvec3, tan_dvec4}Source

tanh :: proc{tanh_f32, tanh_f64, tanh_vec2, tanh_vec3, tanh_vec4, tanh_dvec2, tanh_dvec3, tanh_dvec4}Source

trunc :: proc{trunc_f32, trunc_f64, trunc_vec2, trunc_vec3, trunc_vec4, trunc_dvec2, trunc_dvec3, trunc_dvec4}Source

vectorTripleProduct :: proc{vectorTripleProduct_vec3, vectorTripleProduct_dvec3, vectorTripleProduct_ivec3}Source

math_linalg_glsl

Types

Constants

Procedures

Procedure Groups

Find anything

Settings