package core:math/linalg/glsl

Source

bvec2 :: distinct [2]bool

bvec3 :: distinct [3]bool

bvec4 :: distinct [4]bool

dmat2 :: distinct matrix[2, 2]f64

dmat2x2 :: dmat2

dmat2x3 :: distinct matrix[3, 2]f64

dmat2x4 :: distinct matrix[4, 2]f64

dmat3 :: distinct matrix[3, 3]f64

dmat3x2 :: distinct matrix[2, 3]f64

dmat3x3 :: dmat3

dmat3x4 :: distinct matrix[4, 3]f64

dmat4 :: distinct matrix[4, 4]f64

dmat4x2 :: distinct matrix[2, 4]f64

dmat4x3 :: distinct matrix[3, 4]f64

dmat4x4 :: dmat4

dquat :: distinct quaternion256

dvec2 :: distinct [2]f64

dvec3 :: distinct [3]f64

dvec4 :: distinct [4]f64

ivec2 :: distinct [2]i32

ivec3 :: distinct [3]i32

ivec4 :: distinct [4]i32

mat2 :: distinct matrix[2, 2]f32

mat2x2 :: mat2

mat2x3 :: distinct matrix[3, 2]f32

mat2x4 :: distinct matrix[4, 2]f32

mat3 :: distinct matrix[3, 3]f32

mat3x2 :: distinct matrix[2, 3]f32

mat3x3 :: mat3

mat3x4 :: distinct matrix[4, 3]f32

mat4 :: distinct matrix[4, 4]f32

mat4x2 :: distinct matrix[2, 4]f32

mat4x3 :: distinct matrix[3, 4]f32

mat4x4 :: mat4

quat :: distinct quaternion128

uvec2 :: distinct [2]u32

uvec3 :: distinct [3]u32

uvec4 :: distinct [4]u32

vec2 :: distinct [2]f32

vec3 :: distinct [3]f32

vec4 :: distinct [4]f32

E :: 2.71828182845904523536

F32_EPSILON :: 1e-7

F64_EPSILON :: 1e-15

LN10 :: 2.30258509299404568401799145468436421

LN2 :: 0.693147180559945309417232121458176568

PI :: 3.14159265358979323846264338327950288

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU :: 6.28318530717958647692528676655900576

e :: E

π :: PI

τ :: TAU

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

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

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

abs_f32 :: proc "c" (x: f32) -> f32 {…}

abs_f64 :: proc "c" (x: f64) -> f64 {…}

abs_i32 :: proc "c" (x: i32) -> i32 {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

acos_f32 :: proc "c" (x: f32) -> f32 {…}

acos_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

acosh_f32 :: proc "c" (x: f32) -> f32 {…}

acosh_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

adjugate_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

adjugate_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

adjugate_matrix3x3 :: proc "contextless" (m: $A/matrix[3, 3]$T) -> (y: $A/matrix[3, 3]$T) {…}

adjugate_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: $M/matrix[4, 4]$T) {…}

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

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

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

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

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

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

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

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

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

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

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

asin_f32 :: proc "c" (x: f32) -> f32 {…}

asin_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

asinh_f32 :: proc "c" (x: f32) -> f32 {…}

asinh_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

atan_f32 :: proc "c" (x: f32) -> f32 {…}

atan_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

atanh_f32 :: proc "c" (x: f32) -> f32 {…}

atanh_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

ceil_f32 :: proc "c" (x: f32) -> f32 {…}

ceil_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cos_f32 :: proc "c" (x: f32) -> f32 {…}

cos_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

cosh_f32 :: proc "c" (x: f32) -> f32 {…}

cosh_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

cross_dvec3 :: proc "c" (a, b: dvec3) -> (c: dvec3) {…}

cross_ivec3 :: proc "c" (a, b: ivec3) -> (c: ivec3) {…}

cross_vec3 :: proc "c" (a, b: vec3) -> (c: vec3) {…}

degrees_dvec2 :: proc "c" (radians: dvec2) -> dvec2 {…}

degrees_dvec3 :: proc "c" (radians: dvec3) -> dvec3 {…}

degrees_dvec4 :: proc "c" (radians: dvec4) -> dvec4 {…}

degrees_f32 :: proc "c" (radians: f32) -> f32 {…}

degrees_f64 :: proc "c" (radians: f64) -> f64 {…}

degrees_vec2 :: proc "c" (radians: vec2) -> vec2 {…}

degrees_vec3 :: proc "c" (radians: vec3) -> vec3 {…}

degrees_vec4 :: proc "c" (radians: vec4) -> vec4 {…}

determinant_matrix1x1 :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: $T) {…}

determinant_matrix2x2 :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: $T) {…}

determinant_matrix3x3 :: proc "contextless" (m: $A/matrix[3, 3]$T) -> (det: $T) {…}

determinant_matrix4x4 :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: $T) {…}

distance_dvec2 :: proc "c" (x, y: dvec2) -> f64 {…}

distance_dvec3 :: proc "c" (x, y: dvec3) -> f64 {…}

distance_dvec4 :: proc "c" (x, y: dvec4) -> f64 {…}

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

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

distance_vec2 :: proc "c" (x, y: vec2) -> f32 {…}

distance_vec3 :: proc "c" (x, y: vec3) -> f32 {…}

distance_vec4 :: proc "c" (x, y: vec4) -> f32 {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

dot_f32 :: proc "c" (a, b: f32) -> f32 {…}

dot_f64 :: proc "c" (a, b: f64) -> f64 {…}

dot_i32 :: proc "c" (a, b: i32) -> i32 {…}

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

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

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

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

dot_u32 :: proc "c" (a, b: u32) -> u32 {…}

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

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

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

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

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

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

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

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

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

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

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

dquatSlerp :: proc "c" (x, y: dquat, t: f64) -> (q: dquat) {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

exp2_f32 :: proc "c" (x: f32) -> f32 {…}

exp2_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

exp_f32 :: proc "c" (x: f32) -> f32 {…}

exp_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

faceForward_dvec2 :: proc "c" (N, I, Nref: dvec2) -> dvec2 {…}

faceForward_dvec3 :: proc "c" (N, I, Nref: dvec3) -> dvec3 {…}

faceForward_dvec4 :: proc "c" (N, I, Nref: dvec4) -> dvec4 {…}

faceForward_f32 :: proc "c" (N, I, Nref: f32) -> f32 {…}

faceForward_f64 :: proc "c" (N, I, Nref: f64) -> f64 {…}

faceForward_vec2 :: proc "c" (N, I, Nref: vec2) -> vec2 {…}

faceForward_vec3 :: proc "c" (N, I, Nref: vec3) -> vec3 {…}

faceForward_vec4 :: proc "c" (N, I, Nref: vec4) -> vec4 {…}

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

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

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

floor_f32 :: proc "c" (x: f32) -> f32 {…}

floor_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

fract_f32 :: proc "c" (x: f32) -> f32 {…}

fract_f64 :: proc "c" (x: f64) -> f64 {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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