package core:math/linalg/glsl

Overview

core:math/linalg/glsl implements a GLSL-like mathematics library plus numerous other utility procedures

Index

Variables (0)

This section is empty.

Procedures (563)

Types

bvec2 ¶

bvec2 :: distinct [2]bool

bvec3 ¶

bvec3 :: distinct [3]bool

bvec4 ¶

bvec4 :: distinct [4]bool

dmat2 ¶

dmat2 :: distinct matrix[2, 2]f64

dmat2x3 ¶

dmat2x3 :: distinct matrix[3, 2]f64

dmat2x4 ¶

dmat2x4 :: distinct matrix[4, 2]f64

dmat3 ¶

dmat3 :: distinct matrix[3, 3]f64

dmat3x2 ¶

dmat3x2 :: distinct matrix[2, 3]f64

dmat3x4 ¶

dmat3x4 :: distinct matrix[4, 3]f64

dmat4 ¶

dmat4 :: distinct matrix[4, 4]f64

dmat4x2 ¶

dmat4x2 :: distinct matrix[2, 4]f64

dmat4x3 ¶

dmat4x3 :: distinct matrix[3, 4]f64

dquat ¶

dquat :: distinct quaternion256

dvec2 ¶

dvec2 :: distinct [2]f64

dvec3 ¶

dvec3 :: distinct [3]f64

dvec4 ¶

dvec4 :: distinct [4]f64

ivec2 ¶

ivec2 :: distinct [2]i32

ivec3 ¶

ivec3 :: distinct [3]i32

ivec4 ¶

ivec4 :: distinct [4]i32

mat2 ¶

mat2 :: distinct matrix[2, 2]f32
 

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

mat2x3 ¶

mat2x3 :: distinct matrix[3, 2]f32

mat2x4 ¶

mat2x4 :: distinct matrix[4, 2]f32

mat3 ¶

mat3 :: distinct matrix[3, 3]f32

mat3x2 ¶

mat3x2 :: distinct matrix[2, 3]f32
 

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

mat3x4 ¶

mat3x4 :: distinct matrix[4, 3]f32

mat4 ¶

mat4 :: distinct matrix[4, 4]f32

mat4x2 ¶

mat4x2 :: distinct matrix[2, 4]f32

mat4x3 ¶

mat4x3 :: distinct matrix[3, 4]f32

quat ¶

quat :: distinct quaternion128

uvec2 ¶

uvec2 :: distinct [2]u32

uvec3 ¶

uvec3 :: distinct [3]u32

uvec4 ¶

uvec4 :: distinct [4]u32

vec2 ¶

vec2 :: distinct [2]f32

vec3 ¶

vec3 :: distinct [3]f32

vec4 ¶

vec4 :: distinct [4]f32

Constants

E ¶

E :: 2.71828182845904523536

F32_EPSILON ¶

F32_EPSILON :: 1e-7

F64_EPSILON ¶

F64_EPSILON :: 1e-15

LN10 ¶

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶

LN2 :: 0.693147180559945309417232121458176568

PI ¶

PI :: 3.14159265358979323846264338327950288

SQRT_FIVE ¶

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE ¶

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO ¶

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU ¶

TAU :: 6.28318530717958647692528676655900576

e ¶

e :: E

π ¶

π :: PI

τ ¶

τ :: TAU

Variables

This section is empty.

Procedures

abs_dvec2 ¶

abs_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

abs_dvec3 ¶

abs_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

abs_dvec4 ¶

abs_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

abs_f32 ¶

abs_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

abs_f64 ¶

abs_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

abs_i32 ¶

abs_i32 :: proc "cdecl" (key: i32) -> i32 {…}

abs_ivec2 ¶

abs_ivec2 :: proc "cdecl" (x: ivec2) -> ivec2 {…}

abs_ivec3 ¶

abs_ivec3 :: proc "cdecl" (x: ivec3) -> ivec3 {…}

abs_ivec4 ¶

abs_ivec4 :: proc "cdecl" (x: ivec4) -> ivec4 {…}

abs_u32 ¶

abs_u32 :: proc "cdecl" (x: u32) -> u32 {…}

abs_uvec2 ¶

abs_uvec2 :: proc "cdecl" (x: uvec2) -> uvec2 {…}

abs_uvec3 ¶

abs_uvec3 :: proc "cdecl" (x: uvec3) -> uvec3 {…}

abs_uvec4 ¶

abs_uvec4 :: proc "cdecl" (x: uvec4) -> uvec4 {…}

abs_vec2 ¶

abs_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

abs_vec3 ¶

abs_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

abs_vec4 ¶

abs_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

acos_dvec2 ¶

acos_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

acos_dvec3 ¶

acos_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

acos_dvec4 ¶

acos_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

acos_f32 ¶

acos_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

acos_f64 ¶

acos_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

acos_vec2 ¶

acos_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

acos_vec3 ¶

acos_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

acos_vec4 ¶

acos_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

acosh_dvec2 ¶

acosh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

acosh_dvec3 ¶

acosh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

acosh_dvec4 ¶

acosh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

acosh_f32 ¶

acosh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

acosh_f64 ¶

acosh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

acosh_vec2 ¶

acosh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

acosh_vec3 ¶

acosh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

acosh_vec4 ¶

acosh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

all_bool ¶

all_bool :: proc "cdecl" (v: bool) -> bool {…}

all_bvec2 ¶

all_bvec2 :: proc "cdecl" (v: bvec2) -> bool {…}

all_bvec3 ¶

all_bvec3 :: proc "cdecl" (v: bvec3) -> bool {…}

all_bvec4 ¶

all_bvec4 :: proc "cdecl" (v: bvec4) -> bool {…}

any_bool ¶

any_bool :: proc "cdecl" (v: bool) -> bool {…}

any_bvec2 ¶

any_bvec2 :: proc "cdecl" (v: bvec2) -> bool {…}

any_bvec3 ¶

any_bvec3 :: proc "cdecl" (v: bvec3) -> bool {…}

any_bvec4 ¶

any_bvec4 :: proc "cdecl" (v: bvec4) -> bool {…}

asin_dvec2 ¶

asin_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

asin_dvec3 ¶

asin_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

asin_dvec4 ¶

asin_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

asin_f32 ¶

asin_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

asin_f64 ¶

asin_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

asin_vec2 ¶

asin_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

asin_vec3 ¶

asin_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

asin_vec4 ¶

asin_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

asinh_dvec2 ¶

asinh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

asinh_dvec3 ¶

asinh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

asinh_dvec4 ¶

asinh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

asinh_f32 ¶

asinh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

asinh_f64 ¶

asinh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

asinh_vec2 ¶

asinh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

asinh_vec3 ¶

asinh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

asinh_vec4 ¶

asinh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

atan2_dvec2 ¶

atan2_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

atan2_dvec3 ¶

atan2_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

atan2_dvec4 ¶

atan2_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

atan2_f32 ¶

atan2_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

atan2_f64 ¶

atan2_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

atan2_vec2 ¶

atan2_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

atan2_vec3 ¶

atan2_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

atan2_vec4 ¶

atan2_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

atan_dvec2 ¶

atan_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

atan_dvec3 ¶

atan_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

atan_dvec4 ¶

atan_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

atan_f32 ¶

atan_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

atan_f64 ¶

atan_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

atan_vec2 ¶

atan_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

atan_vec3 ¶

atan_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

atan_vec4 ¶

atan_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

atanh_dvec2 ¶

atanh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

atanh_dvec3 ¶

atanh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

atanh_dvec4 ¶

atanh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

atanh_f32 ¶

atanh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

atanh_f64 ¶

atanh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

atanh_vec2 ¶

atanh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

atanh_vec3 ¶

atanh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

atanh_vec4 ¶

atanh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

ceil_dvec2 ¶

ceil_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

ceil_dvec3 ¶

ceil_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

ceil_dvec4 ¶

ceil_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

ceil_f32 ¶

ceil_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

ceil_f64 ¶

ceil_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

ceil_vec2 ¶

ceil_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

ceil_vec3 ¶

ceil_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

ceil_vec4 ¶

ceil_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

clamp_dvec2 ¶

clamp_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

clamp_dvec3 ¶

clamp_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

clamp_dvec4 ¶

clamp_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

clamp_f32 ¶

clamp_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

clamp_f64 ¶

clamp_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

clamp_i32 ¶

clamp_i32 :: proc "cdecl" (x, y, z: i32) -> i32 {…}

clamp_ivec2 ¶

clamp_ivec2 :: proc "cdecl" (x, y, z: ivec2) -> ivec2 {…}

clamp_ivec3 ¶

clamp_ivec3 :: proc "cdecl" (x, y, z: ivec3) -> ivec3 {…}

clamp_ivec4 ¶

clamp_ivec4 :: proc "cdecl" (x, y, z: ivec4) -> ivec4 {…}

clamp_u32 ¶

clamp_u32 :: proc "cdecl" (x, y, z: u32) -> u32 {…}

clamp_uvec2 ¶

clamp_uvec2 :: proc "cdecl" (x, y, z: uvec2) -> uvec2 {…}

clamp_uvec3 ¶

clamp_uvec3 :: proc "cdecl" (x, y, z: uvec3) -> uvec3 {…}

clamp_uvec4 ¶

clamp_uvec4 :: proc "cdecl" (x, y, z: uvec4) -> uvec4 {…}

clamp_vec2 ¶

clamp_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

clamp_vec3 ¶

clamp_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

clamp_vec4 ¶

clamp_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

cos_dvec2 ¶

cos_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

cos_dvec3 ¶

cos_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

cos_dvec4 ¶

cos_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

cos_f32 ¶

cos_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

cos_f64 ¶

cos_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

cos_vec2 ¶

cos_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

cos_vec3 ¶

cos_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

cos_vec4 ¶

cos_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

cosh_dvec2 ¶

cosh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

cosh_dvec3 ¶

cosh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

cosh_dvec4 ¶

cosh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

cosh_f32 ¶

cosh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

cosh_f64 ¶

cosh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

cosh_vec2 ¶

cosh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

cosh_vec3 ¶

cosh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

cosh_vec4 ¶

cosh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

cross_dvec3 ¶

cross_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

cross_ivec3 ¶

cross_ivec3 :: proc "cdecl" (x, y: ivec3) -> ivec3 {…}

cross_vec3 ¶

cross_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

degrees_dvec2 ¶

degrees_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

degrees_dvec3 ¶

degrees_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

degrees_dvec4 ¶

degrees_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

degrees_f32 ¶

degrees_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

degrees_f64 ¶

degrees_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

degrees_vec2 ¶

degrees_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

degrees_vec3 ¶

degrees_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

degrees_vec4 ¶

degrees_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

distance_dvec2 ¶

distance_dvec2 :: proc "cdecl" (a, b: dvec2) -> f64 {…}

distance_dvec3 ¶

distance_dvec3 :: proc "cdecl" (a, b: dvec3) -> f64 {…}

distance_dvec4 ¶

distance_dvec4 :: proc "cdecl" (a, b: dvec4) -> f64 {…}

distance_f32 ¶

distance_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

distance_f64 ¶

distance_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

distance_vec2 ¶

distance_vec2 :: proc "cdecl" (a, b: vec2) -> f32 {…}

distance_vec3 ¶

distance_vec3 :: proc "cdecl" (a, b: vec3) -> f32 {…}

distance_vec4 ¶

distance_vec4 :: proc "cdecl" (a, b: vec4) -> f32 {…}

dmat4FromDquat ¶

dmat4FromDquat :: proc "cdecl" (q: dquat) -> (m: dmat4) {…}

dmat4LookAt ¶

dmat4LookAt :: proc "cdecl" (eye, centre, up: dvec3) -> (m: dmat4) {…}

dmat4Orientation ¶

dmat4Orientation :: proc "cdecl" (normal, up: dvec3) -> dmat4 {…}

dmat4Ortho3d ¶

dmat4Ortho3d :: proc "cdecl" (
	left, right, bottom, top, near, 
) -> (m: dmat4) {…}

dmat4Perspective ¶

dmat4Perspective :: proc "cdecl" (fovy, aspect, near, far: f64) -> (m: dmat4) {…}

dmat4PerspectiveInfinite ¶

dmat4PerspectiveInfinite :: proc "cdecl" (fovy, aspect, near: f64) -> (m: dmat4) {…}

dmat4Rotate ¶

dmat4Rotate :: proc "cdecl" (v: dvec3, radians: f64) -> (rot: dmat4) {…}

dmat4Scale ¶

dmat4Scale :: proc "cdecl" (v: dvec3) -> (m: dmat4) {…}

dmat4Translate ¶

dmat4Translate :: proc "cdecl" (v: dvec3) -> (m: dmat4) {…}

dot_dquat ¶

dot_dquat :: proc "cdecl" (a, b: dquat) -> f64 {…}

dot_dvec2 ¶

dot_dvec2 :: proc "cdecl" (a, b: dvec2) -> f64 {…}

dot_dvec3 ¶

dot_dvec3 :: proc "cdecl" (a, b: dvec3) -> f64 {…}

dot_dvec4 ¶

dot_dvec4 :: proc "cdecl" (a, b: dvec4) -> f64 {…}

dot_f32 ¶

dot_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

dot_f64 ¶

dot_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

dot_i32 ¶

dot_i32 :: proc "cdecl" (x, y: i32) -> i32 {…}

dot_ivec2 ¶

dot_ivec2 :: proc "cdecl" (a, b: ivec2) -> i32 {…}

dot_ivec3 ¶

dot_ivec3 :: proc "cdecl" (a, b: ivec3) -> i32 {…}

dot_ivec4 ¶

dot_ivec4 :: proc "cdecl" (a, b: ivec4) -> i32 {…}

dot_quat ¶

dot_quat :: proc "cdecl" (a, b: quat) -> f32 {…}

dot_u32 ¶

dot_u32 :: proc "cdecl" (x, y: u32) -> u32 {…}

dot_uvec2 ¶

dot_uvec2 :: proc "cdecl" (a, b: uvec2) -> u32 {…}

dot_uvec3 ¶

dot_uvec3 :: proc "cdecl" (a, b: uvec3) -> u32 {…}

dot_uvec4 ¶

dot_uvec4 :: proc "cdecl" (a, b: uvec4) -> u32 {…}

dot_vec2 ¶

dot_vec2 :: proc "cdecl" (a, b: vec2) -> f32 {…}

dot_vec3 ¶

dot_vec3 :: proc "cdecl" (a, b: vec3) -> f32 {…}

dot_vec4 ¶

dot_vec4 :: proc "cdecl" (a, b: vec4) -> f32 {…}

dquatAxisAngle ¶

dquatAxisAngle :: proc "cdecl" (axis: dvec3, radians: f64) -> (q: dquat) {…}

dquatFromDmat4 ¶

dquatFromDmat4 :: proc "cdecl" (m: dmat4) -> (q: dquat) {…}

dquatFromdMat3 ¶

dquatFromdMat3 :: proc "cdecl" (m: dmat3) -> (q: dquat) {…}

dquatMulDvec3 ¶

dquatMulDvec3 :: proc "cdecl" (q: dquat, v: dvec3) -> dvec3 {…}

dquatNlerp ¶

dquatNlerp :: proc "cdecl" (a, b: dquat, t: f64) -> (c: dquat) {…}

dquatSlerp ¶

dquatSlerp :: proc "cdecl" (a, b: dquat, t: f64) -> (c: dquat) {…}

equal_dvec2 ¶

equal_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

equal_dvec3 ¶

equal_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

equal_dvec4 ¶

equal_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

equal_f32 ¶

equal_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

equal_f64 ¶

equal_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

equal_i32 ¶

equal_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

equal_ivec2 ¶

equal_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

equal_ivec3 ¶

equal_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

equal_ivec4 ¶

equal_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

equal_u32 ¶

equal_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

equal_uvec2 ¶

equal_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

equal_uvec3 ¶

equal_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

equal_uvec4 ¶

equal_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

equal_vec2 ¶

equal_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

equal_vec3 ¶

equal_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

equal_vec4 ¶

equal_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

exp2_dvec2 ¶

exp2_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

exp2_dvec3 ¶

exp2_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

exp2_dvec4 ¶

exp2_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

exp2_f32 ¶

exp2_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

exp2_f64 ¶

exp2_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

exp2_vec2 ¶

exp2_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

exp2_vec3 ¶

exp2_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

exp2_vec4 ¶

exp2_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

exp_dvec2 ¶

exp_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

exp_dvec3 ¶

exp_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

exp_dvec4 ¶

exp_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

exp_f32 ¶

exp_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

exp_f64 ¶

exp_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

exp_vec2 ¶

exp_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

exp_vec3 ¶

exp_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

exp_vec4 ¶

exp_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

faceForward_dvec2 ¶

faceForward_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

faceForward_dvec3 ¶

faceForward_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

faceForward_dvec4 ¶

faceForward_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

faceForward_f32 ¶

faceForward_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

faceForward_f64 ¶

faceForward_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

faceForward_vec2 ¶

faceForward_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

faceForward_vec3 ¶

faceForward_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

faceForward_vec4 ¶

faceForward_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

floor_dvec2 ¶

floor_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

floor_dvec3 ¶

floor_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

floor_dvec4 ¶

floor_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

floor_f32 ¶

floor_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

floor_f64 ¶

floor_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

floor_vec2 ¶

floor_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

floor_vec3 ¶

floor_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

floor_vec4 ¶

floor_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

fract_dvec2 ¶

fract_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

fract_dvec3 ¶

fract_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

fract_dvec4 ¶

fract_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

fract_f32 ¶

fract_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

fract_f64 ¶

fract_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

fract_vec2 ¶

fract_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

fract_vec3 ¶

fract_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

fract_vec4 ¶

fract_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

greaterThanEqual_dvec2 ¶

greaterThanEqual_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

greaterThanEqual_dvec3 ¶

greaterThanEqual_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

greaterThanEqual_dvec4 ¶

greaterThanEqual_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

greaterThanEqual_f32 ¶

greaterThanEqual_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

greaterThanEqual_f64 ¶

greaterThanEqual_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

greaterThanEqual_i32 ¶

greaterThanEqual_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

greaterThanEqual_ivec2 ¶

greaterThanEqual_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

greaterThanEqual_ivec3 ¶

greaterThanEqual_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

greaterThanEqual_ivec4 ¶

greaterThanEqual_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

greaterThanEqual_u32 ¶

greaterThanEqual_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

greaterThanEqual_uvec2 ¶

greaterThanEqual_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

greaterThanEqual_uvec3 ¶

greaterThanEqual_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

greaterThanEqual_uvec4 ¶

greaterThanEqual_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

greaterThanEqual_vec2 ¶

greaterThanEqual_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

greaterThanEqual_vec3 ¶

greaterThanEqual_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

greaterThanEqual_vec4 ¶

greaterThanEqual_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

greaterThan_dvec2 ¶

greaterThan_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

greaterThan_dvec3 ¶

greaterThan_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

greaterThan_dvec4 ¶

greaterThan_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

greaterThan_f32 ¶

greaterThan_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

greaterThan_f64 ¶

greaterThan_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

greaterThan_i32 ¶

greaterThan_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

greaterThan_ivec2 ¶

greaterThan_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

greaterThan_ivec3 ¶

greaterThan_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

greaterThan_ivec4 ¶

greaterThan_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

greaterThan_u32 ¶

greaterThan_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

greaterThan_uvec2 ¶

greaterThan_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

greaterThan_uvec3 ¶

greaterThan_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

greaterThan_uvec4 ¶

greaterThan_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

greaterThan_vec2 ¶

greaterThan_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

greaterThan_vec3 ¶

greaterThan_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

greaterThan_vec4 ¶

greaterThan_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

identity ¶

identity :: proc "cdecl" ($M: typeid/matrix[0, 0]$) -> M {…}

inverse_dmat2 ¶

inverse_dmat2 :: proc "cdecl" (m: dmat2) -> dmat2 {…}

inverse_dmat3 ¶

inverse_dmat3 :: proc "cdecl" (m: dmat3) -> dmat3 {…}

inverse_dmat4 ¶

inverse_dmat4 :: proc "cdecl" (m: dmat4) -> dmat4 {…}

inverse_dquat ¶

inverse_dquat :: proc "cdecl" (x: dquat) -> dquat {…}

inverse_mat2 ¶

inverse_mat2 :: proc "cdecl" (m: mat2) -> mat2 {…}

inverse_mat3 ¶

inverse_mat3 :: proc "cdecl" (m: mat3) -> mat3 {…}

inverse_mat4 ¶

inverse_mat4 :: proc "cdecl" (m: mat4) -> mat4 {…}

inverse_quat ¶

inverse_quat :: proc "cdecl" (x: quat) -> quat {…}

inversesqrt_dvec2 ¶

inversesqrt_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

inversesqrt_dvec3 ¶

inversesqrt_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

inversesqrt_dvec4 ¶

inversesqrt_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

inversesqrt_f32 ¶

inversesqrt_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

inversesqrt_f64 ¶

inversesqrt_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

inversesqrt_vec2 ¶

inversesqrt_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

inversesqrt_vec3 ¶

inversesqrt_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

inversesqrt_vec4 ¶

inversesqrt_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

length_dquat ¶

length_dquat :: proc "cdecl" (x: dquat) -> f64 {…}

length_dvec2 ¶

length_dvec2 :: proc "cdecl" (x: dvec2) -> f64 {…}

length_dvec3 ¶

length_dvec3 :: proc "cdecl" (x: dvec3) -> f64 {…}

length_dvec4 ¶

length_dvec4 :: proc "cdecl" (x: dvec4) -> f64 {…}

length_f32 ¶

length_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

length_f64 ¶

length_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

length_quat ¶

length_quat :: proc "cdecl" (x: quat) -> f32 {…}

length_vec2 ¶

length_vec2 :: proc "cdecl" (x: vec2) -> f32 {…}

length_vec3 ¶

length_vec3 :: proc "cdecl" (x: vec3) -> f32 {…}

length_vec4 ¶

length_vec4 :: proc "cdecl" (x: vec4) -> f32 {…}

lerp_dvec2 ¶

lerp_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

lerp_dvec3 ¶

lerp_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

lerp_dvec4 ¶

lerp_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

lerp_f32 ¶

lerp_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

lerp_f64 ¶

lerp_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

lerp_vec2 ¶

lerp_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

lerp_vec3 ¶

lerp_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

lerp_vec4 ¶

lerp_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

lessThanEqual_dvec2 ¶

lessThanEqual_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

lessThanEqual_dvec3 ¶

lessThanEqual_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

lessThanEqual_dvec4 ¶

lessThanEqual_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

lessThanEqual_f32 ¶

lessThanEqual_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

lessThanEqual_f64 ¶

lessThanEqual_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

lessThanEqual_i32 ¶

lessThanEqual_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

lessThanEqual_ivec2 ¶

lessThanEqual_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

lessThanEqual_ivec3 ¶

lessThanEqual_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

lessThanEqual_ivec4 ¶

lessThanEqual_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

lessThanEqual_u32 ¶

lessThanEqual_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

lessThanEqual_uvec2 ¶

lessThanEqual_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

lessThanEqual_uvec3 ¶

lessThanEqual_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

lessThanEqual_uvec4 ¶

lessThanEqual_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

lessThanEqual_vec2 ¶

lessThanEqual_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

lessThanEqual_vec3 ¶

lessThanEqual_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

lessThanEqual_vec4 ¶

lessThanEqual_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

lessThan_dvec2 ¶

lessThan_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

lessThan_dvec3 ¶

lessThan_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

lessThan_dvec4 ¶

lessThan_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

lessThan_f32 ¶

lessThan_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

lessThan_f64 ¶

lessThan_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

lessThan_i32 ¶

lessThan_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

lessThan_ivec2 ¶

lessThan_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

lessThan_ivec3 ¶

lessThan_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

lessThan_ivec4 ¶

lessThan_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

lessThan_u32 ¶

lessThan_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

lessThan_uvec2 ¶

lessThan_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

lessThan_uvec3 ¶

lessThan_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

lessThan_uvec4 ¶

lessThan_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

lessThan_vec2 ¶

lessThan_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

lessThan_vec3 ¶

lessThan_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

lessThan_vec4 ¶

lessThan_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

log_dvec2 ¶

log_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

log_dvec3 ¶

log_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

log_dvec4 ¶

log_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

log_f32 ¶

log_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

log_f64 ¶

log_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

log_vec2 ¶

log_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

log_vec3 ¶

log_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

log_vec4 ¶

log_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

mat4FromQuat ¶

mat4FromQuat :: proc "cdecl" (q: quat) -> (m: mat4) {…}

mat4LookAt ¶

mat4LookAt :: proc "cdecl" (eye, centre, up: vec3) -> (m: mat4) {…}

mat4Orientation ¶

mat4Orientation :: proc "cdecl" (normal, up: vec3) -> mat4 {…}

mat4Ortho3d ¶

mat4Ortho3d :: proc "cdecl" (
	left, right, bottom, top, near, 
) -> (m: mat4) {…}

mat4Perspective ¶

mat4Perspective :: proc "cdecl" (fovy, aspect, near, far: f32) -> (m: mat4) {…}

mat4PerspectiveInfinite ¶

mat4PerspectiveInfinite :: proc "cdecl" (fovy, aspect, near: f32) -> (m: mat4) {…}

mat4Rotate ¶

mat4Rotate :: proc "cdecl" (v: vec3, radians: f32) -> (rot: mat4) {…}

mat4Scale ¶

mat4Scale :: proc "cdecl" (v: vec3) -> (m: mat4) {…}

mat4Translate ¶

mat4Translate :: proc "cdecl" (v: vec3) -> (m: mat4) {…}

max_dvec2 ¶

max_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

max_dvec3 ¶

max_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

max_dvec4 ¶

max_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

max_f32 ¶

max_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

max_f64 ¶

max_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

max_i32 ¶

max_i32 :: proc "cdecl" (x, y: i32) -> i32 {…}

max_ivec2 ¶

max_ivec2 :: proc "cdecl" (x, y: ivec2) -> ivec2 {…}

max_ivec3 ¶

max_ivec3 :: proc "cdecl" (x, y: ivec3) -> ivec3 {…}

max_ivec4 ¶

max_ivec4 :: proc "cdecl" (x, y: ivec4) -> ivec4 {…}

max_u32 ¶

max_u32 :: proc "cdecl" (x, y: u32) -> u32 {…}

max_uvec2 ¶

max_uvec2 :: proc "cdecl" (x, y: uvec2) -> uvec2 {…}

max_uvec3 ¶

max_uvec3 :: proc "cdecl" (x, y: uvec3) -> uvec3 {…}

max_uvec4 ¶

max_uvec4 :: proc "cdecl" (x, y: uvec4) -> uvec4 {…}

max_vec2 ¶

max_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

max_vec3 ¶

max_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

max_vec4 ¶

max_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

min_dvec2 ¶

min_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

min_dvec3 ¶

min_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

min_dvec4 ¶

min_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

min_f32 ¶

min_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

min_f64 ¶

min_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

min_i32 ¶

min_i32 :: proc "cdecl" (x, y: i32) -> i32 {…}

min_ivec2 ¶

min_ivec2 :: proc "cdecl" (x, y: ivec2) -> ivec2 {…}

min_ivec3 ¶

min_ivec3 :: proc "cdecl" (x, y: ivec3) -> ivec3 {…}

min_ivec4 ¶

min_ivec4 :: proc "cdecl" (x, y: ivec4) -> ivec4 {…}

min_u32 ¶

min_u32 :: proc "cdecl" (x, y: u32) -> u32 {…}

min_uvec2 ¶

min_uvec2 :: proc "cdecl" (x, y: uvec2) -> uvec2 {…}

min_uvec3 ¶

min_uvec3 :: proc "cdecl" (x, y: uvec3) -> uvec3 {…}

min_uvec4 ¶

min_uvec4 :: proc "cdecl" (x, y: uvec4) -> uvec4 {…}

min_vec2 ¶

min_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

min_vec3 ¶

min_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

min_vec4 ¶

min_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

mix_dvec2 ¶

mix_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

mix_dvec3 ¶

mix_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

mix_dvec4 ¶

mix_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

mix_f32 ¶

mix_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

mix_f64 ¶

mix_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

mix_vec2 ¶

mix_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

mix_vec3 ¶

mix_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

mix_vec4 ¶

mix_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

mod_dvec2 ¶

mod_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

mod_dvec3 ¶

mod_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

mod_dvec4 ¶

mod_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

mod_f32 ¶

mod_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

mod_f64 ¶

mod_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

mod_vec2 ¶

mod_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

mod_vec3 ¶

mod_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

mod_vec4 ¶

mod_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

normalize_dquat ¶

normalize_dquat :: proc "cdecl" (x: dquat) -> dquat {…}

normalize_dvec2 ¶

normalize_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

normalize_dvec3 ¶

normalize_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

normalize_dvec4 ¶

normalize_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

normalize_f32 ¶

normalize_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

normalize_f64 ¶

normalize_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

normalize_quat ¶

normalize_quat :: proc "cdecl" (x: quat) -> quat {…}

normalize_vec2 ¶

normalize_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

normalize_vec3 ¶

normalize_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

normalize_vec4 ¶

normalize_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

notEqual_dvec2 ¶

notEqual_dvec2 :: proc "cdecl" (a, b: dvec2) -> bvec2 {…}

notEqual_dvec3 ¶

notEqual_dvec3 :: proc "cdecl" (a, b: dvec3) -> bvec3 {…}

notEqual_dvec4 ¶

notEqual_dvec4 :: proc "cdecl" (a, b: dvec4) -> bvec4 {…}

notEqual_f32 ¶

notEqual_f32 :: proc "cdecl" (a, b: f32) -> bool {…}

notEqual_f64 ¶

notEqual_f64 :: proc "cdecl" (a, b: f64) -> bool {…}

notEqual_i32 ¶

notEqual_i32 :: proc "cdecl" (a, b: i32) -> bool {…}

notEqual_ivec2 ¶

notEqual_ivec2 :: proc "cdecl" (a, b: ivec2) -> bvec2 {…}

notEqual_ivec3 ¶

notEqual_ivec3 :: proc "cdecl" (a, b: ivec3) -> bvec3 {…}

notEqual_ivec4 ¶

notEqual_ivec4 :: proc "cdecl" (a, b: ivec4) -> bvec4 {…}

notEqual_u32 ¶

notEqual_u32 :: proc "cdecl" (a, b: u32) -> bool {…}

notEqual_uvec2 ¶

notEqual_uvec2 :: proc "cdecl" (a, b: uvec2) -> bvec2 {…}

notEqual_uvec3 ¶

notEqual_uvec3 :: proc "cdecl" (a, b: uvec3) -> bvec3 {…}

notEqual_uvec4 ¶

notEqual_uvec4 :: proc "cdecl" (a, b: uvec4) -> bvec4 {…}

notEqual_vec2 ¶

notEqual_vec2 :: proc "cdecl" (a, b: vec2) -> bvec2 {…}

notEqual_vec3 ¶

notEqual_vec3 :: proc "cdecl" (a, b: vec3) -> bvec3 {…}

notEqual_vec4 ¶

notEqual_vec4 :: proc "cdecl" (a, b: vec4) -> bvec4 {…}

not_bool ¶

not_bool :: proc "cdecl" (v: bool) -> bool {…}

not_bvec2 ¶

not_bvec2 :: proc "cdecl" (v: bvec2) -> bvec2 {…}

not_bvec3 ¶

not_bvec3 :: proc "cdecl" (v: bvec3) -> bvec3 {…}

not_bvec4 ¶

not_bvec4 :: proc "cdecl" (v: bvec4) -> bvec4 {…}

pow_dvec2 ¶

pow_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

pow_dvec3 ¶

pow_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

pow_dvec4 ¶

pow_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

pow_f32 ¶

pow_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

pow_f64 ¶

pow_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

pow_vec2 ¶

pow_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

pow_vec3 ¶

pow_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

pow_vec4 ¶

pow_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

quatAxisAngle ¶

quatAxisAngle :: proc "cdecl" (axis: vec3, radians: f32) -> (q: quat) {…}

quatFromMat3 ¶

quatFromMat3 :: proc "cdecl" (m: mat3) -> (q: quat) {…}

quatFromMat4 ¶

quatFromMat4 :: proc "cdecl" (m: mat4) -> (q: quat) {…}

quatMulVec3 ¶

quatMulVec3 :: proc "cdecl" (q: quat, v: vec3) -> vec3 {…}

quatNlerp ¶

quatNlerp :: proc "cdecl" (a, b: quat, t: f32) -> (c: quat) {…}

quatSlerp ¶

quatSlerp :: proc "cdecl" (a, b: quat, t: f32) -> (c: quat) {…}

radians_dvec2 ¶

radians_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

radians_dvec3 ¶

radians_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

radians_dvec4 ¶

radians_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

radians_f32 ¶

radians_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

radians_f64 ¶

radians_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

radians_vec2 ¶

radians_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

radians_vec3 ¶

radians_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

radians_vec4 ¶

radians_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

reflect_dvec2 ¶

reflect_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

reflect_dvec3 ¶

reflect_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

reflect_dvec4 ¶

reflect_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

reflect_f32 ¶

reflect_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

reflect_f64 ¶

reflect_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

reflect_vec2 ¶

reflect_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

reflect_vec3 ¶

reflect_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

reflect_vec4 ¶

reflect_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

refract_dvec2 ¶

refract_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

refract_dvec3 ¶

refract_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

refract_dvec4 ¶

refract_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

refract_f32 ¶

refract_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

refract_f64 ¶

refract_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

refract_vec2 ¶

refract_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

refract_vec3 ¶

refract_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

refract_vec4 ¶

refract_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

round_dvec2 ¶

round_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

round_dvec3 ¶

round_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

round_dvec4 ¶

round_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

round_f32 ¶

round_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

round_f64 ¶

round_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

round_vec2 ¶

round_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

round_vec3 ¶

round_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

round_vec4 ¶

round_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

saturate_dvec2 ¶

saturate_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

saturate_dvec3 ¶

saturate_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

saturate_dvec4 ¶

saturate_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

saturate_f32 ¶

saturate_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

saturate_f64 ¶

saturate_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

saturate_i32 ¶

saturate_i32 :: proc "cdecl" (key: i32) -> i32 {…}

saturate_ivec2 ¶

saturate_ivec2 :: proc "cdecl" (x: ivec2) -> ivec2 {…}

saturate_ivec3 ¶

saturate_ivec3 :: proc "cdecl" (x: ivec3) -> ivec3 {…}

saturate_ivec4 ¶

saturate_ivec4 :: proc "cdecl" (x: ivec4) -> ivec4 {…}

saturate_u32 ¶

saturate_u32 :: proc "cdecl" (x: u32) -> u32 {…}

saturate_uvec2 ¶

saturate_uvec2 :: proc "cdecl" (x: uvec2) -> uvec2 {…}

saturate_uvec3 ¶

saturate_uvec3 :: proc "cdecl" (x: uvec3) -> uvec3 {…}

saturate_uvec4 ¶

saturate_uvec4 :: proc "cdecl" (x: uvec4) -> uvec4 {…}

saturate_vec2 ¶

saturate_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

saturate_vec3 ¶

saturate_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

saturate_vec4 ¶

saturate_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

scalarTripleProduct_dvec3 ¶

scalarTripleProduct_dvec3 :: proc "cdecl" (a, b, c: dvec3) -> f64 {…}

scalarTripleProduct_ivec3 ¶

scalarTripleProduct_ivec3 :: proc "cdecl" (a, b, c: ivec3) -> i32 {…}

scalarTripleProduct_vec3 ¶

scalarTripleProduct_vec3 :: proc "cdecl" (a, b, c: vec3) -> f32 {…}

sign_dvec2 ¶

sign_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

sign_dvec3 ¶

sign_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

sign_dvec4 ¶

sign_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

sign_f32 ¶

sign_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

sign_f64 ¶

sign_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

sign_i32 ¶

sign_i32 :: proc "cdecl" (key: i32) -> i32 {…}

sign_ivec2 ¶

sign_ivec2 :: proc "cdecl" (x: ivec2) -> ivec2 {…}

sign_ivec3 ¶

sign_ivec3 :: proc "cdecl" (x: ivec3) -> ivec3 {…}

sign_ivec4 ¶

sign_ivec4 :: proc "cdecl" (x: ivec4) -> ivec4 {…}

sign_u32 ¶

sign_u32 :: proc "cdecl" (x: u32) -> u32 {…}

sign_uvec2 ¶

sign_uvec2 :: proc "cdecl" (x: uvec2) -> uvec2 {…}

sign_uvec3 ¶

sign_uvec3 :: proc "cdecl" (x: uvec3) -> uvec3 {…}

sign_uvec4 ¶

sign_uvec4 :: proc "cdecl" (x: uvec4) -> uvec4 {…}

sign_vec2 ¶

sign_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

sign_vec3 ¶

sign_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

sign_vec4 ¶

sign_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

sin_dvec2 ¶

sin_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

sin_dvec3 ¶

sin_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

sin_dvec4 ¶

sin_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

sin_f32 ¶

sin_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

sin_f64 ¶

sin_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

sin_vec2 ¶

sin_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

sin_vec3 ¶

sin_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

sin_vec4 ¶

sin_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

sinh_dvec2 ¶

sinh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

sinh_dvec3 ¶

sinh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

sinh_dvec4 ¶

sinh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

sinh_f32 ¶

sinh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

sinh_f64 ¶

sinh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

sinh_vec2 ¶

sinh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

sinh_vec3 ¶

sinh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

sinh_vec4 ¶

sinh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

smoothstep_dvec2 ¶

smoothstep_dvec2 :: proc "cdecl" (x, y, z: dvec2) -> dvec2 {…}

smoothstep_dvec3 ¶

smoothstep_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

smoothstep_dvec4 ¶

smoothstep_dvec4 :: proc "cdecl" (x, y, z: dvec4) -> dvec4 {…}

smoothstep_f32 ¶

smoothstep_f32 :: proc "cdecl" (x, y, z: f32) -> f32 {…}

smoothstep_f64 ¶

smoothstep_f64 :: proc "cdecl" (x, y, z: f64) -> f64 {…}

smoothstep_vec2 ¶

smoothstep_vec2 :: proc "cdecl" (x, y, z: vec2) -> vec2 {…}

smoothstep_vec3 ¶

smoothstep_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

smoothstep_vec4 ¶

smoothstep_vec4 :: proc "cdecl" (x, y, z: vec4) -> vec4 {…}

sqrt_dvec2 ¶

sqrt_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

sqrt_dvec3 ¶

sqrt_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

sqrt_dvec4 ¶

sqrt_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

sqrt_f32 ¶

sqrt_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

sqrt_f64 ¶

sqrt_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

sqrt_vec2 ¶

sqrt_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

sqrt_vec3 ¶

sqrt_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

sqrt_vec4 ¶

sqrt_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

step_dvec2 ¶

step_dvec2 :: proc "cdecl" (y, x: dvec2) -> dvec2 {…}

step_dvec3 ¶

step_dvec3 :: proc "cdecl" (y, x: dvec3) -> dvec3 {…}

step_dvec4 ¶

step_dvec4 :: proc "cdecl" (y, x: dvec4) -> dvec4 {…}

step_f32 ¶

step_f32 :: proc "cdecl" (x, y: f32) -> f32 {…}

step_f64 ¶

step_f64 :: proc "cdecl" (x, y: f64) -> f64 {…}

step_vec2 ¶

step_vec2 :: proc "cdecl" (y, x: vec2) -> vec2 {…}

step_vec3 ¶

step_vec3 :: proc "cdecl" (y, x: vec3) -> vec3 {…}

step_vec4 ¶

step_vec4 :: proc "cdecl" (y, x: vec4) -> vec4 {…}

tan_dvec2 ¶

tan_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

tan_dvec3 ¶

tan_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

tan_dvec4 ¶

tan_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

tan_f32 ¶

tan_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

tan_f64 ¶

tan_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

tan_vec2 ¶

tan_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

tan_vec3 ¶

tan_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

tan_vec4 ¶

tan_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

tanh_dvec2 ¶

tanh_dvec2 :: proc "cdecl" (x: dvec2) -> dvec2 {…}

tanh_dvec3 ¶

tanh_dvec3 :: proc "cdecl" (x: dvec3) -> dvec3 {…}

tanh_dvec4 ¶

tanh_dvec4 :: proc "cdecl" (x: dvec4) -> dvec4 {…}

tanh_f32 ¶

tanh_f32 :: proc "cdecl" (degrees: f32) -> f32 {…}

tanh_f64 ¶

tanh_f64 :: proc "cdecl" (degrees: f64) -> f64 {…}

tanh_vec2 ¶

tanh_vec2 :: proc "cdecl" (x: vec2) -> vec2 {…}

tanh_vec3 ¶

tanh_vec3 :: proc "cdecl" (x: vec3) -> vec3 {…}

tanh_vec4 ¶

tanh_vec4 :: proc "cdecl" (x: vec4) -> vec4 {…}

transpose ¶

transpose :: builtin.transpose

vectorTripleProduct_dvec3 ¶

vectorTripleProduct_dvec3 :: proc "cdecl" (x, y, z: dvec3) -> dvec3 {…}

vectorTripleProduct_ivec3 ¶

vectorTripleProduct_ivec3 :: proc "cdecl" (x, y, z: ivec3) -> ivec3 {…}

vectorTripleProduct_vec3 ¶

vectorTripleProduct_vec3 :: proc "cdecl" (x, y, z: vec3) -> vec3 {…}

Procedure Groups

adjugate ¶

adjugate :: proc{
	runtime.matrix1x1_adjugate,
	runtime.matrix2x2_adjugate,
	runtime.matrix3x3_adjugate,
	runtime.matrix4x4_adjugate,
}

nlerp ¶

nlerp :: proc{
	quatNlerp,
	dquatNlerp,
}

slerp ¶

slerp :: proc{
	quatSlerp,
	dquatSlerp,
}

Source Files

Generation Information

Generated with odin version dev-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.429921100 +0000 UTC