package core:math/linalg/glsl

⌘K
Ctrl+K
or
/

    Overview

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

    Index

    Variables (0)

    This section is empty.

    Procedures (582)

    Types

    bvec2 ¶

    bvec2 :: [2]bool

    bvec3 ¶

    bvec3 :: [3]bool

    bvec4 ¶

    bvec4 :: [4]bool

    dmat2 ¶

    dmat2 :: matrix[2, 2]f64

    dmat2x2 ¶

    dmat2x2 :: matrix[2, 2]f64

    dmat2x3 ¶

    dmat2x3 :: matrix[3, 2]f64

    dmat2x4 ¶

    dmat2x4 :: matrix[4, 2]f64

    dmat3 ¶

    dmat3 :: matrix[3, 3]f64

    dmat3x2 ¶

    dmat3x2 :: matrix[2, 3]f64

    dmat3x3 ¶

    dmat3x3 :: matrix[3, 3]f64

    dmat3x4 ¶

    dmat3x4 :: matrix[4, 3]f64

    dmat4 ¶

    dmat4 :: matrix[4, 4]f64

    dmat4x2 ¶

    dmat4x2 :: matrix[2, 4]f64

    dmat4x3 ¶

    dmat4x3 :: matrix[3, 4]f64

    dmat4x4 ¶

    dmat4x4 :: matrix[4, 4]f64

    dvec2 ¶

    dvec2 :: [2]f64

    dvec3 ¶

    dvec3 :: [3]f64

    dvec4 ¶

    dvec4 :: [4]f64

    ivec2 ¶

    ivec2 :: [2]i32

    ivec3 ¶

    ivec3 :: [3]i32

    ivec4 ¶

    ivec4 :: [4]i32

    mat2 ¶

    mat2 :: matrix[2, 2]f32
     

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

    mat2x2 ¶

    mat2x2 :: matrix[2, 2]f32

    mat2x3 ¶

    mat2x3 :: matrix[3, 2]f32

    mat2x4 ¶

    mat2x4 :: matrix[4, 2]f32

    mat3 ¶

    mat3 :: matrix[3, 3]f32

    mat3x2 ¶

    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 ¶

    mat3x3 :: matrix[3, 3]f32

    mat3x4 ¶

    mat3x4 :: matrix[4, 3]f32

    mat4 ¶

    mat4 :: matrix[4, 4]f32

    mat4x2 ¶

    mat4x2 :: matrix[2, 4]f32

    mat4x3 ¶

    mat4x3 :: matrix[3, 4]f32

    mat4x4 ¶

    mat4x4 :: matrix[4, 4]f32

    uvec2 ¶

    uvec2 :: [2]u32

    uvec3 ¶

    uvec3 :: [3]u32

    uvec4 ¶

    uvec4 :: [4]u32

    vec2 ¶

    vec2 :: [2]f32

    vec3 ¶

    vec3 :: [3]f32

    vec4 ¶

    vec4 :: [4]f32

    Constants

    E ¶

    E :: 2.71828182845904523536

    F32_EPSILON ¶

    F32_EPSILON :: 1e-7

    F64_EPSILON ¶

    F64_EPSILON :: 1e-15

    LN10 ¶

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶

    LN2 :: 0.693147180559945309417232121458176568

    PI ¶

    PI :: 3.14159265358979323846264338327950288

    SQRT_FIVE ¶

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶

    TAU :: 6.28318530717958647692528676655900576

    e ¶

    e :: E

    π ¶

    π :: PI

    τ ¶

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs_dvec2 ¶

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

    abs_dvec3 ¶

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

    abs_dvec4 ¶

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

    abs_f32 ¶

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

    abs_f64 ¶

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

    abs_i32 ¶

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

    abs_ivec2 ¶

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

    abs_ivec3 ¶

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

    abs_ivec4 ¶

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

    abs_u32 ¶

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

    abs_uvec2 ¶

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

    abs_uvec3 ¶

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

    abs_uvec4 ¶

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

    abs_vec2 ¶

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

    abs_vec3 ¶

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

    abs_vec4 ¶

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

    acos_dvec2 ¶

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

    acos_dvec3 ¶

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

    acos_dvec4 ¶

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

    acos_f32 ¶

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

    acos_f64 ¶

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

    acos_vec2 ¶

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

    acos_vec3 ¶

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

    acos_vec4 ¶

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

    acosh_dvec2 ¶

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

    acosh_dvec3 ¶

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

    acosh_dvec4 ¶

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

    acosh_f32 ¶

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

    acosh_f64 ¶

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

    acosh_vec2 ¶

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

    acosh_vec3 ¶

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

    acosh_vec4 ¶

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

    adjugate_matrix1x1 ¶

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

    adjugate_matrix2x2 ¶

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

    adjugate_matrix3x3 ¶

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

    adjugate_matrix4x4 ¶

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

    all_bool ¶

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

    all_bvec2 ¶

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

    all_bvec3 ¶

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

    all_bvec4 ¶

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

    any_bool ¶

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

    any_bvec2 ¶

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

    any_bvec3 ¶

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

    any_bvec4 ¶

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

    asin_dvec2 ¶

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

    asin_dvec3 ¶

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

    asin_dvec4 ¶

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

    asin_f32 ¶

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

    asin_f64 ¶

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

    asin_vec2 ¶

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

    asin_vec3 ¶

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

    asin_vec4 ¶

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

    asinh_dvec2 ¶

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

    asinh_dvec3 ¶

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

    asinh_dvec4 ¶

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

    asinh_f32 ¶

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

    asinh_f64 ¶

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

    asinh_vec2 ¶

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

    asinh_vec3 ¶

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

    asinh_vec4 ¶

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

    atan2_dvec2 ¶

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

    atan2_dvec3 ¶

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

    atan2_dvec4 ¶

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

    atan2_f32 ¶

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

    atan2_f64 ¶

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

    atan2_vec2 ¶

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

    atan2_vec3 ¶

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

    atan2_vec4 ¶

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

    atan_dvec2 ¶

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

    atan_dvec3 ¶

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

    atan_dvec4 ¶

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

    atan_f32 ¶

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

    atan_f64 ¶

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

    atan_vec2 ¶

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

    atan_vec3 ¶

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

    atan_vec4 ¶

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

    atanh_dvec2 ¶

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

    atanh_dvec3 ¶

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

    atanh_dvec4 ¶

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

    atanh_f32 ¶

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

    atanh_f64 ¶

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

    atanh_vec2 ¶

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

    atanh_vec3 ¶

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

    atanh_vec4 ¶

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

    ceil_dvec2 ¶

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

    ceil_dvec3 ¶

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

    ceil_dvec4 ¶

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

    ceil_f32 ¶

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

    ceil_f64 ¶

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

    ceil_vec2 ¶

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

    ceil_vec3 ¶

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

    ceil_vec4 ¶

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

    clamp_dvec2 ¶

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

    clamp_dvec3 ¶

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

    clamp_dvec4 ¶

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

    clamp_f32 ¶

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

    clamp_f64 ¶

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

    clamp_i32 ¶

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

    clamp_ivec2 ¶

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

    clamp_ivec3 ¶

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

    clamp_ivec4 ¶

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

    clamp_u32 ¶

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

    clamp_uvec2 ¶

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

    clamp_uvec3 ¶

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

    clamp_uvec4 ¶

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

    clamp_vec2 ¶

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

    clamp_vec3 ¶

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

    clamp_vec4 ¶

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

    cos_dvec2 ¶

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

    cos_dvec3 ¶

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

    cos_dvec4 ¶

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

    cos_f32 ¶

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

    cos_f64 ¶

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

    cos_vec2 ¶

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

    cos_vec3 ¶

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

    cos_vec4 ¶

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

    cosh_dvec2 ¶

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

    cosh_dvec3 ¶

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

    cosh_dvec4 ¶

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

    cosh_f32 ¶

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

    cosh_f64 ¶

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

    cosh_vec2 ¶

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

    cosh_vec3 ¶

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

    cosh_vec4 ¶

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

    cross_dvec3 ¶

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

    cross_ivec3 ¶

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

    cross_vec3 ¶

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

    degrees_dvec2 ¶

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

    degrees_dvec3 ¶

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

    degrees_dvec4 ¶

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

    degrees_f32 ¶

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

    degrees_f64 ¶

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

    degrees_vec2 ¶

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

    degrees_vec3 ¶

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

    degrees_vec4 ¶

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

    determinant_matrix1x1 ¶

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

    determinant_matrix2x2 ¶

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

    determinant_matrix3x3 ¶

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

    determinant_matrix4x4 ¶

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

    distance_dvec2 ¶

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

    distance_dvec3 ¶

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

    distance_dvec4 ¶

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

    distance_f32 ¶

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

    distance_f64 ¶

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

    distance_vec2 ¶

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

    distance_vec3 ¶

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

    distance_vec4 ¶

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

    dmat4FromDquat ¶

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

    dmat4LookAt ¶

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

    dmat4Orientation ¶

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

    dmat4Ortho3d ¶

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

    dmat4Perspective ¶

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

    dmat4PerspectiveInfinite ¶

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

    dmat4Rotate ¶

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

    dmat4Scale ¶

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

    dmat4Translate ¶

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

    dot_dquat ¶

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

    dot_dvec2 ¶

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

    dot_dvec3 ¶

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

    dot_dvec4 ¶

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

    dot_f32 ¶

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

    dot_f64 ¶

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

    dot_i32 ¶

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

    dot_ivec2 ¶

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

    dot_ivec3 ¶

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

    dot_ivec4 ¶

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

    dot_quat ¶

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

    dot_u32 ¶

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

    dot_uvec2 ¶

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

    dot_uvec3 ¶

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

    dot_uvec4 ¶

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

    dot_vec2 ¶

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

    dot_vec3 ¶

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

    dot_vec4 ¶

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

    dquatAxisAngle ¶

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

    dquatFromDmat4 ¶

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

    dquatFromdMat3 ¶

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

    dquatMulDvec3 ¶

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

    dquatNlerp ¶

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

    dquatSlerp ¶

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

    equal_dvec2 ¶

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

    equal_dvec3 ¶

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

    equal_dvec4 ¶

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

    equal_f32 ¶

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

    equal_f64 ¶

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

    equal_i32 ¶

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

    equal_ivec2 ¶

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

    equal_ivec3 ¶

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

    equal_ivec4 ¶

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

    equal_u32 ¶

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

    equal_uvec2 ¶

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

    equal_uvec3 ¶

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

    equal_uvec4 ¶

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

    equal_vec2 ¶

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

    equal_vec3 ¶

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

    equal_vec4 ¶

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

    exp2_dvec2 ¶

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

    exp2_dvec3 ¶

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

    exp2_dvec4 ¶

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

    exp2_f32 ¶

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

    exp2_f64 ¶

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

    exp2_vec2 ¶

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

    exp2_vec3 ¶

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

    exp2_vec4 ¶

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

    exp_dvec2 ¶

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

    exp_dvec3 ¶

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

    exp_dvec4 ¶

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

    exp_f32 ¶

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

    exp_f64 ¶

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

    exp_vec2 ¶

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

    exp_vec3 ¶

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

    exp_vec4 ¶

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

    faceForward_dvec2 ¶

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

    faceForward_dvec3 ¶

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

    faceForward_dvec4 ¶

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

    faceForward_f32 ¶

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

    faceForward_f64 ¶

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

    faceForward_vec2 ¶

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

    faceForward_vec3 ¶

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

    faceForward_vec4 ¶

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

    floor_dvec2 ¶

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

    floor_dvec3 ¶

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

    floor_dvec4 ¶

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

    floor_f32 ¶

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

    floor_f64 ¶

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

    floor_vec2 ¶

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

    floor_vec3 ¶

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

    floor_vec4 ¶

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

    fract_dvec2 ¶

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

    fract_dvec3 ¶

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

    fract_dvec4 ¶

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

    fract_f32 ¶

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

    fract_f64 ¶

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

    fract_vec2 ¶

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

    fract_vec3 ¶

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

    fract_vec4 ¶

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

    greaterThanEqual_dvec2 ¶

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

    greaterThanEqual_dvec3 ¶

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

    greaterThanEqual_dvec4 ¶

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

    greaterThanEqual_f32 ¶

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

    greaterThanEqual_f64 ¶

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

    greaterThanEqual_i32 ¶

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

    greaterThanEqual_ivec2 ¶

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

    greaterThanEqual_ivec3 ¶

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

    greaterThanEqual_ivec4 ¶

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

    greaterThanEqual_u32 ¶

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

    greaterThanEqual_uvec2 ¶

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

    greaterThanEqual_uvec3 ¶

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

    greaterThanEqual_uvec4 ¶

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

    greaterThanEqual_vec2 ¶

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

    greaterThanEqual_vec3 ¶

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

    greaterThanEqual_vec4 ¶

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

    greaterThan_dvec2 ¶

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

    greaterThan_dvec3 ¶

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

    greaterThan_dvec4 ¶

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

    greaterThan_f32 ¶

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

    greaterThan_f64 ¶

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

    greaterThan_i32 ¶

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

    greaterThan_ivec2 ¶

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

    greaterThan_ivec3 ¶

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

    greaterThan_ivec4 ¶

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

    greaterThan_u32 ¶

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

    greaterThan_uvec2 ¶

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

    greaterThan_uvec3 ¶

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

    greaterThan_uvec4 ¶

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

    greaterThan_vec2 ¶

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

    greaterThan_vec3 ¶

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

    greaterThan_vec4 ¶

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

    hermitian_adjoint ¶

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

    identity ¶

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

    inverse_dmat2 ¶

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

    inverse_dmat3 ¶

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

    inverse_dmat4 ¶

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

    inverse_dquat ¶

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

    inverse_mat2 ¶

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

    inverse_mat3 ¶

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

    inverse_mat4 ¶

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

    inverse_matrix1x1 ¶

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

    inverse_matrix2x2 ¶

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

    inverse_matrix3x3 ¶

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

    inverse_matrix4x4 ¶

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

    inverse_quat ¶

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

    inverse_transpose_matrix1x1 ¶

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

    inverse_transpose_matrix2x2 ¶

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

    inverse_transpose_matrix3x3 ¶

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

    inverse_transpose_matrix4x4 ¶

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

    inversesqrt_dvec2 ¶

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

    inversesqrt_dvec3 ¶

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

    inversesqrt_dvec4 ¶

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

    inversesqrt_f32 ¶

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

    inversesqrt_f64 ¶

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

    inversesqrt_vec2 ¶

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

    inversesqrt_vec3 ¶

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

    inversesqrt_vec4 ¶

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

    length_dquat ¶

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

    length_dvec2 ¶

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

    length_dvec3 ¶

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

    length_dvec4 ¶

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

    length_f32 ¶

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

    length_f64 ¶

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

    length_quat ¶

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

    length_vec2 ¶

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

    length_vec3 ¶

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

    length_vec4 ¶

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

    lerp_dvec2 ¶

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

    lerp_dvec3 ¶

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

    lerp_dvec4 ¶

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

    lerp_f32 ¶

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

    lerp_f64 ¶

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

    lerp_vec2 ¶

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

    lerp_vec3 ¶

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

    lerp_vec4 ¶

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

    lessThanEqual_dvec2 ¶

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

    lessThanEqual_dvec3 ¶

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

    lessThanEqual_dvec4 ¶

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

    lessThanEqual_f32 ¶

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

    lessThanEqual_f64 ¶

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

    lessThanEqual_i32 ¶

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

    lessThanEqual_ivec2 ¶

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

    lessThanEqual_ivec3 ¶

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

    lessThanEqual_ivec4 ¶

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

    lessThanEqual_u32 ¶

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

    lessThanEqual_uvec2 ¶

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

    lessThanEqual_uvec3 ¶

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

    lessThanEqual_uvec4 ¶

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

    lessThanEqual_vec2 ¶

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

    lessThanEqual_vec3 ¶

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

    lessThanEqual_vec4 ¶

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

    lessThan_dvec2 ¶

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

    lessThan_dvec3 ¶

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

    lessThan_dvec4 ¶

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

    lessThan_f32 ¶

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

    lessThan_f64 ¶

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

    lessThan_i32 ¶

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

    lessThan_ivec2 ¶

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

    lessThan_ivec3 ¶

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

    lessThan_ivec4 ¶

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

    lessThan_u32 ¶

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

    lessThan_uvec2 ¶

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

    lessThan_uvec3 ¶

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

    lessThan_uvec4 ¶

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

    lessThan_vec2 ¶

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

    lessThan_vec3 ¶

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

    lessThan_vec4 ¶

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

    log_dvec2 ¶

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

    log_dvec3 ¶

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

    log_dvec4 ¶

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

    log_f32 ¶

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

    log_f64 ¶

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

    log_vec2 ¶

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

    log_vec3 ¶

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

    log_vec4 ¶

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

    mat4FromQuat ¶

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

    mat4LookAt ¶

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

    mat4Orientation ¶

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

    mat4Ortho3d ¶

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

    mat4Perspective ¶

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

    mat4PerspectiveInfinite ¶

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

    mat4Rotate ¶

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

    mat4Scale ¶

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

    mat4Translate ¶

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

    matrix_minor ¶

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

    max_dvec2 ¶

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

    max_dvec3 ¶

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

    max_dvec4 ¶

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

    max_f32 ¶

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

    max_f64 ¶

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

    max_i32 ¶

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

    max_ivec2 ¶

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

    max_ivec3 ¶

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

    max_ivec4 ¶

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

    max_u32 ¶

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

    max_uvec2 ¶

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

    max_uvec3 ¶

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

    max_uvec4 ¶

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

    max_vec2 ¶

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

    max_vec3 ¶

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

    max_vec4 ¶

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

    min_dvec2 ¶

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

    min_dvec3 ¶

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

    min_dvec4 ¶

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

    min_f32 ¶

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

    min_f64 ¶

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

    min_i32 ¶

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

    min_ivec2 ¶

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

    min_ivec3 ¶

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

    min_ivec4 ¶

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

    min_u32 ¶

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

    min_uvec2 ¶

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

    min_uvec3 ¶

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

    min_uvec4 ¶

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

    min_vec2 ¶

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

    min_vec3 ¶

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

    min_vec4 ¶

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

    mix_dvec2 ¶

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

    mix_dvec3 ¶

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

    mix_dvec4 ¶

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

    mix_f32 ¶

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

    mix_f64 ¶

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

    mix_vec2 ¶

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

    mix_vec3 ¶

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

    mix_vec4 ¶

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

    mod_dvec2 ¶

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

    mod_dvec3 ¶

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

    mod_dvec4 ¶

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

    mod_f32 ¶

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

    mod_f64 ¶

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

    mod_vec2 ¶

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

    mod_vec3 ¶

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

    mod_vec4 ¶

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

    normalize_dquat ¶

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

    normalize_dvec2 ¶

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

    normalize_dvec3 ¶

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

    normalize_dvec4 ¶

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

    normalize_f32 ¶

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

    normalize_f64 ¶

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

    normalize_quat ¶

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

    normalize_vec2 ¶

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

    normalize_vec3 ¶

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

    normalize_vec4 ¶

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

    notEqual_dvec2 ¶

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

    notEqual_dvec3 ¶

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

    notEqual_dvec4 ¶

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

    notEqual_f32 ¶

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

    notEqual_f64 ¶

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

    notEqual_i32 ¶

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

    notEqual_ivec2 ¶

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

    notEqual_ivec3 ¶

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

    notEqual_ivec4 ¶

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

    notEqual_u32 ¶

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

    notEqual_uvec2 ¶

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

    notEqual_uvec3 ¶

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

    notEqual_uvec4 ¶

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

    notEqual_vec2 ¶

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

    notEqual_vec3 ¶

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

    notEqual_vec4 ¶

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

    not_bool ¶

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

    not_bvec2 ¶

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

    not_bvec3 ¶

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

    not_bvec4 ¶

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

    pow_dvec2 ¶

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

    pow_dvec3 ¶

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

    pow_dvec4 ¶

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

    pow_f32 ¶

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

    pow_f64 ¶

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

    pow_vec2 ¶

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

    pow_vec3 ¶

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

    pow_vec4 ¶

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

    quatAxisAngle ¶

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

    quatFromMat3 ¶

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

    quatFromMat4 ¶

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

    quatMulVec3 ¶

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

    quatNlerp ¶

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

    quatSlerp ¶

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

    radians_dvec2 ¶

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

    radians_dvec3 ¶

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

    radians_dvec4 ¶

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

    radians_f32 ¶

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

    radians_f64 ¶

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

    radians_vec2 ¶

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

    radians_vec3 ¶

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

    radians_vec4 ¶

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

    reflect_dvec2 ¶

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

    reflect_dvec3 ¶

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

    reflect_dvec4 ¶

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

    reflect_f32 ¶

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

    reflect_f64 ¶

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

    reflect_vec2 ¶

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

    reflect_vec3 ¶

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

    reflect_vec4 ¶

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

    refract_dvec2 ¶

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

    refract_dvec3 ¶

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

    refract_dvec4 ¶

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

    refract_f32 ¶

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

    refract_f64 ¶

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

    refract_vec2 ¶

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

    refract_vec3 ¶

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

    refract_vec4 ¶

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

    round_dvec2 ¶

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

    round_dvec3 ¶

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

    round_dvec4 ¶

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

    round_f32 ¶

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

    round_f64 ¶

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

    round_vec2 ¶

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

    round_vec3 ¶

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

    round_vec4 ¶

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

    saturate_dvec2 ¶

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

    saturate_dvec3 ¶

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

    saturate_dvec4 ¶

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

    saturate_f32 ¶

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

    saturate_f64 ¶

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

    saturate_i32 ¶

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

    saturate_ivec2 ¶

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

    saturate_ivec3 ¶

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

    saturate_ivec4 ¶

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

    saturate_u32 ¶

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

    saturate_uvec2 ¶

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

    saturate_uvec3 ¶

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

    saturate_uvec4 ¶

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

    saturate_vec2 ¶

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

    saturate_vec3 ¶

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

    saturate_vec4 ¶

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

    scalarTripleProduct_dvec3 ¶

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

    scalarTripleProduct_ivec3 ¶

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

    scalarTripleProduct_vec3 ¶

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

    sign_dvec2 ¶

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

    sign_dvec3 ¶

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

    sign_dvec4 ¶

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

    sign_f32 ¶

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

    sign_f64 ¶

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

    sign_i32 ¶

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

    sign_ivec2 ¶

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

    sign_ivec3 ¶

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

    sign_ivec4 ¶

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

    sign_u32 ¶

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

    sign_uvec2 ¶

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

    sign_uvec3 ¶

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

    sign_uvec4 ¶

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

    sign_vec2 ¶

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

    sign_vec3 ¶

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

    sign_vec4 ¶

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

    sin_dvec2 ¶

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

    sin_dvec3 ¶

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

    sin_dvec4 ¶

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

    sin_f32 ¶

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

    sin_f64 ¶

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

    sin_vec2 ¶

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

    sin_vec3 ¶

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

    sin_vec4 ¶

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

    sinh_dvec2 ¶

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

    sinh_dvec3 ¶

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

    sinh_dvec4 ¶

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

    sinh_f32 ¶

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

    sinh_f64 ¶

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

    sinh_vec2 ¶

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

    sinh_vec3 ¶

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

    sinh_vec4 ¶

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

    smoothstep_dvec2 ¶

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

    smoothstep_dvec3 ¶

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

    smoothstep_dvec4 ¶

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

    smoothstep_f32 ¶

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

    smoothstep_f64 ¶

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

    smoothstep_vec2 ¶

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

    smoothstep_vec3 ¶

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

    smoothstep_vec4 ¶

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

    sqrt_dvec2 ¶

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

    sqrt_dvec3 ¶

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

    sqrt_dvec4 ¶

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

    sqrt_f32 ¶

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

    sqrt_f64 ¶

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

    sqrt_vec2 ¶

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

    sqrt_vec3 ¶

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

    sqrt_vec4 ¶

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

    step_dvec2 ¶

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

    step_dvec3 ¶

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

    step_dvec4 ¶

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

    step_f32 ¶

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

    step_f64 ¶

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

    step_vec2 ¶

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

    step_vec3 ¶

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

    step_vec4 ¶

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

    tan_dvec2 ¶

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

    tan_dvec3 ¶

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

    tan_dvec4 ¶

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

    tan_f32 ¶

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

    tan_f64 ¶

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

    tan_vec2 ¶

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

    tan_vec3 ¶

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

    tan_vec4 ¶

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

    tanh_dvec2 ¶

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

    tanh_dvec3 ¶

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

    tanh_dvec4 ¶

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

    tanh_f32 ¶

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

    tanh_f64 ¶

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

    tanh_vec2 ¶

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

    tanh_vec3 ¶

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

    tanh_vec4 ¶

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

    trace ¶

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

    transpose ¶

    transpose :: intrinsics.transpose

    vectorTripleProduct_dvec3 ¶

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

    vectorTripleProduct_ivec3 ¶

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

    vectorTripleProduct_vec3 ¶

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

    Procedure Groups

    nlerp ¶

    nlerp :: proc{
    	quatNlerp,
    	dquatNlerp,
    }
    

    slerp ¶

    slerp :: proc{
    	quatSlerp,
    	dquatSlerp,
    }
    

    Source Files

    Generation Information

    Generated with odin version dev-2024-12 (vendor "odin") Windows_amd64 @ 2024-12-06 21:12:12.582626200 +0000 UTC