package core:math/linalg/glsl
Source

Overview

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

Index

Types (41)

Constants (13)

E
F32_EPSILON
F64_EPSILON
LN10
LN2
PI
SQRT_FIVE
SQRT_THREE
SQRT_TWO
TAU
e
π
τ

Variables (0)

This section is empty.

Procedures (563)

Procedure Groups (62)

Types

bvec2 ¶
Source

bvec2 :: distinct [2]bool

bvec3 ¶
Source

bvec3 :: distinct [3]bool

bvec4 ¶
Source

bvec4 :: distinct [4]bool

dmat2 ¶
Source

dmat2 :: distinct matrix[2, 2]f64

dmat2x2 ¶
Source

dmat2x2 :: dmat2

dmat2x3 ¶
Source

dmat2x3 :: distinct matrix[3, 2]f64

dmat2x4 ¶
Source

dmat2x4 :: distinct matrix[4, 2]f64

dmat3 ¶
Source

dmat3 :: distinct matrix[3, 3]f64

dmat3x2 ¶
Source

dmat3x2 :: distinct matrix[2, 3]f64

dmat3x3 ¶
Source

dmat3x3 :: dmat3

dmat3x4 ¶
Source

dmat3x4 :: distinct matrix[4, 3]f64

dmat4 ¶
Source

dmat4 :: distinct matrix[4, 4]f64

dmat4x2 ¶
Source

dmat4x2 :: distinct matrix[2, 4]f64

dmat4x3 ¶
Source

dmat4x3 :: distinct matrix[3, 4]f64

dmat4x4 ¶
Source

dmat4x4 :: dmat4

dquat ¶
Source

dquat :: distinct quaternion256

dvec2 ¶
Source

dvec2 :: distinct [2]f64

dvec3 ¶
Source

dvec3 :: distinct [3]f64

dvec4 ¶
Source

dvec4 :: distinct [4]f64

ivec2 ¶
Source

ivec2 :: distinct [2]i32

ivec3 ¶
Source

ivec3 :: distinct [3]i32

ivec4 ¶
Source

ivec4 :: distinct [4]i32

mat2 ¶
Source

mat2 :: distinct matrix[2, 2]f32

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

mat2x2 ¶
Source

mat2x2 :: mat2

mat2x3 ¶
Source

mat2x3 :: distinct matrix[3, 2]f32

mat2x4 ¶
Source

mat2x4 :: distinct matrix[4, 2]f32

mat3 ¶
Source

mat3 :: distinct matrix[3, 3]f32

mat3x2 ¶
Source

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

mat3x3 ¶
Source

mat3x3 :: mat3

mat3x4 ¶
Source

mat3x4 :: distinct matrix[4, 3]f32

mat4 ¶
Source

mat4 :: distinct matrix[4, 4]f32

mat4x2 ¶
Source

mat4x2 :: distinct matrix[2, 4]f32

mat4x3 ¶
Source

mat4x3 :: distinct matrix[3, 4]f32

mat4x4 ¶
Source

mat4x4 :: mat4

quat ¶
Source

quat :: distinct quaternion128

uvec2 ¶
Source

uvec2 :: distinct [2]u32

uvec3 ¶
Source

uvec3 :: distinct [3]u32

uvec4 ¶
Source

uvec4 :: distinct [4]u32

vec2 ¶
Source

vec2 :: distinct [2]f32

vec3 ¶
Source

vec3 :: distinct [3]f32

vec4 ¶
Source

vec4 :: distinct [4]f32

Constants

E ¶
Source

E :: 2.71828182845904523536

F32_EPSILON ¶
Source

F32_EPSILON :: 1e-7

F64_EPSILON ¶
Source

F64_EPSILON :: 1e-15

LN10 ¶
Source

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶
Source

LN2 :: 0.693147180559945309417232121458176568

PI ¶
Source

PI :: 3.14159265358979323846264338327950288

SQRT_FIVE ¶
Source

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE ¶
Source

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO ¶
Source

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU ¶
Source

TAU :: 6.28318530717958647692528676655900576

e ¶
Source

e :: E

π ¶
Source

π :: PI

τ ¶
Source

τ :: TAU

Variables

This section is empty.

Procedures

abs_dvec2 ¶
Source

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

abs_dvec3 ¶
Source

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

abs_dvec4 ¶
Source

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

abs_f32 ¶
Source

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

abs_f64 ¶
Source

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

abs_i32 ¶
Source

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

abs_ivec2 ¶
Source

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

abs_ivec3 ¶
Source

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

abs_ivec4 ¶
Source

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

abs_u32 ¶
Source

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

abs_uvec2 ¶
Source

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

abs_uvec3 ¶
Source

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

abs_uvec4 ¶
Source

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

abs_vec2 ¶
Source

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

abs_vec3 ¶
Source

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

abs_vec4 ¶
Source

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

acos_dvec2 ¶
Source

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

acos_dvec3 ¶
Source

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

acos_dvec4 ¶
Source

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

acos_f32 ¶
Source

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

acos_f64 ¶
Source

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

acos_vec2 ¶
Source

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

acos_vec3 ¶
Source

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

acos_vec4 ¶
Source

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

acosh_dvec2 ¶
Source

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

acosh_dvec3 ¶
Source

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

acosh_dvec4 ¶
Source

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

acosh_f32 ¶
Source

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

acosh_f64 ¶
Source

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

acosh_vec2 ¶
Source

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

acosh_vec3 ¶
Source

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

acosh_vec4 ¶
Source

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

all_bool ¶
Source

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

all_bvec2 ¶
Source

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

all_bvec3 ¶
Source

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

all_bvec4 ¶
Source

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

any_bool ¶
Source

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

any_bvec2 ¶
Source

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

any_bvec3 ¶
Source

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

any_bvec4 ¶
Source

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

asin_dvec2 ¶
Source

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

asin_dvec3 ¶
Source

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

asin_dvec4 ¶
Source

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

asin_f32 ¶
Source

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

asin_f64 ¶
Source

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

asin_vec2 ¶
Source

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

asin_vec3 ¶
Source

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

asin_vec4 ¶
Source

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

asinh_dvec2 ¶
Source

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

asinh_dvec3 ¶
Source

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

asinh_dvec4 ¶
Source

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

asinh_f32 ¶
Source

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

asinh_f64 ¶
Source

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

asinh_vec2 ¶
Source

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

asinh_vec3 ¶
Source

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

asinh_vec4 ¶
Source

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

atan2_dvec2 ¶
Source

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

atan2_dvec3 ¶
Source

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

atan2_dvec4 ¶
Source

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

atan2_f32 ¶
Source

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

atan2_f64 ¶
Source

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

atan2_vec2 ¶
Source

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

atan2_vec3 ¶
Source

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

atan2_vec4 ¶
Source

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

atan_dvec2 ¶
Source

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

atan_dvec3 ¶
Source

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

atan_dvec4 ¶
Source

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

atan_f32 ¶
Source

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

atan_f64 ¶
Source

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

atan_vec2 ¶
Source

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

atan_vec3 ¶
Source

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

atan_vec4 ¶
Source

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

atanh_dvec2 ¶
Source

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

atanh_dvec3 ¶
Source

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

atanh_dvec4 ¶
Source

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

atanh_f32 ¶
Source

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

atanh_f64 ¶
Source

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

atanh_vec2 ¶
Source

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

atanh_vec3 ¶
Source

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

atanh_vec4 ¶
Source

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

ceil_dvec2 ¶
Source

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

ceil_dvec3 ¶
Source

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

ceil_dvec4 ¶
Source

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

ceil_f32 ¶
Source

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

ceil_f64 ¶
Source

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

ceil_vec2 ¶
Source

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

ceil_vec3 ¶
Source

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

ceil_vec4 ¶
Source

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

clamp_dvec2 ¶
Source

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

clamp_dvec3 ¶
Source

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

clamp_dvec4 ¶
Source

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

clamp_f32 ¶
Source

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

clamp_f64 ¶
Source

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

clamp_i32 ¶
Source

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

clamp_ivec2 ¶
Source

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

clamp_ivec3 ¶
Source

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

clamp_ivec4 ¶
Source

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

clamp_u32 ¶
Source

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

clamp_uvec2 ¶
Source

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

clamp_uvec3 ¶
Source

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

clamp_uvec4 ¶
Source

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

clamp_vec2 ¶
Source

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

clamp_vec3 ¶
Source

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

clamp_vec4 ¶
Source

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

cos_dvec2 ¶
Source

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

cos_dvec3 ¶
Source

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

cos_dvec4 ¶
Source

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

cos_f32 ¶
Source

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

cos_f64 ¶
Source

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

cos_vec2 ¶
Source

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

cos_vec3 ¶
Source

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

cos_vec4 ¶
Source

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

cosh_dvec2 ¶
Source

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

cosh_dvec3 ¶
Source

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

cosh_dvec4 ¶
Source

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

cosh_f32 ¶
Source

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

cosh_f64 ¶
Source

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

cosh_vec2 ¶
Source

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

cosh_vec3 ¶
Source

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

cosh_vec4 ¶
Source

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

cross_dvec3 ¶
Source

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

cross_ivec3 ¶
Source

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

cross_vec3 ¶
Source

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

degrees_dvec2 ¶
Source

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

degrees_dvec3 ¶
Source

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

degrees_dvec4 ¶
Source

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

degrees_f32 ¶
Source

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

degrees_f64 ¶
Source

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

degrees_vec2 ¶
Source

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

degrees_vec3 ¶
Source

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

degrees_vec4 ¶
Source

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

distance_dvec2 ¶
Source

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

distance_dvec3 ¶
Source

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

distance_dvec4 ¶
Source

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

distance_f32 ¶
Source

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

distance_f64 ¶
Source

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

distance_vec2 ¶
Source

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

distance_vec3 ¶
Source

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

distance_vec4 ¶
Source

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

dmat4FromDquat ¶
Source

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

dmat4LookAt ¶
Source

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

dmat4Orientation ¶
Source

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

dmat4Ortho3d ¶
Source

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

dmat4Perspective ¶
Source

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

dmat4PerspectiveInfinite ¶
Source

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

dmat4Rotate ¶
Source

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

dmat4Scale ¶
Source

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

dmat4Translate ¶
Source

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

dot_dquat ¶
Source

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

dot_dvec2 ¶
Source

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

dot_dvec3 ¶
Source

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

dot_dvec4 ¶
Source

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

dot_f32 ¶
Source

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

dot_f64 ¶
Source

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

dot_i32 ¶
Source

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

dot_ivec2 ¶
Source

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

dot_ivec3 ¶
Source

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

dot_ivec4 ¶
Source

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

dot_quat ¶
Source

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

dot_u32 ¶
Source

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

dot_uvec2 ¶
Source

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

dot_uvec3 ¶
Source

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

dot_uvec4 ¶
Source

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

dot_vec2 ¶
Source

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

dot_vec3 ¶
Source

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

dot_vec4 ¶
Source

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

dquatAxisAngle ¶
Source

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

dquatFromDmat4 ¶
Source

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

dquatFromdMat3 ¶
Source

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

dquatMulDvec3 ¶
Source

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

dquatNlerp ¶
Source

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

dquatSlerp ¶
Source

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

equal_dvec2 ¶
Source

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

equal_dvec3 ¶
Source

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

equal_dvec4 ¶
Source

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

equal_f32 ¶
Source

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

equal_f64 ¶
Source

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

equal_i32 ¶
Source

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

equal_ivec2 ¶
Source

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

equal_ivec3 ¶
Source

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

equal_ivec4 ¶
Source

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

equal_u32 ¶
Source

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

equal_uvec2 ¶
Source

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

equal_uvec3 ¶
Source

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

equal_uvec4 ¶
Source

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

equal_vec2 ¶
Source

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

equal_vec3 ¶
Source

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

equal_vec4 ¶
Source

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

exp2_dvec2 ¶
Source

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

exp2_dvec3 ¶
Source

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

exp2_dvec4 ¶
Source

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

exp2_f32 ¶
Source

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

exp2_f64 ¶
Source

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

exp2_vec2 ¶
Source

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

exp2_vec3 ¶
Source

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

exp2_vec4 ¶
Source

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

exp_dvec2 ¶
Source

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

exp_dvec3 ¶
Source

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

exp_dvec4 ¶
Source

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

exp_f32 ¶
Source

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

exp_f64 ¶
Source

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

exp_vec2 ¶
Source

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

exp_vec3 ¶
Source

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

exp_vec4 ¶
Source

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

faceForward_dvec2 ¶
Source

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

faceForward_dvec3 ¶
Source

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

faceForward_dvec4 ¶
Source

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

faceForward_f32 ¶
Source

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

faceForward_f64 ¶
Source

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

faceForward_vec2 ¶
Source

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

faceForward_vec3 ¶
Source

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

faceForward_vec4 ¶
Source

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

floor_dvec2 ¶
Source

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

floor_dvec3 ¶
Source

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

floor_dvec4 ¶
Source

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

floor_f32 ¶
Source

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

floor_f64 ¶
Source

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

floor_vec2 ¶
Source

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

floor_vec3 ¶
Source

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

floor_vec4 ¶
Source

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

fract_dvec2 ¶
Source

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

fract_dvec3 ¶
Source

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

fract_dvec4 ¶
Source

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

fract_f32 ¶
Source

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

fract_f64 ¶
Source

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

fract_vec2 ¶
Source

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

fract_vec3 ¶
Source

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

fract_vec4 ¶
Source

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

greaterThanEqual_dvec2 ¶
Source

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

greaterThanEqual_dvec3 ¶
Source

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

greaterThanEqual_dvec4 ¶
Source

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

greaterThanEqual_f32 ¶
Source

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

greaterThanEqual_f64 ¶
Source

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

greaterThanEqual_i32 ¶
Source

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

greaterThanEqual_ivec2 ¶
Source

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

greaterThanEqual_ivec3 ¶
Source

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

greaterThanEqual_ivec4 ¶
Source

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

greaterThanEqual_u32 ¶
Source

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

greaterThanEqual_uvec2 ¶
Source

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

greaterThanEqual_uvec3 ¶
Source

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

greaterThanEqual_uvec4 ¶
Source

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

greaterThanEqual_vec2 ¶
Source

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

greaterThanEqual_vec3 ¶
Source

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

greaterThanEqual_vec4 ¶
Source

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

greaterThan_dvec2 ¶
Source

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

greaterThan_dvec3 ¶
Source

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

greaterThan_dvec4 ¶
Source

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

greaterThan_f32 ¶
Source

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

greaterThan_f64 ¶
Source

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

greaterThan_i32 ¶
Source

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

greaterThan_ivec2 ¶
Source

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

greaterThan_ivec3 ¶
Source

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

greaterThan_ivec4 ¶
Source

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

greaterThan_u32 ¶
Source

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

greaterThan_uvec2 ¶
Source

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

greaterThan_uvec3 ¶
Source

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

greaterThan_uvec4 ¶
Source

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

greaterThan_vec2 ¶
Source

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

greaterThan_vec3 ¶
Source

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

greaterThan_vec4 ¶
Source

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

identity ¶
Source

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

inverse_dmat2 ¶
Source

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

inverse_dmat3 ¶
Source

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

inverse_dmat4 ¶
Source

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

inverse_dquat ¶
Source

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

inverse_mat2 ¶
Source

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

inverse_mat3 ¶
Source

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

inverse_mat4 ¶
Source

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

inverse_quat ¶
Source

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

inversesqrt_dvec2 ¶
Source

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

inversesqrt_dvec3 ¶
Source

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

inversesqrt_dvec4 ¶
Source

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

inversesqrt_f32 ¶
Source

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

inversesqrt_f64 ¶
Source

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

inversesqrt_vec2 ¶
Source

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

inversesqrt_vec3 ¶
Source

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

inversesqrt_vec4 ¶
Source

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

length_dquat ¶
Source

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

length_dvec2 ¶
Source

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

length_dvec3 ¶
Source

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

length_dvec4 ¶
Source

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

length_f32 ¶
Source

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

length_f64 ¶
Source

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

length_quat ¶
Source

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

length_vec2 ¶
Source

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

length_vec3 ¶
Source

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

length_vec4 ¶
Source

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

lerp_dvec2 ¶
Source

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

lerp_dvec3 ¶
Source

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

lerp_dvec4 ¶
Source

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

lerp_f32 ¶
Source

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

lerp_f64 ¶
Source

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

lerp_vec2 ¶
Source

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

lerp_vec3 ¶
Source

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

lerp_vec4 ¶
Source

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

lessThanEqual_dvec2 ¶
Source

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

lessThanEqual_dvec3 ¶
Source

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

lessThanEqual_dvec4 ¶
Source

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

lessThanEqual_f32 ¶
Source

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

lessThanEqual_f64 ¶
Source

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

lessThanEqual_i32 ¶
Source

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

lessThanEqual_ivec2 ¶
Source

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

lessThanEqual_ivec3 ¶
Source

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

lessThanEqual_ivec4 ¶
Source

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

lessThanEqual_u32 ¶
Source

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

lessThanEqual_uvec2 ¶
Source

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

lessThanEqual_uvec3 ¶
Source

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

lessThanEqual_uvec4 ¶
Source

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

lessThanEqual_vec2 ¶
Source

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

lessThanEqual_vec3 ¶
Source

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

lessThanEqual_vec4 ¶
Source

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

lessThan_dvec2 ¶
Source

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

lessThan_dvec3 ¶
Source

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

lessThan_dvec4 ¶
Source

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

lessThan_f32 ¶
Source

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

lessThan_f64 ¶
Source

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

lessThan_i32 ¶
Source

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

lessThan_ivec2 ¶
Source

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

lessThan_ivec3 ¶
Source

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

lessThan_ivec4 ¶
Source

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

lessThan_u32 ¶
Source

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

lessThan_uvec2 ¶
Source

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

lessThan_uvec3 ¶
Source

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

lessThan_uvec4 ¶
Source

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

lessThan_vec2 ¶
Source

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

lessThan_vec3 ¶
Source

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

lessThan_vec4 ¶
Source

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

log_dvec2 ¶
Source

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

log_dvec3 ¶
Source

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

log_dvec4 ¶
Source

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

log_f32 ¶
Source

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

log_f64 ¶
Source

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

log_vec2 ¶
Source

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

log_vec3 ¶
Source

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

log_vec4 ¶
Source

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

mat4FromQuat ¶
Source

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

mat4LookAt ¶
Source

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

mat4Orientation ¶
Source

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

mat4Ortho3d ¶
Source

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

mat4Perspective ¶
Source

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

mat4PerspectiveInfinite ¶
Source

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

mat4Rotate ¶
Source

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

mat4Scale ¶
Source

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

mat4Translate ¶
Source

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

max_dvec2 ¶
Source

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

max_dvec3 ¶
Source

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

max_dvec4 ¶
Source

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

max_f32 ¶
Source

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

max_f64 ¶
Source

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

max_i32 ¶
Source

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

max_ivec2 ¶
Source

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

max_ivec3 ¶
Source

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

max_ivec4 ¶
Source

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

max_u32 ¶
Source

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

max_uvec2 ¶
Source

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

max_uvec3 ¶
Source

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

max_uvec4 ¶
Source

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

max_vec2 ¶
Source

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

max_vec3 ¶
Source

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

max_vec4 ¶
Source

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

min_dvec2 ¶
Source

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

min_dvec3 ¶
Source

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

min_dvec4 ¶
Source

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

min_f32 ¶
Source

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

min_f64 ¶
Source

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

min_i32 ¶
Source

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

min_ivec2 ¶
Source

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

min_ivec3 ¶
Source

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

min_ivec4 ¶
Source

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

min_u32 ¶
Source

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

min_uvec2 ¶
Source

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

min_uvec3 ¶
Source

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

min_uvec4 ¶
Source

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

min_vec2 ¶
Source

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

min_vec3 ¶
Source

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

min_vec4 ¶
Source

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

mix_dvec2 ¶
Source

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

mix_dvec3 ¶
Source

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

mix_dvec4 ¶
Source

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

mix_f32 ¶
Source

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

mix_f64 ¶
Source

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

mix_vec2 ¶
Source

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

mix_vec3 ¶
Source

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

mix_vec4 ¶
Source

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

mod_dvec2 ¶
Source

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

mod_dvec3 ¶
Source

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

mod_dvec4 ¶
Source

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

mod_f32 ¶
Source

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

mod_f64 ¶
Source

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

mod_vec2 ¶
Source

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

mod_vec3 ¶
Source

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

mod_vec4 ¶
Source

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

normalize_dquat ¶
Source

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

normalize_dvec2 ¶
Source

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

normalize_dvec3 ¶
Source

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

normalize_dvec4 ¶
Source

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

normalize_f32 ¶
Source

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

normalize_f64 ¶
Source

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

normalize_quat ¶
Source

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

normalize_vec2 ¶
Source

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

normalize_vec3 ¶
Source

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

normalize_vec4 ¶
Source

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

notEqual_dvec2 ¶
Source

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

notEqual_dvec3 ¶
Source

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

notEqual_dvec4 ¶
Source

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

notEqual_f32 ¶
Source

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

notEqual_f64 ¶
Source

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

notEqual_i32 ¶
Source

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

notEqual_ivec2 ¶
Source

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

notEqual_ivec3 ¶
Source

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

notEqual_ivec4 ¶
Source

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

notEqual_u32 ¶
Source

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

notEqual_uvec2 ¶
Source

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

notEqual_uvec3 ¶
Source

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

notEqual_uvec4 ¶
Source

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

notEqual_vec2 ¶
Source

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

notEqual_vec3 ¶
Source

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

notEqual_vec4 ¶
Source

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

not_bool ¶
Source

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

not_bvec2 ¶
Source

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

not_bvec3 ¶
Source

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

not_bvec4 ¶
Source

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

pow_dvec2 ¶
Source

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

pow_dvec3 ¶
Source

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

pow_dvec4 ¶
Source

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

pow_f32 ¶
Source

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

pow_f64 ¶
Source

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

pow_vec2 ¶
Source

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

pow_vec3 ¶
Source

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

pow_vec4 ¶
Source

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

quatAxisAngle ¶
Source

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

quatFromMat3 ¶
Source

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

quatFromMat4 ¶
Source

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

quatMulVec3 ¶
Source

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

quatNlerp ¶
Source

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

quatSlerp ¶
Source

quatSlerp :: proc "cdecl" (x, y: quat, t: f32) -> (q: quat) {…}

radians_dvec2 ¶
Source

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

radians_dvec3 ¶
Source

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

radians_dvec4 ¶
Source

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

radians_f32 ¶
Source

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

radians_f64 ¶
Source

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

radians_vec2 ¶
Source

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

radians_vec3 ¶
Source

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

radians_vec4 ¶
Source

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

reflect_dvec2 ¶
Source

reflect_dvec2 :: proc "cdecl" (I, N: dvec2) -> dvec2 {…}

reflect_dvec3 ¶
Source

reflect_dvec3 :: proc "cdecl" (I, N: dvec3) -> dvec3 {…}

reflect_dvec4 ¶
Source

reflect_dvec4 :: proc "cdecl" (I, N: dvec4) -> dvec4 {…}

reflect_f32 ¶
Source

reflect_f32 :: proc "cdecl" (I, N: f32) -> f32 {…}

reflect_f64 ¶
Source

reflect_f64 :: proc "cdecl" (I, N: f64) -> f64 {…}

reflect_vec2 ¶
Source

reflect_vec2 :: proc "cdecl" (I, N: vec2) -> vec2 {…}

reflect_vec3 ¶
Source

reflect_vec3 :: proc "cdecl" (I, N: vec3) -> vec3 {…}

reflect_vec4 ¶
Source

reflect_vec4 :: proc "cdecl" (I, N: vec4) -> vec4 {…}

refract_dvec2 ¶
Source

refract_dvec2 :: proc "cdecl" (i, n, eta: dvec2) -> dvec2 {…}

refract_dvec3 ¶
Source

refract_dvec3 :: proc "cdecl" (i, n, eta: dvec3) -> dvec3 {…}

refract_dvec4 ¶
Source

refract_dvec4 :: proc "cdecl" (i, n, eta: dvec4) -> dvec4 {…}

refract_f32 ¶
Source

refract_f32 :: proc "cdecl" (i, n, eta: f32) -> f32 {…}

refract_f64 ¶
Source

refract_f64 :: proc "cdecl" (i, n, eta: f64) -> f64 {…}

refract_vec2 ¶
Source

refract_vec2 :: proc "cdecl" (i, n, eta: vec2) -> vec2 {…}

refract_vec3 ¶
Source

refract_vec3 :: proc "cdecl" (i, n, eta: vec3) -> vec3 {…}

refract_vec4 ¶
Source

refract_vec4 :: proc "cdecl" (i, n, eta: vec4) -> vec4 {…}

round_dvec2 ¶
Source

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

round_dvec3 ¶
Source

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

round_dvec4 ¶
Source

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

round_f32 ¶
Source

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

round_f64 ¶
Source

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

round_vec2 ¶
Source

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

round_vec3 ¶
Source

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

round_vec4 ¶
Source

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

saturate_dvec2 ¶
Source

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

saturate_dvec3 ¶
Source

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

saturate_dvec4 ¶
Source

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

saturate_f32 ¶
Source

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

saturate_f64 ¶
Source

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

saturate_i32 ¶
Source

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

saturate_ivec2 ¶
Source

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

saturate_ivec3 ¶
Source

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

saturate_ivec4 ¶
Source

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

saturate_u32 ¶
Source

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

saturate_uvec2 ¶
Source

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

saturate_uvec3 ¶
Source

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

saturate_uvec4 ¶
Source

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

saturate_vec2 ¶
Source

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

saturate_vec3 ¶
Source

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

saturate_vec4 ¶
Source

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

scalarTripleProduct_dvec3 ¶
Source

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

scalarTripleProduct_ivec3 ¶
Source

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

scalarTripleProduct_vec3 ¶
Source

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

sign_dvec2 ¶
Source

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

sign_dvec3 ¶
Source

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

sign_dvec4 ¶
Source

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

sign_f32 ¶
Source

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

sign_f64 ¶
Source

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

sign_i32 ¶
Source

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

sign_ivec2 ¶
Source

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

sign_ivec3 ¶
Source

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

sign_ivec4 ¶
Source

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

sign_u32 ¶
Source

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

sign_uvec2 ¶
Source

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

sign_uvec3 ¶
Source

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

sign_uvec4 ¶
Source

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

sign_vec2 ¶
Source

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

sign_vec3 ¶
Source

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

sign_vec4 ¶
Source

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

sin_dvec2 ¶
Source

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

sin_dvec3 ¶
Source

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

sin_dvec4 ¶
Source

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

sin_f32 ¶
Source

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

sin_f64 ¶
Source

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

sin_vec2 ¶
Source

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

sin_vec3 ¶
Source

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

sin_vec4 ¶
Source

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

sinh_dvec2 ¶
Source

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

sinh_dvec3 ¶
Source

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

sinh_dvec4 ¶
Source

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

sinh_f32 ¶
Source

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

sinh_f64 ¶
Source

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

sinh_vec2 ¶
Source

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

sinh_vec3 ¶
Source

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

sinh_vec4 ¶
Source

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

smoothstep_dvec2 ¶
Source

smoothstep_dvec2 :: proc "cdecl" (edge0, edge1, x: dvec2) -> dvec2 {…}

smoothstep_dvec3 ¶
Source

smoothstep_dvec3 :: proc "cdecl" (edge0, edge1, x: dvec3) -> dvec3 {…}

smoothstep_dvec4 ¶
Source

smoothstep_dvec4 :: proc "cdecl" (edge0, edge1, x: dvec4) -> dvec4 {…}

smoothstep_f32 ¶
Source

smoothstep_f32 :: proc "cdecl" (edge0, edge1, x: f32) -> f32 {…}

smoothstep_f64 ¶
Source

smoothstep_f64 :: proc "cdecl" (edge0, edge1, x: f64) -> f64 {…}

smoothstep_vec2 ¶
Source

smoothstep_vec2 :: proc "cdecl" (edge0, edge1, x: vec2) -> vec2 {…}

smoothstep_vec3 ¶
Source

smoothstep_vec3 :: proc "cdecl" (edge0, edge1, x: vec3) -> vec3 {…}

smoothstep_vec4 ¶
Source

smoothstep_vec4 :: proc "cdecl" (edge0, edge1, x: vec4) -> vec4 {…}

sqrt_dvec2 ¶
Source

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

sqrt_dvec3 ¶
Source

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

sqrt_dvec4 ¶
Source

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

sqrt_f32 ¶
Source

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

sqrt_f64 ¶
Source

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

sqrt_vec2 ¶
Source

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

sqrt_vec3 ¶
Source

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

sqrt_vec4 ¶
Source

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

step_dvec2 ¶
Source

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

step_dvec3 ¶
Source

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

step_dvec4 ¶
Source

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

step_f32 ¶
Source

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

step_f64 ¶
Source

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

step_vec2 ¶
Source

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

step_vec3 ¶
Source

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

step_vec4 ¶
Source

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

tan_dvec2 ¶
Source

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

tan_dvec3 ¶
Source

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

tan_dvec4 ¶
Source

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

tan_f32 ¶
Source

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

tan_f64 ¶
Source

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

tan_vec2 ¶
Source

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

tan_vec3 ¶
Source

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

tan_vec4 ¶
Source

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

tanh_dvec2 ¶
Source

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

tanh_dvec3 ¶
Source

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

tanh_dvec4 ¶
Source

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

tanh_f32 ¶
Source

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

tanh_f64 ¶
Source

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

tanh_vec2 ¶
Source

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

tanh_vec3 ¶
Source

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

tanh_vec4 ¶
Source

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

transpose ¶

transpose :: builtin.transpose

vectorTripleProduct_dvec3 ¶
Source

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

vectorTripleProduct_ivec3 ¶
Source

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

vectorTripleProduct_vec3 ¶
Source

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

Procedure Groups

abs ¶
Source

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,
}

acos ¶
Source

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

acosh ¶
Source

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

adjugate ¶
Source

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

all ¶
Source

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

any ¶
Source

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

asin ¶
Source

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

asinh ¶
Source

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

atan ¶
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,
}

atan2 ¶
Source

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

atanh ¶
Source

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

ceil ¶
Source

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

clamp ¶
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,
}

cos ¶
Source

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

cosh ¶
Source

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

cross ¶
Source

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

degrees ¶
Source

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

determinant ¶
Source

determinant :: proc{
	runtime.matrix1x1_determinant,
	runtime.matrix2x2_determinant,
	runtime.matrix3x3_determinant,
	runtime.matrix4x4_determinant,
}

distance ¶
Source

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

dot ¶
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,
}

equal ¶
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,
}

exp ¶
Source

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

exp2 ¶
Source

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

faceForward ¶
Source

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

floor ¶
Source

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

fract ¶
Source

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

greaterThan ¶
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,
}

greaterThanEqual ¶
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,
}

inverse ¶
Source

inverse :: proc{
	inverse_mat2,
	inverse_mat3,
	inverse_mat4,
	inverse_dmat2,
	inverse_dmat3,
	inverse_dmat4,
	inverse_quat,
	inverse_dquat,
}

inverse_transpose ¶
Source

inverse_transpose :: proc{
	runtime.matrix1x1_inverse_transpose,
	runtime.matrix2x2_inverse_transpose,
	runtime.matrix3x3_inverse_transpose,
	runtime.matrix4x4_inverse_transpose,
}

inversesqrt ¶
Source

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

length ¶
Source

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

lerp ¶
Source

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

lessThan ¶
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,
}

lessThanEqual ¶
Source

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,
}

log ¶
Source

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

max ¶
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,
}

min ¶
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,
}

mix ¶
Source

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

mod ¶
Source

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

nlerp ¶
Source

nlerp :: proc{
	quatNlerp,
	dquatNlerp,
}

normalize ¶
Source

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

not ¶
Source

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

notEqual ¶
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,
}

pow ¶
Source

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

radians ¶
Source

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

reflect ¶
Source

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

refract ¶
Source

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

round ¶
Source

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

rsqrt ¶
Source

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

saturate ¶
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,
}

scalarTripleProduct ¶
Source

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

sign ¶
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,
}

sin ¶
Source

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

sinh ¶
Source

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

slerp ¶
Source

slerp :: proc{
	quatSlerp,
	dquatSlerp,
}

smoothstep ¶
Source

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

sqrt ¶
Source

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

step ¶
Source

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

tan ¶
Source

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

tanh ¶
Source

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

vectorTripleProduct ¶
Source

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

Source Files

Generation Information

Generated with odin version dev-2023-03 (vendor "odin") Windows_amd64 @ 2023-03-29 21:09:05.417234400 +0000 UTC