core/math/linalg/glsl package | Odin Programming Language

`GLSL`-like mathematics library plus numerous other utility procedures.

Collection Info

View Source

Collection: core
Path: math/linalg/glsl
Entries: 712

Constants 13

Jump to Constants

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

Types 41

Jump to Types

bvec2 bvec3 bvec4 dmat2 dmat2x2 dmat2x3 dmat2x4 dmat3 dmat3x2 dmat3x3 dmat3x4 dmat4 dmat4x2 dmat4x3 dmat4x4 dquat +25 more

Procedures 594

Jump to Procedures

abs_dvec2 abs_dvec3 abs_dvec4 abs_f32 abs_f64 abs_i32 abs_ivec2 abs_ivec3 abs_ivec4 abs_u32 abs_uvec2 abs_uvec3 abs_uvec4 abs_vec2 abs_vec3 abs_vec4 +578 more

Procedure Groups 64

Jump to Procedure Groups

abs acos acosh adjugate all any asin asinh atan atan2 atanh ceil clamp cofactor cos cosh +48 more

Variables 0

Source Files

Constants

e #

Source

e :: E

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

π #

Source

π :: PI

τ #

Source

τ :: TAU

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

Procedures

594

abs_dvec2 #

Source

@(require_results)

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

abs_dvec3 #

Source

@(require_results)

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

abs_dvec4 #

Source

@(require_results)

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

abs_f32 #

Source

@(require_results)

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

abs_f64 #

Source

@(require_results)

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

abs_i32 #

Source

@(require_results)

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

abs_ivec2 #

Source

@(require_results)

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

abs_ivec3 #

Source

@(require_results)

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

abs_ivec4 #

Source

@(require_results)

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

abs_u32 #

Source

@(require_results)

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

abs_uvec2 #

Source

@(require_results)

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

abs_uvec3 #

Source

@(require_results)

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

abs_uvec4 #

Source

@(require_results)

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

abs_vec2 #

Source

@(require_results)

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

abs_vec3 #

Source

@(require_results)

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

abs_vec4 #

Source

@(require_results)

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

acos_dvec2 #

Source

@(require_results)

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

acos_dvec3 #

Source

@(require_results)

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

acos_dvec4 #

Source

@(require_results)

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

acos_f32 #

Source

@(require_results)

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

acos_f64 #

Source

@(require_results)

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

acos_vec2 #

Source

@(require_results)

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

acos_vec3 #

Source

@(require_results)

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

acos_vec4 #

Source

@(require_results)

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

acosh_dvec2 #

Source

@(require_results)

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

acosh_dvec3 #

Source

@(require_results)

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

acosh_dvec4 #

Source

@(require_results)

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

acosh_f32 #

Source

@(require_results)

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

acosh_f64 #

Source

@(require_results)

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

acosh_vec2 #

Source

@(require_results)

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

acosh_vec3 #

Source

@(require_results)

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

acosh_vec4 #

Source

@(require_results)

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

adjugate_matrix1x1 #

Source

@(require_results)

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

adjugate_matrix2x2 #

Source

@(require_results)

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

adjugate_matrix3x3 #

Source

@(require_results)

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

adjugate_matrix4x4 #

Source

@(require_results)

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

all_bool #

Source

@(require_results)

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

all_bvec2 #

Source

@(require_results)

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

all_bvec3 #

Source

@(require_results)

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

all_bvec4 #

Source

@(require_results)

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

any_bool #

Source

@(require_results)

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

any_bvec2 #

Source

@(require_results)

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

any_bvec3 #

Source

@(require_results)

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

any_bvec4 #

Source

@(require_results)

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

asin_dvec2 #

Source

@(require_results)

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

asin_dvec3 #

Source

@(require_results)

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

asin_dvec4 #

Source

@(require_results)

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

asin_f32 #

Source

@(require_results)

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

asin_f64 #

Source

@(require_results)

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

asin_vec2 #

Source

@(require_results)

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

asin_vec3 #

Source

@(require_results)

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

asin_vec4 #

Source

@(require_results)

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

asinh_dvec2 #

Source

@(require_results)

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

asinh_dvec3 #

Source

@(require_results)

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

asinh_dvec4 #

Source

@(require_results)

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

asinh_f32 #

Source

@(require_results)

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

asinh_f64 #

Source

@(require_results)

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

asinh_vec2 #

Source

@(require_results)

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

asinh_vec3 #

Source

@(require_results)

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

asinh_vec4 #

Source

@(require_results)

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

atan_dvec2 #

Source

@(require_results)

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

atan_dvec3 #

Source

@(require_results)

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

atan_dvec4 #

Source

@(require_results)

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

atan_f32 #

Source

@(require_results)

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

atan_f64 #

Source

@(require_results)

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

atan_vec2 #

Source

@(require_results)

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

atan_vec3 #

Source

@(require_results)

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

atan_vec4 #

Source

@(require_results)

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

atan2_dvec2 #

Source

@(require_results)

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

atan2_dvec3 #

Source

@(require_results)

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

atan2_dvec4 #

Source

@(require_results)

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

atan2_f32 #

Source

@(require_results)

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

atan2_f64 #

Source

@(require_results)

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

atan2_vec2 #

Source

@(require_results)

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

atan2_vec3 #

Source

@(require_results)

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

atan2_vec4 #

Source

@(require_results)

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

atanh_dvec2 #

Source

@(require_results)

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

atanh_dvec3 #

Source

@(require_results)

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

atanh_dvec4 #

Source

@(require_results)

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

atanh_f32 #

Source

@(require_results)

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

atanh_f64 #

Source

@(require_results)

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

atanh_vec2 #

Source

@(require_results)

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

atanh_vec3 #

Source

@(require_results)

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

atanh_vec4 #

Source

@(require_results)

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

ceil_dvec2 #

Source

@(require_results)

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

ceil_dvec3 #

Source

@(require_results)

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

ceil_dvec4 #

Source

@(require_results)

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

ceil_f32 #

Source

@(require_results)

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

ceil_f64 #

Source

@(require_results)

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

ceil_vec2 #

Source

@(require_results)

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

ceil_vec3 #

Source

@(require_results)

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

ceil_vec4 #

Source

@(require_results)

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

clamp_dvec2 #

Source

@(require_results)

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

clamp_dvec3 #

Source

@(require_results)

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

clamp_dvec4 #

Source

@(require_results)

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

clamp_f32 #

Source

@(require_results)

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

clamp_f64 #

Source

@(require_results)

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

clamp_i32 #

Source

@(require_results)

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

clamp_ivec2 #

Source

@(require_results)

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

clamp_ivec3 #

Source

@(require_results)

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

clamp_ivec4 #

Source

@(require_results)

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

clamp_u32 #

Source

@(require_results)

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

clamp_uvec2 #

Source

@(require_results)

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

clamp_uvec3 #

Source

@(require_results)

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

clamp_uvec4 #

Source

@(require_results)

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

clamp_vec2 #

Source

@(require_results)

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

clamp_vec3 #

Source

@(require_results)

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

clamp_vec4 #

Source

@(require_results)

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

cofactor_matrix1x1 #

Source

@(require_results)

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

cofactor_matrix2x2 #

Source

@(require_results)

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

cofactor_matrix3x3 #

Source

@(require_results)

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

cofactor_matrix4x4 #

Source

@(require_results)

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

cos_dvec2 #

Source

@(require_results)

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

cos_dvec3 #

Source

@(require_results)

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

cos_dvec4 #

Source

@(require_results)

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

cos_f32 #

Source

@(require_results)

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

cos_f64 #

Source

@(require_results)

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

cos_vec2 #

Source

@(require_results)

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

cos_vec3 #

Source

@(require_results)

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

cos_vec4 #

Source

@(require_results)

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

cosh_dvec2 #

Source

@(require_results)

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

cosh_dvec3 #

Source

@(require_results)

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

cosh_dvec4 #

Source

@(require_results)

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

cosh_f32 #

Source

@(require_results)

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

cosh_f64 #

Source

@(require_results)

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

cosh_vec2 #

Source

@(require_results)

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

cosh_vec3 #

Source

@(require_results)

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

cosh_vec4 #

Source

@(require_results)

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

cross_dvec3 #

Source

@(require_results)

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

cross_ivec3 #

Source

@(require_results)

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

cross_vec3 #

Source

@(require_results)

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

degrees_dvec2 #

Source

@(require_results)

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

degrees_dvec3 #

Source

@(require_results)

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

degrees_dvec4 #

Source

@(require_results)

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

degrees_f32 #

Source

@(require_results)

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

degrees_f64 #

Source

@(require_results)

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

degrees_vec2 #

Source

@(require_results)

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

degrees_vec3 #

Source

@(require_results)

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

degrees_vec4 #

Source

@(require_results)

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

determinant_matrix1x1 #

Source

@(require_results)

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

determinant_matrix2x2 #

Source

@(require_results)

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

determinant_matrix3x3 #

Source

@(require_results)

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

determinant_matrix4x4 #

Source

@(require_results)

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

distance_dvec2 #

Source

@(require_results)

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

distance_dvec3 #

Source

@(require_results)

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

distance_dvec4 #

Source

@(require_results)

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

distance_f32 #

Source

@(require_results)

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

distance_f64 #

Source

@(require_results)

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

distance_vec2 #

Source

@(require_results)

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

distance_vec3 #

Source

@(require_results)

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

distance_vec4 #

Source

@(require_results)

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

dmat4FromDquat #

Source

@(require_results)

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

dmat4LookAt #

Source

@(require_results)

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

dmat4Orientation #

Source

@(require_results)

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

dmat4Ortho3d #

Source

@(require_results)

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

dmat4Perspective #

Source

@(require_results)

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

dmat4PerspectiveInfinite #

Source

@(require_results)

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

dmat4Rotate #

Source

@(require_results)

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

dmat4Scale #

Source

@(require_results)

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

dmat4Translate #

Source

@(require_results)

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

dot_dquat #

Source

@(require_results)

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

dot_dvec2 #

Source

@(require_results)

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

dot_dvec3 #

Source

@(require_results)

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

dot_dvec4 #

Source

@(require_results)

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

dot_f32 #

Source

@(require_results)

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

dot_f64 #

Source

@(require_results)

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

dot_i32 #

Source

@(require_results)

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

dot_ivec2 #

Source

@(require_results)

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

dot_ivec3 #

Source

@(require_results)

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

dot_ivec4 #

Source

@(require_results)

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

dot_quat #

Source

@(require_results)

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

dot_u32 #

Source

@(require_results)

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

dot_uvec2 #

Source

@(require_results)

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

dot_uvec3 #

Source

@(require_results)

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

dot_uvec4 #

Source

@(require_results)

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

dot_vec2 #

Source

@(require_results)

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

dot_vec3 #

Source

@(require_results)

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

dot_vec4 #

Source

@(require_results)

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

dquatAxisAngle #

Source

@(require_results)

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

dquatFromdMat3 #

Source

@(require_results)

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

dquatFromDmat4 #

Source

@(require_results)

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

dquatMulDvec3 #

Source

@(require_results)

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

dquatNlerp #

Source

@(require_results)

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

dquatSlerp #

Source

@(require_results)

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

equal_dvec2 #

Source

@(require_results)

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

equal_dvec3 #

Source

@(require_results)

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

equal_dvec4 #

Source

@(require_results)

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

equal_f32 #

Source

@(require_results)

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

equal_f64 #

Source

@(require_results)

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

equal_i32 #

Source

@(require_results)

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

equal_ivec2 #

Source

@(require_results)

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

equal_ivec3 #

Source

@(require_results)

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

equal_ivec4 #

Source

@(require_results)

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

equal_u32 #

Source

@(require_results)

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

equal_uvec2 #

Source

@(require_results)

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

equal_uvec3 #

Source

@(require_results)

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

equal_uvec4 #

Source

@(require_results)

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

equal_vec2 #

Source

@(require_results)

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

equal_vec3 #

Source

@(require_results)

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

equal_vec4 #

Source

@(require_results)

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

exp_dvec2 #

Source

@(require_results)

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

exp_dvec3 #

Source

@(require_results)

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

exp_dvec4 #

Source

@(require_results)

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

exp_f32 #

Source

@(require_results)

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

exp_f64 #

Source

@(require_results)

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

exp_vec2 #

Source

@(require_results)

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

exp_vec3 #

Source

@(require_results)

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

exp_vec4 #

Source

@(require_results)

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

exp2_dvec2 #

Source

@(require_results)

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

exp2_dvec3 #

Source

@(require_results)

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

exp2_dvec4 #

Source

@(require_results)

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

exp2_f32 #

Source

@(require_results)

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

exp2_f64 #

Source

@(require_results)

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

exp2_vec2 #

Source

@(require_results)

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

exp2_vec3 #

Source

@(require_results)

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

exp2_vec4 #

Source

@(require_results)

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

faceForward_dvec2 #

Source

@(require_results)

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

faceForward_dvec3 #

Source

@(require_results)

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

faceForward_dvec4 #

Source

@(require_results)

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

faceForward_f32 #

Source

@(require_results)

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

faceForward_f64 #

Source

@(require_results)

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

faceForward_vec2 #

Source

@(require_results)

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

faceForward_vec3 #

Source

@(require_results)

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

faceForward_vec4 #

Source

@(require_results)

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

floor_dvec2 #

Source

@(require_results)

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

floor_dvec3 #

Source

@(require_results)

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

floor_dvec4 #

Source

@(require_results)

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

floor_f32 #

Source

@(require_results)

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

floor_f64 #

Source

@(require_results)

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

floor_vec2 #

Source

@(require_results)

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

floor_vec3 #

Source

@(require_results)

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

floor_vec4 #

Source

@(require_results)

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

fract_dvec2 #

Source

@(require_results)

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

fract_dvec3 #

Source

@(require_results)

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

fract_dvec4 #

Source

@(require_results)

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

fract_f32 #

Source

@(require_results)

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

fract_f64 #

Source

@(require_results)

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

fract_vec2 #

Source

@(require_results)

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

fract_vec3 #

Source

@(require_results)

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

fract_vec4 #

Source

@(require_results)

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

greaterThan_dvec2 #

Source

@(require_results)

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

greaterThan_dvec3 #

Source

@(require_results)

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

greaterThan_dvec4 #

Source

@(require_results)

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

greaterThan_f32 #

Source

@(require_results)

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

greaterThan_f64 #

Source

@(require_results)

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

greaterThan_i32 #

Source

@(require_results)

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

greaterThan_ivec2 #

Source

@(require_results)

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

greaterThan_ivec3 #

Source

@(require_results)

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

greaterThan_ivec4 #

Source

@(require_results)

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

greaterThan_u32 #

Source

@(require_results)

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

greaterThan_uvec2 #

Source

@(require_results)

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

greaterThan_uvec3 #

Source

@(require_results)

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

greaterThan_uvec4 #

Source

@(require_results)

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

greaterThan_vec2 #

Source

@(require_results)

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

greaterThan_vec3 #

Source

@(require_results)

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

greaterThan_vec4 #

Source

@(require_results)

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

greaterThanEqual_dvec2 #

Source

@(require_results)

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

greaterThanEqual_dvec3 #

Source

@(require_results)

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

greaterThanEqual_dvec4 #

Source

@(require_results)

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

greaterThanEqual_f32 #

Source

@(require_results)

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

greaterThanEqual_f64 #

Source

@(require_results)

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

greaterThanEqual_i32 #

Source

@(require_results)

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

greaterThanEqual_ivec2 #

Source

@(require_results)

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

greaterThanEqual_ivec3 #

Source

@(require_results)

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

greaterThanEqual_ivec4 #

Source

@(require_results)

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

greaterThanEqual_u32 #

Source

@(require_results)

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

greaterThanEqual_uvec2 #

Source

@(require_results)

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

greaterThanEqual_uvec3 #

Source

@(require_results)

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

greaterThanEqual_uvec4 #

Source

@(require_results)

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

greaterThanEqual_vec2 #

Source

@(require_results)

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

greaterThanEqual_vec3 #

Source

@(require_results)

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

greaterThanEqual_vec4 #

Source

@(require_results)

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

hermitian_adjoint #

Source

@(require_results)

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

identity #

Source

@(require_results)

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

inverse_dmat2 #

Source

@(require_results)

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

inverse_dmat3 #

Source

@(require_results)

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

inverse_dmat4 #

Source

@(require_results)

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

inverse_dquat #

Source

@(require_results)

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

inverse_mat2 #

Source

@(require_results)

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

inverse_mat3 #

Source

@(require_results)

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

inverse_mat4 #

Source

@(require_results)

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

inverse_matrix1x1 #

Source

@(require_results)

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

inverse_matrix2x2 #

Source

@(require_results)

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

inverse_matrix3x3 #

Source

@(require_results)

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

inverse_matrix4x4 #

Source

@(require_results)

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

inverse_quat #

Source

@(require_results)

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

inverse_transpose_matrix1x1 #

Source

@(require_results)

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

inverse_transpose_matrix2x2 #

Source

@(require_results)

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

inverse_transpose_matrix3x3 #

Source

@(require_results)

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

inverse_transpose_matrix4x4 #

Source

@(require_results)

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

inversesqrt_dvec2 #

Source

@(require_results)

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

inversesqrt_dvec3 #

Source

@(require_results)

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

inversesqrt_dvec4 #

Source

@(require_results)

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

inversesqrt_f32 #

Source

@(require_results)

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

inversesqrt_f64 #

Source

@(require_results)

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

inversesqrt_vec2 #

Source

@(require_results)

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

inversesqrt_vec3 #

Source

@(require_results)

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

inversesqrt_vec4 #

Source

@(require_results)

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

length_dquat #

Source

@(require_results)

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

length_dvec2 #

Source

@(require_results)

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

length_dvec3 #

Source

@(require_results)

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

length_dvec4 #

Source

@(require_results)

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

length_f32 #

Source

@(require_results)

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

length_f64 #

Source

@(require_results)

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

length_quat #

Source

@(require_results)

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

length_vec2 #

Source

@(require_results)

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

length_vec3 #

Source

@(require_results)

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

length_vec4 #

Source

@(require_results)

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

lerp_dvec2 #

Source

@(require_results)

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

lerp_dvec3 #

Source

@(require_results)

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

lerp_dvec4 #

Source

@(require_results)

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

lerp_f32 #

Source

@(require_results)

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

lerp_f64 #

Source

@(require_results)

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

lerp_vec2 #

Source

@(require_results)

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

lerp_vec3 #

Source

@(require_results)

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

lerp_vec4 #

Source

@(require_results)

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

lessThan_dvec2 #

Source

@(require_results)

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

lessThan_dvec3 #

Source

@(require_results)

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

lessThan_dvec4 #

Source

@(require_results)

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

lessThan_f32 #

Source

@(require_results)

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

lessThan_f64 #

Source

@(require_results)

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

lessThan_i32 #

Source

@(require_results)

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

lessThan_ivec2 #

Source

@(require_results)

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

lessThan_ivec3 #

Source

@(require_results)

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

lessThan_ivec4 #

Source

@(require_results)

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

lessThan_u32 #

Source

@(require_results)

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

lessThan_uvec2 #

Source

@(require_results)

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

lessThan_uvec3 #

Source

@(require_results)

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

lessThan_uvec4 #

Source

@(require_results)

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

lessThan_vec2 #

Source

@(require_results)

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

lessThan_vec3 #

Source

@(require_results)

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

lessThan_vec4 #

Source

@(require_results)

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

lessThanEqual_dvec2 #

Source

@(require_results)

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

lessThanEqual_dvec3 #

Source

@(require_results)

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

lessThanEqual_dvec4 #

Source

@(require_results)

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

lessThanEqual_f32 #

Source

@(require_results)

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

lessThanEqual_f64 #

Source

@(require_results)

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

lessThanEqual_i32 #

Source

@(require_results)

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

lessThanEqual_ivec2 #

Source

@(require_results)

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

lessThanEqual_ivec3 #

Source

@(require_results)

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

lessThanEqual_ivec4 #

Source

@(require_results)

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

lessThanEqual_u32 #

Source

@(require_results)

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

lessThanEqual_uvec2 #

Source

@(require_results)

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

lessThanEqual_uvec3 #

Source

@(require_results)

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

lessThanEqual_uvec4 #

Source

@(require_results)

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

lessThanEqual_vec2 #

Source

@(require_results)

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

lessThanEqual_vec3 #

Source

@(require_results)

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

lessThanEqual_vec4 #

Source

@(require_results)

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

log_dvec2 #

Source

@(require_results)

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

log_dvec3 #

Source

@(require_results)

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

log_dvec4 #

Source

@(require_results)

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

log_f32 #

Source

@(require_results)

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

log_f64 #

Source

@(require_results)

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

log_vec2 #

Source

@(require_results)

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

log_vec3 #

Source

@(require_results)

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

log_vec4 #

Source

@(require_results)

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

mat4FromQuat #

Source

@(require_results)

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

mat4LookAt #

Source

@(require_results)

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

mat4Orientation #

Source

@(require_results)

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

mat4Ortho3d #

Source

@(require_results)

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

mat4Perspective #

Source

@(require_results)

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

mat4PerspectiveInfinite #

Source

@(require_results)

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

mat4Rotate #

Source

@(require_results)

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

mat4Scale #

Source

@(require_results)

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

mat4Translate #

Source

@(require_results)

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

matrix_minor #

Source

@(require_results)

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

max_dvec2 #

Source

@(require_results)

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

max_dvec3 #

Source

@(require_results)

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

max_dvec4 #

Source

@(require_results)

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

max_f32 #

Source

@(require_results)

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

max_f64 #

Source

@(require_results)

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

max_i32 #

Source

@(require_results)

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

max_ivec2 #

Source

@(require_results)

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

max_ivec3 #

Source

@(require_results)

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

max_ivec4 #

Source

@(require_results)

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

max_u32 #

Source

@(require_results)

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

max_uvec2 #

Source

@(require_results)

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

max_uvec3 #

Source

@(require_results)

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

max_uvec4 #

Source

@(require_results)

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

max_vec2 #

Source

@(require_results)

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

max_vec3 #

Source

@(require_results)

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

max_vec4 #

Source

@(require_results)

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

min_dvec2 #

Source

@(require_results)

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

min_dvec3 #

Source

@(require_results)

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

min_dvec4 #

Source

@(require_results)

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

min_f32 #

Source

@(require_results)

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

min_f64 #

Source

@(require_results)

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

min_i32 #

Source

@(require_results)

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

min_ivec2 #

Source

@(require_results)

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

min_ivec3 #

Source

@(require_results)

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

min_ivec4 #

Source

@(require_results)

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

min_u32 #

Source

@(require_results)

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

min_uvec2 #

Source

@(require_results)

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

min_uvec3 #

Source

@(require_results)

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

min_uvec4 #

Source

@(require_results)

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

min_vec2 #

Source

@(require_results)

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

min_vec3 #

Source

@(require_results)

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

min_vec4 #

Source

@(require_results)

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

mix_dvec2 #

Source

@(require_results)

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

mix_dvec3 #

Source

@(require_results)

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

mix_dvec4 #

Source

@(require_results)

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

mix_f32 #

Source

@(require_results)

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

mix_f64 #

Source

@(require_results)

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

mix_vec2 #

Source

@(require_results)

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

mix_vec3 #

Source

@(require_results)

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

mix_vec4 #

Source

@(require_results)

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

mod_dvec2 #

Source

@(require_results)

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

mod_dvec3 #

Source

@(require_results)

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

mod_dvec4 #

Source

@(require_results)

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

mod_f32 #

Source

@(require_results)

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

mod_f64 #

Source

@(require_results)

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

mod_vec2 #

Source

@(require_results)

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

mod_vec3 #

Source

@(require_results)

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

mod_vec4 #

Source

@(require_results)

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

normalize_dquat #

Source

@(require_results)

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

normalize_dvec2 #

Source

@(require_results)

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

normalize_dvec3 #

Source

@(require_results)

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

normalize_dvec4 #

Source

@(require_results)

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

normalize_f32 #

Source

@(require_results)

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

normalize_f64 #

Source

@(require_results)

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

normalize_quat #

Source

@(require_results)

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

normalize_vec2 #

Source

@(require_results)

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

normalize_vec3 #

Source

@(require_results)

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

normalize_vec4 #

Source

@(require_results)

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

not_bool #

Source

@(require_results)

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

not_bvec2 #

Source

@(require_results)

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

not_bvec3 #

Source

@(require_results)

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

not_bvec4 #

Source

@(require_results)

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

notEqual_dvec2 #

Source

@(require_results)

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

notEqual_dvec3 #

Source

@(require_results)

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

notEqual_dvec4 #

Source

@(require_results)

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

notEqual_f32 #

Source

@(require_results)

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

notEqual_f64 #

Source

@(require_results)

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

notEqual_i32 #

Source

@(require_results)

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

notEqual_ivec2 #

Source

@(require_results)

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

notEqual_ivec3 #

Source

@(require_results)

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

notEqual_ivec4 #

Source

@(require_results)

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

notEqual_u32 #

Source

@(require_results)

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

notEqual_uvec2 #

Source

@(require_results)

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

notEqual_uvec3 #

Source

@(require_results)

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

notEqual_uvec4 #

Source

@(require_results)

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

notEqual_vec2 #

Source

@(require_results)

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

notEqual_vec3 #

Source

@(require_results)

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

notEqual_vec4 #

Source

@(require_results)

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

pow_dvec2 #

Source

@(require_results)

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

pow_dvec3 #

Source

@(require_results)

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

pow_dvec4 #

Source

@(require_results)

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

pow_f32 #

Source

@(require_results)

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

pow_f64 #

Source

@(require_results)

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

pow_vec2 #

Source

@(require_results)

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

pow_vec3 #

Source

@(require_results)

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

pow_vec4 #

Source

@(require_results)

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

quatAxisAngle #

Source

@(require_results)

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

quatFromMat3 #

Source

@(require_results)

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

quatFromMat4 #

Source

@(require_results)

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

quatMulVec3 #

Source

@(require_results)

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

quatNlerp #

Source

@(require_results)

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

quatSlerp #

Source

@(require_results)

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

radians_dvec2 #

Source

@(require_results)

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

radians_dvec3 #

Source

@(require_results)

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

radians_dvec4 #

Source

@(require_results)

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

radians_f32 #

Source

@(require_results)

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

radians_f64 #

Source

@(require_results)

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

radians_vec2 #

Source

@(require_results)

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

radians_vec3 #

Source

@(require_results)

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

radians_vec4 #

Source

@(require_results)

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

reflect_dvec2 #

Source

@(require_results)

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

reflect_dvec3 #

Source

@(require_results)

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

reflect_dvec4 #

Source

@(require_results)

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

reflect_f32 #

Source

@(require_results)

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

reflect_f64 #

Source

@(require_results)

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

reflect_vec2 #

Source

@(require_results)

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

reflect_vec3 #

Source

@(require_results)

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

reflect_vec4 #

Source

@(require_results)

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

refract_dvec2 #

Source

@(require_results)

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

refract_dvec3 #

Source

@(require_results)

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

refract_dvec4 #

Source

@(require_results)

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

refract_f32 #

Source

@(require_results)

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

refract_f64 #

Source

@(require_results)

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

refract_vec2 #

Source

@(require_results)

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

refract_vec3 #

Source

@(require_results)

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

refract_vec4 #

Source

@(require_results)

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

round_dvec2 #

Source

@(require_results)

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

round_dvec3 #

Source

@(require_results)

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

round_dvec4 #

Source

@(require_results)

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

round_f32 #

Source

@(require_results)

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

round_f64 #

Source

@(require_results)

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

round_vec2 #

Source

@(require_results)

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

round_vec3 #

Source

@(require_results)

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

round_vec4 #

Source

@(require_results)

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

saturate_dvec2 #

Source

@(require_results)

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

saturate_dvec3 #

Source

@(require_results)

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

saturate_dvec4 #

Source

@(require_results)

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

saturate_f32 #

Source

@(require_results)

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

saturate_f64 #

Source

@(require_results)

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

saturate_i32 #

Source

@(require_results)

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

saturate_ivec2 #

Source

@(require_results)

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

saturate_ivec3 #

Source

@(require_results)

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

saturate_ivec4 #

Source

@(require_results)

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

saturate_u32 #

Source

@(require_results)

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

saturate_uvec2 #

Source

@(require_results)

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

saturate_uvec3 #

Source

@(require_results)

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

saturate_uvec4 #

Source

@(require_results)

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

saturate_vec2 #

Source

@(require_results)

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

saturate_vec3 #

Source

@(require_results)

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

saturate_vec4 #

Source

@(require_results)

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

scalarTripleProduct_dvec3 #

Source

@(require_results)

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

scalarTripleProduct_ivec3 #

Source

@(require_results)

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

scalarTripleProduct_vec3 #

Source

@(require_results)

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

sign_dvec2 #

Source

@(require_results)

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

sign_dvec3 #

Source

@(require_results)

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

sign_dvec4 #

Source

@(require_results)

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

sign_f32 #

Source

@(require_results)

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

sign_f64 #

Source

@(require_results)

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

sign_i32 #

Source

@(require_results)

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

sign_ivec2 #

Source

@(require_results)

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

sign_ivec3 #

Source

@(require_results)

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

sign_ivec4 #

Source

@(require_results)

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

sign_u32 #

Source

@(require_results)

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

sign_uvec2 #

Source

@(require_results)

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

sign_uvec3 #

Source

@(require_results)

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

sign_uvec4 #

Source

@(require_results)

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

sign_vec2 #

Source

@(require_results)

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

sign_vec3 #

Source

@(require_results)

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

sign_vec4 #

Source

@(require_results)

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

sin_dvec2 #

Source

@(require_results)

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

sin_dvec3 #

Source

@(require_results)

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

sin_dvec4 #

Source

@(require_results)

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

sin_f32 #

Source

@(require_results)

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

sin_f64 #

Source

@(require_results)

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

sin_vec2 #

Source

@(require_results)

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

sin_vec3 #

Source

@(require_results)

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

sin_vec4 #

Source

@(require_results)

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

sinh_dvec2 #

Source

@(require_results)

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

sinh_dvec3 #

Source

@(require_results)

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

sinh_dvec4 #

Source

@(require_results)

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

sinh_f32 #

Source

@(require_results)

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

sinh_f64 #

Source

@(require_results)

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

sinh_vec2 #

Source

@(require_results)

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

sinh_vec3 #

Source

@(require_results)

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

sinh_vec4 #

Source

@(require_results)

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

smoothstep_dvec2 #

Source

@(require_results)

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

smoothstep_dvec3 #

Source

@(require_results)

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

smoothstep_dvec4 #

Source

@(require_results)

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

smoothstep_f32 #

Source

@(require_results)

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

smoothstep_f64 #

Source

@(require_results)

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

smoothstep_vec2 #

Source

@(require_results)

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

smoothstep_vec3 #

Source

@(require_results)

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

smoothstep_vec4 #

Source

@(require_results)

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

sqrt_dvec2 #

Source

@(require_results)

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

sqrt_dvec3 #

Source

@(require_results)

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

sqrt_dvec4 #

Source

@(require_results)

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

sqrt_f32 #

Source

@(require_results)

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

sqrt_f64 #

Source

@(require_results)

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

sqrt_vec2 #

Source

@(require_results)

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

sqrt_vec3 #

Source

@(require_results)

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

sqrt_vec4 #

Source

@(require_results)

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

step_dvec2 #

Source

@(require_results)

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

step_dvec3 #

Source

@(require_results)

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

step_dvec4 #

Source

@(require_results)

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

step_f32 #

Source

@(require_results)

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

step_f64 #

Source

@(require_results)

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

step_vec2 #

Source

@(require_results)

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

step_vec3 #

Source

@(require_results)

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

step_vec4 #

Source

@(require_results)

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

tan_dvec2 #

Source

@(require_results)

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

tan_dvec3 #

Source

@(require_results)

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

tan_dvec4 #

Source

@(require_results)

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

tan_f32 #

Source

@(require_results)

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

tan_f64 #

Source

@(require_results)

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

tan_vec2 #

Source

@(require_results)

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

tan_vec3 #

Source

@(require_results)

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

tan_vec4 #

Source

@(require_results)

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

tanh_dvec2 #

Source

@(require_results)

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

tanh_dvec3 #

Source

@(require_results)

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

tanh_dvec4 #

Source

@(require_results)

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

tanh_f32 #

Source

@(require_results)

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

tanh_f64 #

Source

@(require_results)

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

tanh_vec2 #

Source

@(require_results)

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

tanh_vec3 #

Source

@(require_results)

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

tanh_vec4 #

Source

@(require_results)

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

trace #

Source

@(require_results)

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

transpose #

Source

transpose :: invalid type {…}

trunc_dvec2 #

Source

@(require_results)

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

trunc_dvec3 #

Source

@(require_results)

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

trunc_dvec4 #

Source

@(require_results)

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

trunc_f32 #

Source

@(require_results)

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

trunc_f64 #

Source

@(require_results)

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

trunc_vec2 #

Source

@(require_results)

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

trunc_vec3 #

Source

@(require_results)

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

trunc_vec4 #

Source

@(require_results)

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

vectorTripleProduct_dvec3 #

Source

@(require_results)

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

vectorTripleProduct_ivec3 #

Source

@(require_results)

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

vectorTripleProduct_vec3 #

Source

@(require_results)

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

cofactor #

Source

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

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

trunc #

Source

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

vectorTripleProduct #

Source

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