package core:math/linalg/glsl
Source

⌘K

Ctrl+K

or

/

Filter Results

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 (582)

Procedure Groups (62)

Types

bvec2 ¶
Source

bvec2 :: [2]bool

bvec3 ¶
Source

bvec3 :: [3]bool

bvec4 ¶
Source

bvec4 :: [4]bool

dmat2 ¶
Source

dmat2 :: matrix[2, 2]f64

dmat2x2 ¶
Source

dmat2x2 :: matrix[2, 2]f64

dmat2x3 ¶
Source

dmat2x3 :: matrix[3, 2]f64

dmat2x4 ¶
Source

dmat2x4 :: matrix[4, 2]f64

dmat3 ¶
Source

dmat3 :: matrix[3, 3]f64

dmat3x2 ¶
Source

dmat3x2 :: matrix[2, 3]f64

dmat3x3 ¶
Source

dmat3x3 :: matrix[3, 3]f64

dmat3x4 ¶
Source

dmat3x4 :: matrix[4, 3]f64

dmat4 ¶
Source

dmat4 :: matrix[4, 4]f64

dmat4x2 ¶
Source

dmat4x2 :: matrix[2, 4]f64

dmat4x3 ¶
Source

dmat4x3 :: matrix[3, 4]f64

dmat4x4 ¶
Source

dmat4x4 :: matrix[4, 4]f64

dquat ¶
Source

dquat :: quaternion256

dvec2 ¶
Source

dvec2 :: [2]f64

dvec3 ¶
Source

dvec3 :: [3]f64

dvec4 ¶
Source

dvec4 :: [4]f64

ivec2 ¶
Source

ivec2 :: [2]i32

ivec3 ¶
Source

ivec3 :: [3]i32

ivec4 ¶
Source

ivec4 :: [4]i32

mat2 ¶
Source

mat2 :: matrix[2, 2]f32

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

mat2x2 ¶
Source

mat2x2 :: matrix[2, 2]f32

mat2x3 ¶
Source

mat2x3 :: matrix[3, 2]f32

mat2x4 ¶
Source

mat2x4 :: matrix[4, 2]f32

mat3 ¶
Source

mat3 :: matrix[3, 3]f32

mat3x2 ¶
Source

mat3x2 :: 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 :: matrix[3, 3]f32

mat3x4 ¶
Source

mat3x4 :: matrix[4, 3]f32

mat4 ¶
Source

mat4 :: matrix[4, 4]f32

mat4x2 ¶
Source

mat4x2 :: matrix[2, 4]f32

mat4x3 ¶
Source

mat4x3 :: matrix[3, 4]f32

mat4x4 ¶
Source

mat4x4 :: matrix[4, 4]f32

quat ¶
Source

quat :: quaternion128

uvec2 ¶
Source

uvec2 :: [2]u32

uvec3 ¶
Source

uvec3 :: [3]u32

uvec4 ¶
Source

uvec4 :: [4]u32

vec2 ¶
Source

vec2 :: [2]f32

vec3 ¶
Source

vec3 :: [3]f32

vec4 ¶
Source

vec4 :: [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 "c" (x: [2]f64) -> [2]f64 {…}

abs_dvec3 ¶
Source

abs_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

abs_dvec4 ¶
Source

abs_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

abs_f32 ¶
Source

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

abs_f64 ¶
Source

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

abs_i32 ¶
Source

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

abs_ivec2 ¶
Source

abs_ivec2 :: proc "c" (x: [2]i32) -> [2]i32 {…}

abs_ivec3 ¶
Source

abs_ivec3 :: proc "c" (x: [3]i32) -> [3]i32 {…}

abs_ivec4 ¶
Source

abs_ivec4 :: proc "c" (x: [4]i32) -> [4]i32 {…}

abs_u32 ¶
Source

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

abs_uvec2 ¶
Source

abs_uvec2 :: proc "c" (x: [2]u32) -> [2]u32 {…}

abs_uvec3 ¶
Source

abs_uvec3 :: proc "c" (x: [3]u32) -> [3]u32 {…}

abs_uvec4 ¶
Source

abs_uvec4 :: proc "c" (x: [4]u32) -> [4]u32 {…}

abs_vec2 ¶
Source

abs_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

abs_vec3 ¶
Source

abs_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

abs_vec4 ¶
Source

abs_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

acos_dvec2 ¶
Source

acos_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

acos_dvec3 ¶
Source

acos_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

acos_dvec4 ¶
Source

acos_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

acos_f32 ¶
Source

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

acos_f64 ¶
Source

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

acos_vec2 ¶
Source

acos_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

acos_vec3 ¶
Source

acos_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

acos_vec4 ¶
Source

acos_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

acosh_dvec2 ¶
Source

acosh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

acosh_dvec3 ¶
Source

acosh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

acosh_dvec4 ¶
Source

acosh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

acosh_f32 ¶
Source

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

acosh_f64 ¶
Source

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

acosh_vec2 ¶
Source

acosh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

acosh_vec3 ¶
Source

acosh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

acosh_vec4 ¶
Source

acosh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

adjugate_matrix1x1 ¶
Source

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

adjugate_matrix2x2 ¶
Source

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

adjugate_matrix3x3 ¶
Source

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

adjugate_matrix4x4 ¶
Source

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

all_bool ¶
Source

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

all_bvec2 ¶
Source

all_bvec2 :: proc "c" (v: [2]bool) -> bool {…}

all_bvec3 ¶
Source

all_bvec3 :: proc "c" (v: [3]bool) -> bool {…}

all_bvec4 ¶
Source

all_bvec4 :: proc "c" (v: [4]bool) -> bool {…}

any_bool ¶
Source

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

any_bvec2 ¶
Source

any_bvec2 :: proc "c" (v: [2]bool) -> bool {…}

any_bvec3 ¶
Source

any_bvec3 :: proc "c" (v: [3]bool) -> bool {…}

any_bvec4 ¶
Source

any_bvec4 :: proc "c" (v: [4]bool) -> bool {…}

asin_dvec2 ¶
Source

asin_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

asin_dvec3 ¶
Source

asin_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

asin_dvec4 ¶
Source

asin_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

asin_f32 ¶
Source

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

asin_f64 ¶
Source

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

asin_vec2 ¶
Source

asin_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

asin_vec3 ¶
Source

asin_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

asin_vec4 ¶
Source

asin_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

asinh_dvec2 ¶
Source

asinh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

asinh_dvec3 ¶
Source

asinh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

asinh_dvec4 ¶
Source

asinh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

asinh_f32 ¶
Source

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

asinh_f64 ¶
Source

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

asinh_vec2 ¶
Source

asinh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

asinh_vec3 ¶
Source

asinh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

asinh_vec4 ¶
Source

asinh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

atan2_dvec2 ¶
Source

atan2_dvec2 :: proc "c" (y, x: [2]f64) -> [2]f64 {…}

atan2_dvec3 ¶
Source

atan2_dvec3 :: proc "c" (y, x: [3]f64) -> [3]f64 {…}

atan2_dvec4 ¶
Source

atan2_dvec4 :: proc "c" (y, x: [4]f64) -> [4]f64 {…}

atan2_f32 ¶
Source

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

atan2_f64 ¶
Source

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

atan2_vec2 ¶
Source

atan2_vec2 :: proc "c" (y, x: [2]f32) -> [2]f32 {…}

atan2_vec3 ¶
Source

atan2_vec3 :: proc "c" (y, x: [3]f32) -> [3]f32 {…}

atan2_vec4 ¶
Source

atan2_vec4 :: proc "c" (y, x: [4]f32) -> [4]f32 {…}

atan_dvec2 ¶
Source

atan_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

atan_dvec3 ¶
Source

atan_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

atan_dvec4 ¶
Source

atan_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

atan_f32 ¶
Source

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

atan_f64 ¶
Source

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

atan_vec2 ¶
Source

atan_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

atan_vec3 ¶
Source

atan_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

atan_vec4 ¶
Source

atan_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

atanh_dvec2 ¶
Source

atanh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

atanh_dvec3 ¶
Source

atanh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

atanh_dvec4 ¶
Source

atanh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

atanh_f32 ¶
Source

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

atanh_f64 ¶
Source

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

atanh_vec2 ¶
Source

atanh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

atanh_vec3 ¶
Source

atanh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

atanh_vec4 ¶
Source

atanh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

ceil_dvec2 ¶
Source

ceil_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

ceil_dvec3 ¶
Source

ceil_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

ceil_dvec4 ¶
Source

ceil_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

ceil_f32 ¶
Source

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

ceil_f64 ¶
Source

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

ceil_vec2 ¶
Source

ceil_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

ceil_vec3 ¶
Source

ceil_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

ceil_vec4 ¶
Source

ceil_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

clamp_dvec2 ¶
Source

clamp_dvec2 :: proc "c" (x, y, z: [2]f64) -> [2]f64 {…}

clamp_dvec3 ¶
Source

clamp_dvec3 :: proc "c" (x, y, z: [3]f64) -> [3]f64 {…}

clamp_dvec4 ¶
Source

clamp_dvec4 :: proc "c" (x, y, z: [4]f64) -> [4]f64 {…}

clamp_f32 ¶
Source

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

clamp_f64 ¶
Source

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

clamp_i32 ¶
Source

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

clamp_ivec2 ¶
Source

clamp_ivec2 :: proc "c" (x, y, z: [2]i32) -> [2]i32 {…}

clamp_ivec3 ¶
Source

clamp_ivec3 :: proc "c" (x, y, z: [3]i32) -> [3]i32 {…}

clamp_ivec4 ¶
Source

clamp_ivec4 :: proc "c" (x, y, z: [4]i32) -> [4]i32 {…}

clamp_u32 ¶
Source

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

clamp_uvec2 ¶
Source

clamp_uvec2 :: proc "c" (x, y, z: [2]u32) -> [2]u32 {…}

clamp_uvec3 ¶
Source

clamp_uvec3 :: proc "c" (x, y, z: [3]u32) -> [3]u32 {…}

clamp_uvec4 ¶
Source

clamp_uvec4 :: proc "c" (x, y, z: [4]u32) -> [4]u32 {…}

clamp_vec2 ¶
Source

clamp_vec2 :: proc "c" (x, y, z: [2]f32) -> [2]f32 {…}

clamp_vec3 ¶
Source

clamp_vec3 :: proc "c" (x, y, z: [3]f32) -> [3]f32 {…}

clamp_vec4 ¶
Source

clamp_vec4 :: proc "c" (x, y, z: [4]f32) -> [4]f32 {…}

cos_dvec2 ¶
Source

cos_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

cos_dvec3 ¶
Source

cos_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

cos_dvec4 ¶
Source

cos_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

cos_f32 ¶
Source

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

cos_f64 ¶
Source

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

cos_vec2 ¶
Source

cos_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

cos_vec3 ¶
Source

cos_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

cos_vec4 ¶
Source

cos_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

cosh_dvec2 ¶
Source

cosh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

cosh_dvec3 ¶
Source

cosh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

cosh_dvec4 ¶
Source

cosh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

cosh_f32 ¶
Source

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

cosh_f64 ¶
Source

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

cosh_vec2 ¶
Source

cosh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

cosh_vec3 ¶
Source

cosh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

cosh_vec4 ¶
Source

cosh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

cross_dvec3 ¶
Source

cross_dvec3 :: proc "c" (a, b: [3]f64) -> (c: [3]f64) {…}

cross_ivec3 ¶
Source

cross_ivec3 :: proc "c" (a, b: [3]i32) -> (c: [3]i32) {…}

cross_vec3 ¶
Source

cross_vec3 :: proc "c" (a, b: [3]f32) -> (c: [3]f32) {…}

degrees_dvec2 ¶
Source

degrees_dvec2 :: proc "c" (radians: [2]f64) -> [2]f64 {…}

degrees_dvec3 ¶
Source

degrees_dvec3 :: proc "c" (radians: [3]f64) -> [3]f64 {…}

degrees_dvec4 ¶
Source

degrees_dvec4 :: proc "c" (radians: [4]f64) -> [4]f64 {…}

degrees_f32 ¶
Source

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

degrees_f64 ¶
Source

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

degrees_vec2 ¶
Source

degrees_vec2 :: proc "c" (radians: [2]f32) -> [2]f32 {…}

degrees_vec3 ¶
Source

degrees_vec3 :: proc "c" (radians: [3]f32) -> [3]f32 {…}

degrees_vec4 ¶
Source

degrees_vec4 :: proc "c" (radians: [4]f32) -> [4]f32 {…}

determinant_matrix1x1 ¶
Source

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

determinant_matrix2x2 ¶
Source

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

determinant_matrix3x3 ¶
Source

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

determinant_matrix4x4 ¶
Source

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

distance_dvec2 ¶
Source

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

distance_dvec3 ¶
Source

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

distance_dvec4 ¶
Source

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

distance_f32 ¶
Source

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

distance_f64 ¶
Source

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

distance_vec2 ¶
Source

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

distance_vec3 ¶
Source

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

distance_vec4 ¶
Source

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

dmat4FromDquat ¶
Source

dmat4FromDquat :: proc "c" (q: quaternion256) -> (m: matrix[4, 4]f64) {…}

dmat4LookAt ¶
Source

dmat4LookAt :: proc "c" (eye, centre: [3]f64, up: [3]f64) -> (m: matrix[4, 4]f64) {…}

dmat4Orientation ¶
Source

dmat4Orientation :: proc "c" (normal, up: [3]f64) -> matrix[4, 4]f64 {…}

dmat4Ortho3d ¶
Source

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

dmat4Perspective ¶
Source

dmat4Perspective :: proc "c" (fovy, aspect, near, far: f64) -> (m: matrix[4, 4]f64) {…}

dmat4PerspectiveInfinite ¶
Source

dmat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f64) -> (m: matrix[4, 4]f64) {…}

dmat4Rotate ¶
Source

dmat4Rotate :: proc "c" (v: [3]f64, radians: f64) -> (rot: matrix[4, 4]f64) {…}

dmat4Scale ¶
Source

dmat4Scale :: proc "c" (v: [3]f64) -> (m: matrix[4, 4]f64) {…}

dmat4Translate ¶
Source

dmat4Translate :: proc "c" (v: [3]f64) -> (m: matrix[4, 4]f64) {…}

dot_dquat ¶
Source

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

dot_dvec2 ¶
Source

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

dot_dvec3 ¶
Source

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

dot_dvec4 ¶
Source

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

dot_f32 ¶
Source

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

dot_f64 ¶
Source

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

dot_i32 ¶
Source

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

dot_ivec2 ¶
Source

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

dot_ivec3 ¶
Source

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

dot_ivec4 ¶
Source

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

dot_quat ¶
Source

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

dot_u32 ¶
Source

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

dot_uvec2 ¶
Source

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

dot_uvec3 ¶
Source

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

dot_uvec4 ¶
Source

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

dot_vec2 ¶
Source

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

dot_vec3 ¶
Source

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

dot_vec4 ¶
Source

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

dquatAxisAngle ¶
Source

dquatAxisAngle :: proc "c" (axis: [3]f64, radians: f64) -> (q: quaternion256) {…}

dquatFromDmat4 ¶
Source

dquatFromDmat4 :: proc "c" (m: matrix[4, 4]f64) -> (q: quaternion256) {…}

dquatFromdMat3 ¶
Source

dquatFromdMat3 :: proc "c" (m: matrix[3, 3]f64) -> (q: quaternion256) {…}

dquatMulDvec3 ¶
Source

dquatMulDvec3 :: proc "c" (q: quaternion256, v: [3]f64) -> [3]f64 {…}

dquatNlerp ¶
Source

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

dquatSlerp ¶
Source

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

equal_dvec2 ¶
Source

equal_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

equal_dvec3 ¶
Source

equal_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

equal_dvec4 ¶
Source

equal_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

equal_f32 ¶
Source

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

equal_f64 ¶
Source

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

equal_i32 ¶
Source

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

equal_ivec2 ¶
Source

equal_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

equal_ivec3 ¶
Source

equal_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

equal_ivec4 ¶
Source

equal_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

equal_u32 ¶
Source

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

equal_uvec2 ¶
Source

equal_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

equal_uvec3 ¶
Source

equal_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

equal_uvec4 ¶
Source

equal_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

equal_vec2 ¶
Source

equal_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

equal_vec3 ¶
Source

equal_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

equal_vec4 ¶
Source

equal_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

exp2_dvec2 ¶
Source

exp2_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

exp2_dvec3 ¶
Source

exp2_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

exp2_dvec4 ¶
Source

exp2_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

exp2_f32 ¶
Source

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

exp2_f64 ¶
Source

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

exp2_vec2 ¶
Source

exp2_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

exp2_vec3 ¶
Source

exp2_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

exp2_vec4 ¶
Source

exp2_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

exp_dvec2 ¶
Source

exp_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

exp_dvec3 ¶
Source

exp_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

exp_dvec4 ¶
Source

exp_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

exp_f32 ¶
Source

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

exp_f64 ¶
Source

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

exp_vec2 ¶
Source

exp_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

exp_vec3 ¶
Source

exp_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

exp_vec4 ¶
Source

exp_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

faceForward_dvec2 ¶
Source

faceForward_dvec2 :: proc "c" (N, I, Nref: [2]f64) -> [2]f64 {…}

faceForward_dvec3 ¶
Source

faceForward_dvec3 :: proc "c" (N, I, Nref: [3]f64) -> [3]f64 {…}

faceForward_dvec4 ¶
Source

faceForward_dvec4 :: proc "c" (N, I, Nref: [4]f64) -> [4]f64 {…}

faceForward_f32 ¶
Source

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

faceForward_f64 ¶
Source

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

faceForward_vec2 ¶
Source

faceForward_vec2 :: proc "c" (N, I, Nref: [2]f32) -> [2]f32 {…}

faceForward_vec3 ¶
Source

faceForward_vec3 :: proc "c" (N, I, Nref: [3]f32) -> [3]f32 {…}

faceForward_vec4 ¶
Source

faceForward_vec4 :: proc "c" (N, I, Nref: [4]f32) -> [4]f32 {…}

floor_dvec2 ¶
Source

floor_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

floor_dvec3 ¶
Source

floor_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

floor_dvec4 ¶
Source

floor_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

floor_f32 ¶
Source

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

floor_f64 ¶
Source

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

floor_vec2 ¶
Source

floor_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

floor_vec3 ¶
Source

floor_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

floor_vec4 ¶
Source

floor_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

fract_dvec2 ¶
Source

fract_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

fract_dvec3 ¶
Source

fract_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

fract_dvec4 ¶
Source

fract_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

fract_f32 ¶
Source

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

fract_f64 ¶
Source

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

fract_vec2 ¶
Source

fract_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

fract_vec3 ¶
Source

fract_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

fract_vec4 ¶
Source

fract_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

greaterThanEqual_dvec2 ¶
Source

greaterThanEqual_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

greaterThanEqual_dvec3 ¶
Source

greaterThanEqual_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

greaterThanEqual_dvec4 ¶
Source

greaterThanEqual_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

greaterThanEqual_f32 ¶
Source

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

greaterThanEqual_f64 ¶
Source

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

greaterThanEqual_i32 ¶
Source

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

greaterThanEqual_ivec2 ¶
Source

greaterThanEqual_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

greaterThanEqual_ivec3 ¶
Source

greaterThanEqual_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

greaterThanEqual_ivec4 ¶
Source

greaterThanEqual_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

greaterThanEqual_u32 ¶
Source

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

greaterThanEqual_uvec2 ¶
Source

greaterThanEqual_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

greaterThanEqual_uvec3 ¶
Source

greaterThanEqual_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

greaterThanEqual_uvec4 ¶
Source

greaterThanEqual_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

greaterThanEqual_vec2 ¶
Source

greaterThanEqual_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

greaterThanEqual_vec3 ¶
Source

greaterThanEqual_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

greaterThanEqual_vec4 ¶
Source

greaterThanEqual_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

greaterThan_dvec2 ¶
Source

greaterThan_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

greaterThan_dvec3 ¶
Source

greaterThan_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

greaterThan_dvec4 ¶
Source

greaterThan_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

greaterThan_f32 ¶
Source

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

greaterThan_f64 ¶
Source

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

greaterThan_i32 ¶
Source

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

greaterThan_ivec2 ¶
Source

greaterThan_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

greaterThan_ivec3 ¶
Source

greaterThan_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

greaterThan_ivec4 ¶
Source

greaterThan_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

greaterThan_u32 ¶
Source

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

greaterThan_uvec2 ¶
Source

greaterThan_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

greaterThan_uvec3 ¶
Source

greaterThan_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

greaterThan_uvec4 ¶
Source

greaterThan_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

greaterThan_vec2 ¶
Source

greaterThan_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

greaterThan_vec3 ¶
Source

greaterThan_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

greaterThan_vec4 ¶
Source

greaterThan_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

hermitian_adjoint ¶
Source

hermitian_adjoint :: proc "contextless" (m: $/matrix[0, 0]$T) -> $/matrix[0, 0]$T {…}

identity ¶
Source

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

inverse_dmat2 ¶
Source

inverse_dmat2 :: proc "c" (m: matrix[2, 2]f64) -> matrix[2, 2]f64 {…}

inverse_dmat3 ¶
Source

inverse_dmat3 :: proc "c" (m: matrix[3, 3]f64) -> matrix[3, 3]f64 {…}

inverse_dmat4 ¶
Source

inverse_dmat4 :: proc "c" (m: matrix[4, 4]f64) -> matrix[4, 4]f64 {…}

inverse_dquat ¶
Source

inverse_dquat :: proc "c" (q: quaternion256) -> quaternion256 {…}

inverse_mat2 ¶
Source

inverse_mat2 :: proc "c" (m: matrix[2, 2]f32) -> matrix[2, 2]f32 {…}

inverse_mat3 ¶
Source

inverse_mat3 :: proc "c" (m: matrix[3, 3]f32) -> matrix[3, 3]f32 {…}

inverse_mat4 ¶
Source

inverse_mat4 :: proc "c" (m: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

inverse_matrix1x1 ¶
Source

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

inverse_matrix2x2 ¶
Source

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

inverse_matrix3x3 ¶
Source

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

inverse_matrix4x4 ¶
Source

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

inverse_quat ¶
Source

inverse_quat :: proc "c" (q: quaternion128) -> quaternion128 {…}

inverse_transpose_matrix1x1 ¶
Source

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

inverse_transpose_matrix2x2 ¶
Source

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

inverse_transpose_matrix3x3 ¶
Source

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

inverse_transpose_matrix4x4 ¶
Source

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

inversesqrt_dvec2 ¶
Source

inversesqrt_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

inversesqrt_dvec3 ¶
Source

inversesqrt_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

inversesqrt_dvec4 ¶
Source

inversesqrt_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

inversesqrt_f32 ¶
Source

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

inversesqrt_f64 ¶
Source

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

inversesqrt_vec2 ¶
Source

inversesqrt_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

inversesqrt_vec3 ¶
Source

inversesqrt_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

inversesqrt_vec4 ¶
Source

inversesqrt_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

length_dquat ¶
Source

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

length_dvec2 ¶
Source

length_dvec2 :: proc "c" (x: [2]f64) -> f64 {…}

length_dvec3 ¶
Source

length_dvec3 :: proc "c" (x: [3]f64) -> f64 {…}

length_dvec4 ¶
Source

length_dvec4 :: proc "c" (x: [4]f64) -> f64 {…}

length_f32 ¶
Source

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

length_f64 ¶
Source

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

length_quat ¶
Source

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

length_vec2 ¶
Source

length_vec2 :: proc "c" (x: [2]f32) -> f32 {…}

length_vec3 ¶
Source

length_vec3 :: proc "c" (x: [3]f32) -> f32 {…}

length_vec4 ¶
Source

length_vec4 :: proc "c" (x: [4]f32) -> f32 {…}

lerp_dvec2 ¶
Source

lerp_dvec2 :: proc "c" (x, y, t: [2]f64) -> [2]f64 {…}

lerp_dvec3 ¶
Source

lerp_dvec3 :: proc "c" (x, y, t: [3]f64) -> [3]f64 {…}

lerp_dvec4 ¶
Source

lerp_dvec4 :: proc "c" (x, y, t: [4]f64) -> [4]f64 {…}

lerp_f32 ¶
Source

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

lerp_f64 ¶
Source

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

lerp_vec2 ¶
Source

lerp_vec2 :: proc "c" (x, y, t: [2]f32) -> [2]f32 {…}

lerp_vec3 ¶
Source

lerp_vec3 :: proc "c" (x, y, t: [3]f32) -> [3]f32 {…}

lerp_vec4 ¶
Source

lerp_vec4 :: proc "c" (x, y, t: [4]f32) -> [4]f32 {…}

lessThanEqual_dvec2 ¶
Source

lessThanEqual_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

lessThanEqual_dvec3 ¶
Source

lessThanEqual_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

lessThanEqual_dvec4 ¶
Source

lessThanEqual_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

lessThanEqual_f32 ¶
Source

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

lessThanEqual_f64 ¶
Source

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

lessThanEqual_i32 ¶
Source

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

lessThanEqual_ivec2 ¶
Source

lessThanEqual_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

lessThanEqual_ivec3 ¶
Source

lessThanEqual_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

lessThanEqual_ivec4 ¶
Source

lessThanEqual_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

lessThanEqual_u32 ¶
Source

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

lessThanEqual_uvec2 ¶
Source

lessThanEqual_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

lessThanEqual_uvec3 ¶
Source

lessThanEqual_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

lessThanEqual_uvec4 ¶
Source

lessThanEqual_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

lessThanEqual_vec2 ¶
Source

lessThanEqual_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

lessThanEqual_vec3 ¶
Source

lessThanEqual_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

lessThanEqual_vec4 ¶
Source

lessThanEqual_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

lessThan_dvec2 ¶
Source

lessThan_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

lessThan_dvec3 ¶
Source

lessThan_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

lessThan_dvec4 ¶
Source

lessThan_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

lessThan_f32 ¶
Source

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

lessThan_f64 ¶
Source

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

lessThan_i32 ¶
Source

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

lessThan_ivec2 ¶
Source

lessThan_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

lessThan_ivec3 ¶
Source

lessThan_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

lessThan_ivec4 ¶
Source

lessThan_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

lessThan_u32 ¶
Source

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

lessThan_uvec2 ¶
Source

lessThan_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

lessThan_uvec3 ¶
Source

lessThan_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

lessThan_uvec4 ¶
Source

lessThan_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

lessThan_vec2 ¶
Source

lessThan_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

lessThan_vec3 ¶
Source

lessThan_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

lessThan_vec4 ¶
Source

lessThan_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

log_dvec2 ¶
Source

log_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

log_dvec3 ¶
Source

log_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

log_dvec4 ¶
Source

log_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

log_f32 ¶
Source

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

log_f64 ¶
Source

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

log_vec2 ¶
Source

log_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

log_vec3 ¶
Source

log_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

log_vec4 ¶
Source

log_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

mat4FromQuat ¶
Source

mat4FromQuat :: proc "c" (q: quaternion128) -> (m: matrix[4, 4]f32) {…}

mat4LookAt ¶
Source

mat4LookAt :: proc "c" (eye, centre: [3]f32, up: [3]f32) -> (m: matrix[4, 4]f32) {…}

mat4Orientation ¶
Source

mat4Orientation :: proc "c" (normal, up: [3]f32) -> matrix[4, 4]f32 {…}

mat4Ortho3d ¶
Source

mat4Ortho3d :: proc "c" (
	left, right, bottom, top, near, 
	far:                            f32, 
) -> (m: matrix[4, 4]f32) {…}

mat4Perspective ¶
Source

mat4Perspective :: proc "c" (fovy, aspect, near, far: f32) -> (m: matrix[4, 4]f32) {…}

mat4PerspectiveInfinite ¶
Source

mat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f32) -> (m: matrix[4, 4]f32) {…}

mat4Rotate ¶
Source

mat4Rotate :: proc "c" (v: [3]f32, radians: f32) -> (rot: matrix[4, 4]f32) {…}

mat4Scale ¶
Source

mat4Scale :: proc "c" (v: [3]f32) -> (m: matrix[4, 4]f32) {…}

mat4Translate ¶
Source

mat4Translate :: proc "c" (v: [3]f32) -> (m: matrix[4, 4]f32) {…}

matrix_minor ¶
Source

matrix_minor :: proc "contextless" (m: $/matrix[0, 0]$T, #any_int row, #any_int column: int) -> (minor: $T) {…}

max_dvec2 ¶
Source

max_dvec2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}

max_dvec3 ¶
Source

max_dvec3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}

max_dvec4 ¶
Source

max_dvec4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}

max_f32 ¶
Source

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

max_f64 ¶
Source

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

max_i32 ¶
Source

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

max_ivec2 ¶
Source

max_ivec2 :: proc "c" (x, y: [2]i32) -> [2]i32 {…}

max_ivec3 ¶
Source

max_ivec3 :: proc "c" (x, y: [3]i32) -> [3]i32 {…}

max_ivec4 ¶
Source

max_ivec4 :: proc "c" (x, y: [4]i32) -> [4]i32 {…}

max_u32 ¶
Source

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

max_uvec2 ¶
Source

max_uvec2 :: proc "c" (x, y: [2]u32) -> [2]u32 {…}

max_uvec3 ¶
Source

max_uvec3 :: proc "c" (x, y: [3]u32) -> [3]u32 {…}

max_uvec4 ¶
Source

max_uvec4 :: proc "c" (x, y: [4]u32) -> [4]u32 {…}

max_vec2 ¶
Source

max_vec2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}

max_vec3 ¶
Source

max_vec3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}

max_vec4 ¶
Source

max_vec4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}

min_dvec2 ¶
Source

min_dvec2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}

min_dvec3 ¶
Source

min_dvec3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}

min_dvec4 ¶
Source

min_dvec4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}

min_f32 ¶
Source

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

min_f64 ¶
Source

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

min_i32 ¶
Source

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

min_ivec2 ¶
Source

min_ivec2 :: proc "c" (x, y: [2]i32) -> [2]i32 {…}

min_ivec3 ¶
Source

min_ivec3 :: proc "c" (x, y: [3]i32) -> [3]i32 {…}

min_ivec4 ¶
Source

min_ivec4 :: proc "c" (x, y: [4]i32) -> [4]i32 {…}

min_u32 ¶
Source

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

min_uvec2 ¶
Source

min_uvec2 :: proc "c" (x, y: [2]u32) -> [2]u32 {…}

min_uvec3 ¶
Source

min_uvec3 :: proc "c" (x, y: [3]u32) -> [3]u32 {…}

min_uvec4 ¶
Source

min_uvec4 :: proc "c" (x, y: [4]u32) -> [4]u32 {…}

min_vec2 ¶
Source

min_vec2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}

min_vec3 ¶
Source

min_vec3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}

min_vec4 ¶
Source

min_vec4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}

mix_dvec2 ¶
Source

mix_dvec2 :: proc "c" (x, y, t: [2]f64) -> [2]f64 {…}

mix_dvec3 ¶
Source

mix_dvec3 :: proc "c" (x, y, t: [3]f64) -> [3]f64 {…}

mix_dvec4 ¶
Source

mix_dvec4 :: proc "c" (x, y, t: [4]f64) -> [4]f64 {…}

mix_f32 ¶
Source

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

mix_f64 ¶
Source

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

mix_vec2 ¶
Source

mix_vec2 :: proc "c" (x, y, t: [2]f32) -> [2]f32 {…}

mix_vec3 ¶
Source

mix_vec3 :: proc "c" (x, y, t: [3]f32) -> [3]f32 {…}

mix_vec4 ¶
Source

mix_vec4 :: proc "c" (x, y, t: [4]f32) -> [4]f32 {…}

mod_dvec2 ¶
Source

mod_dvec2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}

mod_dvec3 ¶
Source

mod_dvec3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}

mod_dvec4 ¶
Source

mod_dvec4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}

mod_f32 ¶
Source

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

mod_f64 ¶
Source

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

mod_vec2 ¶
Source

mod_vec2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}

mod_vec3 ¶
Source

mod_vec3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}

mod_vec4 ¶
Source

mod_vec4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}

normalize_dquat ¶
Source

normalize_dquat :: proc "c" (x: quaternion256) -> quaternion256 {…}

normalize_dvec2 ¶
Source

normalize_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

normalize_dvec3 ¶
Source

normalize_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

normalize_dvec4 ¶
Source

normalize_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

normalize_f32 ¶
Source

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

normalize_f64 ¶
Source

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

normalize_quat ¶
Source

normalize_quat :: proc "c" (x: quaternion128) -> quaternion128 {…}

normalize_vec2 ¶
Source

normalize_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

normalize_vec3 ¶
Source

normalize_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

normalize_vec4 ¶
Source

normalize_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

notEqual_dvec2 ¶
Source

notEqual_dvec2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

notEqual_dvec3 ¶
Source

notEqual_dvec3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

notEqual_dvec4 ¶
Source

notEqual_dvec4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

notEqual_f32 ¶
Source

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

notEqual_f64 ¶
Source

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

notEqual_i32 ¶
Source

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

notEqual_ivec2 ¶
Source

notEqual_ivec2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

notEqual_ivec3 ¶
Source

notEqual_ivec3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

notEqual_ivec4 ¶
Source

notEqual_ivec4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

notEqual_u32 ¶
Source

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

notEqual_uvec2 ¶
Source

notEqual_uvec2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

notEqual_uvec3 ¶
Source

notEqual_uvec3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

notEqual_uvec4 ¶
Source

notEqual_uvec4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

notEqual_vec2 ¶
Source

notEqual_vec2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

notEqual_vec3 ¶
Source

notEqual_vec3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

notEqual_vec4 ¶
Source

notEqual_vec4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

not_bool ¶
Source

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

not_bvec2 ¶
Source

not_bvec2 :: proc "c" (v: [2]bool) -> [2]bool {…}

not_bvec3 ¶
Source

not_bvec3 :: proc "c" (v: [3]bool) -> [3]bool {…}

not_bvec4 ¶
Source

not_bvec4 :: proc "c" (v: [4]bool) -> [4]bool {…}

pow_dvec2 ¶
Source

pow_dvec2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}

pow_dvec3 ¶
Source

pow_dvec3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}

pow_dvec4 ¶
Source

pow_dvec4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}

pow_f32 ¶
Source

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

pow_f64 ¶
Source

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

pow_vec2 ¶
Source

pow_vec2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}

pow_vec3 ¶
Source

pow_vec3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}

pow_vec4 ¶
Source

pow_vec4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}

quatAxisAngle ¶
Source

quatAxisAngle :: proc "c" (axis: [3]f32, radians: f32) -> (q: quaternion128) {…}

quatFromMat3 ¶
Source

quatFromMat3 :: proc "c" (m: matrix[3, 3]f32) -> (q: quaternion128) {…}

quatFromMat4 ¶
Source

quatFromMat4 :: proc "c" (m: matrix[4, 4]f32) -> (q: quaternion128) {…}

quatMulVec3 ¶
Source

quatMulVec3 :: proc "c" (q: quaternion128, v: [3]f32) -> [3]f32 {…}

quatNlerp ¶
Source

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

quatSlerp ¶
Source

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

radians_dvec2 ¶
Source

radians_dvec2 :: proc "c" (degrees: [2]f64) -> [2]f64 {…}

radians_dvec3 ¶
Source

radians_dvec3 :: proc "c" (degrees: [3]f64) -> [3]f64 {…}

radians_dvec4 ¶
Source

radians_dvec4 :: proc "c" (degrees: [4]f64) -> [4]f64 {…}

radians_f32 ¶
Source

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

radians_f64 ¶
Source

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

radians_vec2 ¶
Source

radians_vec2 :: proc "c" (degrees: [2]f32) -> [2]f32 {…}

radians_vec3 ¶
Source

radians_vec3 :: proc "c" (degrees: [3]f32) -> [3]f32 {…}

radians_vec4 ¶
Source

radians_vec4 :: proc "c" (degrees: [4]f32) -> [4]f32 {…}

reflect_dvec2 ¶
Source

reflect_dvec2 :: proc "c" (I, N: [2]f64) -> [2]f64 {…}

reflect_dvec3 ¶
Source

reflect_dvec3 :: proc "c" (I, N: [3]f64) -> [3]f64 {…}

reflect_dvec4 ¶
Source

reflect_dvec4 :: proc "c" (I, N: [4]f64) -> [4]f64 {…}

reflect_f32 ¶
Source

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

reflect_f64 ¶
Source

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

reflect_vec2 ¶
Source

reflect_vec2 :: proc "c" (I, N: [2]f32) -> [2]f32 {…}

reflect_vec3 ¶
Source

reflect_vec3 :: proc "c" (I, N: [3]f32) -> [3]f32 {…}

reflect_vec4 ¶
Source

reflect_vec4 :: proc "c" (I, N: [4]f32) -> [4]f32 {…}

refract_dvec2 ¶
Source

refract_dvec2 :: proc "c" (i, n, eta: [2]f64) -> [2]f64 {…}

refract_dvec3 ¶
Source

refract_dvec3 :: proc "c" (i, n, eta: [3]f64) -> [3]f64 {…}

refract_dvec4 ¶
Source

refract_dvec4 :: proc "c" (i, n, eta: [4]f64) -> [4]f64 {…}

refract_f32 ¶
Source

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

refract_f64 ¶
Source

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

refract_vec2 ¶
Source

refract_vec2 :: proc "c" (i, n, eta: [2]f32) -> [2]f32 {…}

refract_vec3 ¶
Source

refract_vec3 :: proc "c" (i, n, eta: [3]f32) -> [3]f32 {…}

refract_vec4 ¶
Source

refract_vec4 :: proc "c" (i, n, eta: [4]f32) -> [4]f32 {…}

round_dvec2 ¶
Source

round_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

round_dvec3 ¶
Source

round_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

round_dvec4 ¶
Source

round_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

round_f32 ¶
Source

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

round_f64 ¶
Source

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

round_vec2 ¶
Source

round_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

round_vec3 ¶
Source

round_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

round_vec4 ¶
Source

round_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

saturate_dvec2 ¶
Source

saturate_dvec2 :: proc "c" (v: [2]f64) -> [2]f64 {…}

saturate_dvec3 ¶
Source

saturate_dvec3 :: proc "c" (v: [3]f64) -> [3]f64 {…}

saturate_dvec4 ¶
Source

saturate_dvec4 :: proc "c" (v: [4]f64) -> [4]f64 {…}

saturate_f32 ¶
Source

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

saturate_f64 ¶
Source

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

saturate_i32 ¶
Source

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

saturate_ivec2 ¶
Source

saturate_ivec2 :: proc "c" (v: [2]i32) -> [2]i32 {…}

saturate_ivec3 ¶
Source

saturate_ivec3 :: proc "c" (v: [3]i32) -> [3]i32 {…}

saturate_ivec4 ¶
Source

saturate_ivec4 :: proc "c" (v: [4]i32) -> [4]i32 {…}

saturate_u32 ¶
Source

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

saturate_uvec2 ¶
Source

saturate_uvec2 :: proc "c" (v: [2]u32) -> [2]u32 {…}

saturate_uvec3 ¶
Source

saturate_uvec3 :: proc "c" (v: [3]u32) -> [3]u32 {…}

saturate_uvec4 ¶
Source

saturate_uvec4 :: proc "c" (v: [4]u32) -> [4]u32 {…}

saturate_vec2 ¶
Source

saturate_vec2 :: proc "c" (v: [2]f32) -> [2]f32 {…}

saturate_vec3 ¶
Source

saturate_vec3 :: proc "c" (v: [3]f32) -> [3]f32 {…}

saturate_vec4 ¶
Source

saturate_vec4 :: proc "c" (v: [4]f32) -> [4]f32 {…}

scalarTripleProduct_dvec3 ¶
Source

scalarTripleProduct_dvec3 :: proc "c" (a, b, c: [3]f64) -> f64 {…}

scalarTripleProduct_ivec3 ¶
Source

scalarTripleProduct_ivec3 :: proc "c" (a, b, c: [3]i32) -> i32 {…}

scalarTripleProduct_vec3 ¶
Source

scalarTripleProduct_vec3 :: proc "c" (a, b, c: [3]f32) -> f32 {…}

sign_dvec2 ¶
Source

sign_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

sign_dvec3 ¶
Source

sign_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

sign_dvec4 ¶
Source

sign_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

sign_f32 ¶
Source

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

sign_f64 ¶
Source

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

sign_i32 ¶
Source

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

sign_ivec2 ¶
Source

sign_ivec2 :: proc "c" (x: [2]i32) -> [2]i32 {…}

sign_ivec3 ¶
Source

sign_ivec3 :: proc "c" (x: [3]i32) -> [3]i32 {…}

sign_ivec4 ¶
Source

sign_ivec4 :: proc "c" (x: [4]i32) -> [4]i32 {…}

sign_u32 ¶
Source

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

sign_uvec2 ¶
Source

sign_uvec2 :: proc "c" (x: [2]u32) -> [2]u32 {…}

sign_uvec3 ¶
Source

sign_uvec3 :: proc "c" (x: [3]u32) -> [3]u32 {…}

sign_uvec4 ¶
Source

sign_uvec4 :: proc "c" (x: [4]u32) -> [4]u32 {…}

sign_vec2 ¶
Source

sign_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

sign_vec3 ¶
Source

sign_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

sign_vec4 ¶
Source

sign_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

sin_dvec2 ¶
Source

sin_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

sin_dvec3 ¶
Source

sin_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

sin_dvec4 ¶
Source

sin_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

sin_f32 ¶
Source

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

sin_f64 ¶
Source

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

sin_vec2 ¶
Source

sin_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

sin_vec3 ¶
Source

sin_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

sin_vec4 ¶
Source

sin_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

sinh_dvec2 ¶
Source

sinh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

sinh_dvec3 ¶
Source

sinh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

sinh_dvec4 ¶
Source

sinh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

sinh_f32 ¶
Source

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

sinh_f64 ¶
Source

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

sinh_vec2 ¶
Source

sinh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

sinh_vec3 ¶
Source

sinh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

sinh_vec4 ¶
Source

sinh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

smoothstep_dvec2 ¶
Source

smoothstep_dvec2 :: proc "c" (edge0, edge1, x: [2]f64) -> [2]f64 {…}

smoothstep_dvec3 ¶
Source

smoothstep_dvec3 :: proc "c" (edge0, edge1, x: [3]f64) -> [3]f64 {…}

smoothstep_dvec4 ¶
Source

smoothstep_dvec4 :: proc "c" (edge0, edge1, x: [4]f64) -> [4]f64 {…}

smoothstep_f32 ¶
Source

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

smoothstep_f64 ¶
Source

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

smoothstep_vec2 ¶
Source

smoothstep_vec2 :: proc "c" (edge0, edge1, x: [2]f32) -> [2]f32 {…}

smoothstep_vec3 ¶
Source

smoothstep_vec3 :: proc "c" (edge0, edge1, x: [3]f32) -> [3]f32 {…}

smoothstep_vec4 ¶
Source

smoothstep_vec4 :: proc "c" (edge0, edge1, x: [4]f32) -> [4]f32 {…}

sqrt_dvec2 ¶
Source

sqrt_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

sqrt_dvec3 ¶
Source

sqrt_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

sqrt_dvec4 ¶
Source

sqrt_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

sqrt_f32 ¶
Source

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

sqrt_f64 ¶
Source

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

sqrt_vec2 ¶
Source

sqrt_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

sqrt_vec3 ¶
Source

sqrt_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

sqrt_vec4 ¶
Source

sqrt_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

step_dvec2 ¶
Source

step_dvec2 :: proc "c" (edge, x: [2]f64) -> [2]f64 {…}

step_dvec3 ¶
Source

step_dvec3 :: proc "c" (edge, x: [3]f64) -> [3]f64 {…}

step_dvec4 ¶
Source

step_dvec4 :: proc "c" (edge, x: [4]f64) -> [4]f64 {…}

step_f32 ¶
Source

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

step_f64 ¶
Source

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

step_vec2 ¶
Source

step_vec2 :: proc "c" (edge, x: [2]f32) -> [2]f32 {…}

step_vec3 ¶
Source

step_vec3 :: proc "c" (edge, x: [3]f32) -> [3]f32 {…}

step_vec4 ¶
Source

step_vec4 :: proc "c" (edge, x: [4]f32) -> [4]f32 {…}

tan_dvec2 ¶
Source

tan_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

tan_dvec3 ¶
Source

tan_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

tan_dvec4 ¶
Source

tan_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

tan_f32 ¶
Source

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

tan_f64 ¶
Source

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

tan_vec2 ¶
Source

tan_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

tan_vec3 ¶
Source

tan_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

tan_vec4 ¶
Source

tan_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

tanh_dvec2 ¶
Source

tanh_dvec2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

tanh_dvec3 ¶
Source

tanh_dvec3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

tanh_dvec4 ¶
Source

tanh_dvec4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

tanh_f32 ¶
Source

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

tanh_f64 ¶
Source

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

tanh_vec2 ¶
Source

tanh_vec2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

tanh_vec3 ¶
Source

tanh_vec3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

tanh_vec4 ¶
Source

tanh_vec4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

trace ¶
Source

trace :: proc "contextless" (m: $/matrix[0, 0]$T) -> (trace: $T) {…}

transpose ¶

transpose :: intrinsics.transpose

vectorTripleProduct_dvec3 ¶
Source

vectorTripleProduct_dvec3 :: proc "c" (a, b, c: [3]f64) -> [3]f64 {…}

vectorTripleProduct_ivec3 ¶
Source

vectorTripleProduct_ivec3 :: proc "c" (a, b, c: [3]i32) -> [3]i32 {…}

vectorTripleProduct_vec3 ¶
Source

vectorTripleProduct_vec3 :: proc "c" (a, b, c: [3]f32) -> [3]f32 {…}

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{
	adjugate_matrix1x1,
	adjugate_matrix2x2,
	adjugate_matrix3x3,
	adjugate_matrix4x4,
}

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{
	determinant_matrix1x1,
	determinant_matrix2x2,
	determinant_matrix3x3,
	determinant_matrix4x4,
}

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_matrix1x1,
	inverse_matrix2x2,
	inverse_matrix3x3,
	inverse_matrix4x4,
}

inverse_transpose ¶
Source

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

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-2024-12 (vendor "odin") Windows_amd64 @ 2024-12-17 21:11:01.115816400 +0000 UTC