package core:math/linalg/hlsl
Source

⌘K
Ctrl+K
or
/

    Overview

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

    Index

    Variables (0)

    This section is empty.

    Procedures (757)

    Types

    bool2 ¶
    Source

    bool2 :: distinct [2]bool
    Related Procedures With Parameters
    Related Procedures With Returns

    bool3 ¶
    Source

    bool3 :: distinct [3]bool
    Related Procedures With Parameters
    Related Procedures With Returns

    bool4 ¶
    Source

    bool4 :: distinct [4]bool
    Related Procedures With Parameters
    Related Procedures With Returns

    double ¶
    Source

    double :: f64

    double1x1 ¶
    Source

    double1x1 :: distinct matrix[1, 1]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double1x2 ¶
    Source

    double1x2 :: distinct matrix[1, 2]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double1x3 ¶
    Source

    double1x3 :: distinct matrix[1, 3]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double1x4 ¶
    Source

    double1x4 :: distinct matrix[1, 4]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double2 ¶
    Source

    double2 :: distinct [2]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double2x1 ¶
    Source

    double2x1 :: distinct matrix[2, 1]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double2x2 ¶
    Source

    double2x2 :: distinct matrix[2, 2]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double2x3 ¶
    Source

    double2x3 :: distinct matrix[2, 3]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double2x4 ¶
    Source

    double2x4 :: distinct matrix[2, 4]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double3 ¶
    Source

    double3 :: distinct [3]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double3x1 ¶
    Source

    double3x1 :: distinct matrix[3, 1]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double3x2 ¶
    Source

    double3x2 :: distinct matrix[3, 2]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double3x3 ¶
    Source

    double3x3 :: distinct matrix[3, 3]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double3x4 ¶
    Source

    double3x4 :: distinct matrix[3, 4]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double4 ¶
    Source

    double4 :: distinct [4]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double4x1 ¶
    Source

    double4x1 :: distinct matrix[4, 1]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double4x2 ¶
    Source

    double4x2 :: distinct matrix[4, 2]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double4x3 ¶
    Source

    double4x3 :: distinct matrix[4, 3]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    double4x4 ¶
    Source

    double4x4 :: distinct matrix[4, 4]f64
    Related Procedures With Parameters
    Related Procedures With Returns

    float ¶
    Source

    float :: f32
     

    Aliases (not distinct) of types

    float1x1 ¶
    Source

    float1x1 :: distinct matrix[1, 1]f32
     

    Odin matrices are stored internally as Column-Major, which matches the internal layout of HLSL by default

    Related Procedures With Parameters
    Related Procedures With Returns

    float1x2 ¶
    Source

    float1x2 :: distinct matrix[1, 2]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float1x3 ¶
    Source

    float1x3 :: distinct matrix[1, 3]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float1x4 ¶
    Source

    float1x4 :: distinct matrix[1, 4]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float2 ¶
    Source

    float2 :: distinct [2]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float2x1 ¶
    Source

    float2x1 :: distinct matrix[2, 1]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float2x2 ¶
    Source

    float2x2 :: distinct matrix[2, 2]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float2x3 ¶
    Source

    float2x3 :: distinct matrix[2, 3]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float2x4 ¶
    Source

    float2x4 :: distinct matrix[2, 4]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float3 ¶
    Source

    float3 :: distinct [3]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float3x1 ¶
    Source

    float3x1 :: distinct matrix[3, 1]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float3x2 ¶
    Source

    float3x2 :: distinct matrix[3, 2]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float3x3 ¶
    Source

    float3x3 :: distinct matrix[3, 3]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float3x4 ¶
    Source

    float3x4 :: distinct matrix[3, 4]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float4 ¶
    Source

    float4 :: distinct [4]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float4x1 ¶
    Source

    float4x1 :: distinct matrix[4, 1]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float4x2 ¶
    Source

    float4x2 :: distinct matrix[4, 2]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float4x3 ¶
    Source

    float4x3 :: distinct matrix[4, 3]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    float4x4 ¶
    Source

    float4x4 :: distinct matrix[4, 4]f32
    Related Procedures With Parameters
    Related Procedures With Returns

    int ¶
    Source

    int :: i32

    int1x1 ¶
    Source

    int1x1 :: distinct matrix[1, 1]i32
    Related Procedures With Returns

    int1x2 ¶
    Source

    int1x2 :: distinct matrix[1, 2]i32
    Related Procedures With Returns

    int1x3 ¶
    Source

    int1x3 :: distinct matrix[1, 3]i32
    Related Procedures With Returns

    int1x4 ¶
    Source

    int1x4 :: distinct matrix[1, 4]i32
    Related Procedures With Returns

    int2 ¶
    Source

    int2 :: distinct [2]i32
    Related Procedures With Parameters
    Related Procedures With Returns

    int2x1 ¶
    Source

    int2x1 :: distinct matrix[2, 1]i32
    Related Procedures With Returns

    int2x2 ¶
    Source

    int2x2 :: distinct matrix[2, 2]i32
    Related Procedures With Returns

    int2x3 ¶
    Source

    int2x3 :: distinct matrix[2, 3]i32
    Related Procedures With Returns

    int2x4 ¶
    Source

    int2x4 :: distinct matrix[2, 4]i32
    Related Procedures With Returns

    int3 ¶
    Source

    int3 :: distinct [3]i32
    Related Procedures With Parameters
    Related Procedures With Returns

    int3x1 ¶
    Source

    int3x1 :: distinct matrix[3, 1]i32
    Related Procedures With Returns

    int3x2 ¶
    Source

    int3x2 :: distinct matrix[3, 2]i32
    Related Procedures With Returns

    int3x3 ¶
    Source

    int3x3 :: distinct matrix[3, 3]i32
    Related Procedures With Returns

    int3x4 ¶
    Source

    int3x4 :: distinct matrix[3, 4]i32
    Related Procedures With Returns

    int4 ¶
    Source

    int4 :: distinct [4]i32
    Related Procedures With Parameters
    Related Procedures With Returns

    int4x1 ¶
    Source

    int4x1 :: distinct matrix[4, 1]i32
    Related Procedures With Returns

    int4x2 ¶
    Source

    int4x2 :: distinct matrix[4, 2]i32
    Related Procedures With Returns

    int4x3 ¶
    Source

    int4x3 :: distinct matrix[4, 3]i32
    Related Procedures With Returns

    int4x4 ¶
    Source

    int4x4 :: distinct matrix[4, 4]i32
    Related Procedures With Returns

    uint ¶
    Source

    uint :: u32

    uint2 ¶
    Source

    uint2 :: distinct [2]u32
    Related Procedures With Parameters
    Related Procedures With Returns

    uint3 ¶
    Source

    uint3 :: distinct [3]u32
    Related Procedures With Parameters
    Related Procedures With Returns

    uint4 ¶
    Source

    uint4 :: distinct [4]u32
    Related Procedures With Parameters
    Related Procedures With Returns

    Constants

    DOUBLE_EPSILON ¶
    Source

    DOUBLE_EPSILON :: 1e-15

    E ¶
    Source

    E :: 2.71828182845904523536

    FLOAT_EPSILON ¶
    Source

    FLOAT_EPSILON :: 1e-7

    LN10 ¶
    Source

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶
    Source

    LN2 :: 0.693147180559945309417232121458176568

    PI ¶
    Source

    PI :: 3.14159265358979323846264338327950288

    SQRT_FIVE ¶
    Source

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶
    Source

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶
    Source

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶
    Source

    TAU :: 6.28318530717958647692528676655900576

    e ¶
    Source

    e :: E

    π ¶
    Source

    π :: PI

    τ ¶
    Source

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs_double ¶
    Source

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

    abs_double2 ¶
    Source

    abs_double2 :: proc "c" (x: double2) -> double2 {…}

    abs_double3 ¶
    Source

    abs_double3 :: proc "c" (x: double3) -> double3 {…}

    abs_double4 ¶
    Source

    abs_double4 :: proc "c" (x: double4) -> double4 {…}

    abs_float ¶
    Source

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

    abs_float2 ¶
    Source

    abs_float2 :: proc "c" (x: float2) -> float2 {…}

    abs_float3 ¶
    Source

    abs_float3 :: proc "c" (x: float3) -> float3 {…}

    abs_float4 ¶
    Source

    abs_float4 :: proc "c" (x: float4) -> float4 {…}

    abs_int ¶
    Source

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

    abs_int2 ¶
    Source

    abs_int2 :: proc "c" (x: int2) -> int2 {…}

    abs_int3 ¶
    Source

    abs_int3 :: proc "c" (x: int3) -> int3 {…}

    abs_int4 ¶
    Source

    abs_int4 :: proc "c" (x: int4) -> int4 {…}

    abs_uint ¶
    Source

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

    abs_uint2 ¶
    Source

    abs_uint2 :: proc "c" (x: uint2) -> uint2 {…}

    abs_uint3 ¶
    Source

    abs_uint3 :: proc "c" (x: uint3) -> uint3 {…}

    abs_uint4 ¶
    Source

    abs_uint4 :: proc "c" (x: uint4) -> uint4 {…}

    acos_double ¶
    Source

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

    acos_double2 ¶
    Source

    acos_double2 :: proc "c" (x: double2) -> double2 {…}

    acos_double3 ¶
    Source

    acos_double3 :: proc "c" (x: double3) -> double3 {…}

    acos_double4 ¶
    Source

    acos_double4 :: proc "c" (x: double4) -> double4 {…}

    acos_float ¶
    Source

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

    acos_float2 ¶
    Source

    acos_float2 :: proc "c" (x: float2) -> float2 {…}

    acos_float3 ¶
    Source

    acos_float3 :: proc "c" (x: float3) -> float3 {…}

    acos_float4 ¶
    Source

    acos_float4 :: proc "c" (x: float4) -> float4 {…}

    acosh_double ¶
    Source

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

    acosh_double2 ¶
    Source

    acosh_double2 :: proc "c" (x: double2) -> double2 {…}

    acosh_double3 ¶
    Source

    acosh_double3 :: proc "c" (x: double3) -> double3 {…}

    acosh_double4 ¶
    Source

    acosh_double4 :: proc "c" (x: double4) -> double4 {…}

    acosh_float ¶
    Source

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

    acosh_float2 ¶
    Source

    acosh_float2 :: proc "c" (x: float2) -> float2 {…}

    acosh_float3 ¶
    Source

    acosh_float3 :: proc "c" (x: float3) -> float3 {…}

    acosh_float4 ¶
    Source

    acosh_float4 :: proc "c" (x: float4) -> float4 {…}

    adjugate_matrix1x1 ¶
    Source

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

    adjugate_matrix2x2 ¶
    Source

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

    adjugate_matrix3x3 ¶
    Source

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

    adjugate_matrix4x4 ¶
    Source

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

    all_bool ¶
    Source

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

    all_bool2 ¶
    Source

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

    all_bool3 ¶
    Source

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

    all_bool4 ¶
    Source

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

    any_bool ¶
    Source

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

    any_bool2 ¶
    Source

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

    any_bool3 ¶
    Source

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

    any_bool4 ¶
    Source

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

    asdouble_bool2 ¶
    Source

    asdouble_bool2 :: proc "c" (v: bool2) -> double2 {…}

    asdouble_bool3 ¶
    Source

    asdouble_bool3 :: proc "c" (v: bool3) -> double3 {…}

    asdouble_bool4 ¶
    Source

    asdouble_bool4 :: proc "c" (v: bool4) -> double4 {…}

    asdouble_double ¶
    Source

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

    asdouble_double1x1 ¶
    Source

    asdouble_double1x1 :: proc "c" (v: double1x1) -> double1x1 {…}

    asdouble_double1x2 ¶
    Source

    asdouble_double1x2 :: proc "c" (v: double1x2) -> double1x2 {…}

    asdouble_double1x3 ¶
    Source

    asdouble_double1x3 :: proc "c" (v: double1x3) -> double1x3 {…}

    asdouble_double1x4 ¶
    Source

    asdouble_double1x4 :: proc "c" (v: double1x4) -> double1x4 {…}

    asdouble_double2 ¶
    Source

    asdouble_double2 :: proc "c" (v: double2) -> double2 {…}

    asdouble_double2x1 ¶
    Source

    asdouble_double2x1 :: proc "c" (v: double2x1) -> double2x1 {…}

    asdouble_double2x2 ¶
    Source

    asdouble_double2x2 :: proc "c" (v: double2x2) -> double2x2 {…}

    asdouble_double2x3 ¶
    Source

    asdouble_double2x3 :: proc "c" (v: double2x3) -> double2x3 {…}

    asdouble_double2x4 ¶
    Source

    asdouble_double2x4 :: proc "c" (v: double2x4) -> double2x4 {…}

    asdouble_double3 ¶
    Source

    asdouble_double3 :: proc "c" (v: double3) -> double3 {…}

    asdouble_double3x1 ¶
    Source

    asdouble_double3x1 :: proc "c" (v: double3x1) -> double3x1 {…}

    asdouble_double3x2 ¶
    Source

    asdouble_double3x2 :: proc "c" (v: double3x2) -> double3x2 {…}

    asdouble_double3x3 ¶
    Source

    asdouble_double3x3 :: proc "c" (v: double3x3) -> double3x3 {…}

    asdouble_double3x4 ¶
    Source

    asdouble_double3x4 :: proc "c" (v: double3x4) -> double3x4 {…}

    asdouble_double4 ¶
    Source

    asdouble_double4 :: proc "c" (v: double4) -> double4 {…}

    asdouble_double4x1 ¶
    Source

    asdouble_double4x1 :: proc "c" (v: double4x1) -> double4x1 {…}

    asdouble_double4x2 ¶
    Source

    asdouble_double4x2 :: proc "c" (v: double4x2) -> double4x2 {…}

    asdouble_double4x3 ¶
    Source

    asdouble_double4x3 :: proc "c" (v: double4x3) -> double4x3 {…}

    asdouble_double4x4 ¶
    Source

    asdouble_double4x4 :: proc "c" (v: double4x4) -> double4x4 {…}

    asdouble_float ¶
    Source

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

    asdouble_float1x1 ¶
    Source

    asdouble_float1x1 :: proc "c" (v: float1x1) -> double1x1 {…}

    asdouble_float1x2 ¶
    Source

    asdouble_float1x2 :: proc "c" (v: float1x2) -> double1x2 {…}

    asdouble_float1x3 ¶
    Source

    asdouble_float1x3 :: proc "c" (v: float1x3) -> double1x3 {…}

    asdouble_float1x4 ¶
    Source

    asdouble_float1x4 :: proc "c" (v: float1x4) -> double1x4 {…}

    asdouble_float2 ¶
    Source

    asdouble_float2 :: proc "c" (v: float2) -> double2 {…}

    asdouble_float2x1 ¶
    Source

    asdouble_float2x1 :: proc "c" (v: float2x1) -> double2x1 {…}

    asdouble_float2x2 ¶
    Source

    asdouble_float2x2 :: proc "c" (v: float2x2) -> double2x2 {…}

    asdouble_float2x3 ¶
    Source

    asdouble_float2x3 :: proc "c" (v: float2x3) -> double2x3 {…}

    asdouble_float2x4 ¶
    Source

    asdouble_float2x4 :: proc "c" (v: float2x4) -> double2x4 {…}

    asdouble_float3 ¶
    Source

    asdouble_float3 :: proc "c" (v: float3) -> double3 {…}

    asdouble_float3x1 ¶
    Source

    asdouble_float3x1 :: proc "c" (v: float3x1) -> double3x1 {…}

    asdouble_float3x2 ¶
    Source

    asdouble_float3x2 :: proc "c" (v: float3x2) -> double3x2 {…}

    asdouble_float3x3 ¶
    Source

    asdouble_float3x3 :: proc "c" (v: float3x3) -> double3x3 {…}

    asdouble_float3x4 ¶
    Source

    asdouble_float3x4 :: proc "c" (v: float3x4) -> double3x4 {…}

    asdouble_float4 ¶
    Source

    asdouble_float4 :: proc "c" (v: float4) -> double4 {…}

    asdouble_float4x1 ¶
    Source

    asdouble_float4x1 :: proc "c" (v: float4x1) -> double4x1 {…}

    asdouble_float4x2 ¶
    Source

    asdouble_float4x2 :: proc "c" (v: float4x2) -> double4x2 {…}

    asdouble_float4x3 ¶
    Source

    asdouble_float4x3 :: proc "c" (v: float4x3) -> double4x3 {…}

    asdouble_float4x4 ¶
    Source

    asdouble_float4x4 :: proc "c" (v: float4x4) -> double4x4 {…}

    asdouble_int ¶
    Source

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

    asdouble_int2 ¶
    Source

    asdouble_int2 :: proc "c" (v: int2) -> double2 {…}

    asdouble_int3 ¶
    Source

    asdouble_int3 :: proc "c" (v: int3) -> double3 {…}

    asdouble_int4 ¶
    Source

    asdouble_int4 :: proc "c" (v: int4) -> double4 {…}

    asdouble_uint ¶
    Source

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

    asdouble_uint2 ¶
    Source

    asdouble_uint2 :: proc "c" (v: uint2) -> double2 {…}

    asdouble_uint3 ¶
    Source

    asdouble_uint3 :: proc "c" (v: uint3) -> double3 {…}

    asdouble_uint4 ¶
    Source

    asdouble_uint4 :: proc "c" (v: uint4) -> double4 {…}

    asfloat_bool2 ¶
    Source

    asfloat_bool2 :: proc "c" (v: bool2) -> float2 {…}

    asfloat_bool3 ¶
    Source

    asfloat_bool3 :: proc "c" (v: bool3) -> float3 {…}

    asfloat_bool4 ¶
    Source

    asfloat_bool4 :: proc "c" (v: bool4) -> float4 {…}

    asfloat_double ¶
    Source

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

    asfloat_double1x1 ¶
    Source

    asfloat_double1x1 :: proc "c" (v: double1x1) -> float1x1 {…}

    asfloat_double1x2 ¶
    Source

    asfloat_double1x2 :: proc "c" (v: double1x2) -> float1x2 {…}

    asfloat_double1x3 ¶
    Source

    asfloat_double1x3 :: proc "c" (v: double1x3) -> float1x3 {…}

    asfloat_double1x4 ¶
    Source

    asfloat_double1x4 :: proc "c" (v: double1x4) -> float1x4 {…}

    asfloat_double2 ¶
    Source

    asfloat_double2 :: proc "c" (v: double2) -> float2 {…}

    asfloat_double2x1 ¶
    Source

    asfloat_double2x1 :: proc "c" (v: double2x1) -> float2x1 {…}

    asfloat_double2x2 ¶
    Source

    asfloat_double2x2 :: proc "c" (v: double2x2) -> float2x2 {…}

    asfloat_double2x3 ¶
    Source

    asfloat_double2x3 :: proc "c" (v: double2x3) -> float2x3 {…}

    asfloat_double2x4 ¶
    Source

    asfloat_double2x4 :: proc "c" (v: double2x4) -> float2x4 {…}

    asfloat_double3 ¶
    Source

    asfloat_double3 :: proc "c" (v: double3) -> float3 {…}

    asfloat_double3x1 ¶
    Source

    asfloat_double3x1 :: proc "c" (v: double3x1) -> float3x1 {…}

    asfloat_double3x2 ¶
    Source

    asfloat_double3x2 :: proc "c" (v: double3x2) -> float3x2 {…}

    asfloat_double3x3 ¶
    Source

    asfloat_double3x3 :: proc "c" (v: double3x3) -> float3x3 {…}

    asfloat_double3x4 ¶
    Source

    asfloat_double3x4 :: proc "c" (v: double3x4) -> float3x4 {…}

    asfloat_double4 ¶
    Source

    asfloat_double4 :: proc "c" (v: double4) -> float4 {…}

    asfloat_double4x1 ¶
    Source

    asfloat_double4x1 :: proc "c" (v: double4x1) -> float4x1 {…}

    asfloat_double4x2 ¶
    Source

    asfloat_double4x2 :: proc "c" (v: double4x2) -> float4x2 {…}

    asfloat_double4x3 ¶
    Source

    asfloat_double4x3 :: proc "c" (v: double4x3) -> float4x3 {…}

    asfloat_double4x4 ¶
    Source

    asfloat_double4x4 :: proc "c" (v: double4x4) -> float4x4 {…}

    asfloat_float ¶
    Source

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

    asfloat_float1x1 ¶
    Source

    asfloat_float1x1 :: proc "c" (v: float1x1) -> float1x1 {…}

    asfloat_float1x2 ¶
    Source

    asfloat_float1x2 :: proc "c" (v: float1x2) -> float1x2 {…}

    asfloat_float1x3 ¶
    Source

    asfloat_float1x3 :: proc "c" (v: float1x3) -> float1x3 {…}

    asfloat_float1x4 ¶
    Source

    asfloat_float1x4 :: proc "c" (v: float1x4) -> float1x4 {…}

    asfloat_float2 ¶
    Source

    asfloat_float2 :: proc "c" (v: float2) -> float2 {…}

    asfloat_float2x1 ¶
    Source

    asfloat_float2x1 :: proc "c" (v: float2x1) -> float2x1 {…}

    asfloat_float2x2 ¶
    Source

    asfloat_float2x2 :: proc "c" (v: float2x2) -> float2x2 {…}

    asfloat_float2x3 ¶
    Source

    asfloat_float2x3 :: proc "c" (v: float2x3) -> float2x3 {…}

    asfloat_float2x4 ¶
    Source

    asfloat_float2x4 :: proc "c" (v: float2x4) -> float2x4 {…}

    asfloat_float3 ¶
    Source

    asfloat_float3 :: proc "c" (v: float3) -> float3 {…}

    asfloat_float3x1 ¶
    Source

    asfloat_float3x1 :: proc "c" (v: float3x1) -> float3x1 {…}

    asfloat_float3x2 ¶
    Source

    asfloat_float3x2 :: proc "c" (v: float3x2) -> float3x2 {…}

    asfloat_float3x3 ¶
    Source

    asfloat_float3x3 :: proc "c" (v: float3x3) -> float3x3 {…}

    asfloat_float3x4 ¶
    Source

    asfloat_float3x4 :: proc "c" (v: float3x4) -> float3x4 {…}

    asfloat_float4 ¶
    Source

    asfloat_float4 :: proc "c" (v: float4) -> float4 {…}

    asfloat_float4x1 ¶
    Source

    asfloat_float4x1 :: proc "c" (v: float4x1) -> float4x1 {…}

    asfloat_float4x2 ¶
    Source

    asfloat_float4x2 :: proc "c" (v: float4x2) -> float4x2 {…}

    asfloat_float4x3 ¶
    Source

    asfloat_float4x3 :: proc "c" (v: float4x3) -> float4x3 {…}

    asfloat_float4x4 ¶
    Source

    asfloat_float4x4 :: proc "c" (v: float4x4) -> float4x4 {…}

    asfloat_int ¶
    Source

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

    asfloat_int2 ¶
    Source

    asfloat_int2 :: proc "c" (v: int2) -> float2 {…}

    asfloat_int3 ¶
    Source

    asfloat_int3 :: proc "c" (v: int3) -> float3 {…}

    asfloat_int4 ¶
    Source

    asfloat_int4 :: proc "c" (v: int4) -> float4 {…}

    asfloat_uint ¶
    Source

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

    asfloat_uint2 ¶
    Source

    asfloat_uint2 :: proc "c" (v: uint2) -> float2 {…}

    asfloat_uint3 ¶
    Source

    asfloat_uint3 :: proc "c" (v: uint3) -> float3 {…}

    asfloat_uint4 ¶
    Source

    asfloat_uint4 :: proc "c" (v: uint4) -> float4 {…}

    asin_double ¶
    Source

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

    asin_double2 ¶
    Source

    asin_double2 :: proc "c" (x: double2) -> double2 {…}

    asin_double3 ¶
    Source

    asin_double3 :: proc "c" (x: double3) -> double3 {…}

    asin_double4 ¶
    Source

    asin_double4 :: proc "c" (x: double4) -> double4 {…}

    asin_float ¶
    Source

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

    asin_float2 ¶
    Source

    asin_float2 :: proc "c" (x: float2) -> float2 {…}

    asin_float3 ¶
    Source

    asin_float3 :: proc "c" (x: float3) -> float3 {…}

    asin_float4 ¶
    Source

    asin_float4 :: proc "c" (x: float4) -> float4 {…}

    asinh_double ¶
    Source

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

    asinh_double2 ¶
    Source

    asinh_double2 :: proc "c" (x: double2) -> double2 {…}

    asinh_double3 ¶
    Source

    asinh_double3 :: proc "c" (x: double3) -> double3 {…}

    asinh_double4 ¶
    Source

    asinh_double4 :: proc "c" (x: double4) -> double4 {…}

    asinh_float ¶
    Source

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

    asinh_float2 ¶
    Source

    asinh_float2 :: proc "c" (x: float2) -> float2 {…}

    asinh_float3 ¶
    Source

    asinh_float3 :: proc "c" (x: float3) -> float3 {…}

    asinh_float4 ¶
    Source

    asinh_float4 :: proc "c" (x: float4) -> float4 {…}

    asint_bool2 ¶
    Source

    asint_bool2 :: proc "c" (v: bool2) -> int2 {…}

    asint_bool3 ¶
    Source

    asint_bool3 :: proc "c" (v: bool3) -> int3 {…}

    asint_bool4 ¶
    Source

    asint_bool4 :: proc "c" (v: bool4) -> int4 {…}

    asint_double ¶
    Source

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

    asint_double1x1 ¶
    Source

    asint_double1x1 :: proc "c" (v: double1x1) -> int1x1 {…}

    asint_double1x2 ¶
    Source

    asint_double1x2 :: proc "c" (v: double1x2) -> int1x2 {…}

    asint_double1x3 ¶
    Source

    asint_double1x3 :: proc "c" (v: double1x3) -> int1x3 {…}

    asint_double1x4 ¶
    Source

    asint_double1x4 :: proc "c" (v: double1x4) -> int1x4 {…}

    asint_double2 ¶
    Source

    asint_double2 :: proc "c" (v: double2) -> int2 {…}

    asint_double2x1 ¶
    Source

    asint_double2x1 :: proc "c" (v: double2x1) -> int2x1 {…}

    asint_double2x2 ¶
    Source

    asint_double2x2 :: proc "c" (v: double2x2) -> int2x2 {…}

    asint_double2x3 ¶
    Source

    asint_double2x3 :: proc "c" (v: double2x3) -> int2x3 {…}

    asint_double2x4 ¶
    Source

    asint_double2x4 :: proc "c" (v: double2x4) -> int2x4 {…}

    asint_double3 ¶
    Source

    asint_double3 :: proc "c" (v: double3) -> int3 {…}

    asint_double3x1 ¶
    Source

    asint_double3x1 :: proc "c" (v: double3x1) -> int3x1 {…}

    asint_double3x2 ¶
    Source

    asint_double3x2 :: proc "c" (v: double3x2) -> int3x2 {…}

    asint_double3x3 ¶
    Source

    asint_double3x3 :: proc "c" (v: double3x3) -> int3x3 {…}

    asint_double3x4 ¶
    Source

    asint_double3x4 :: proc "c" (v: double3x4) -> int3x4 {…}

    asint_double4 ¶
    Source

    asint_double4 :: proc "c" (v: double4) -> int4 {…}

    asint_double4x1 ¶
    Source

    asint_double4x1 :: proc "c" (v: double4x1) -> int4x1 {…}

    asint_double4x2 ¶
    Source

    asint_double4x2 :: proc "c" (v: double4x2) -> int4x2 {…}

    asint_double4x3 ¶
    Source

    asint_double4x3 :: proc "c" (v: double4x3) -> int4x3 {…}

    asint_double4x4 ¶
    Source

    asint_double4x4 :: proc "c" (v: double4x4) -> int4x4 {…}

    asint_float ¶
    Source

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

    asint_float1x1 ¶
    Source

    asint_float1x1 :: proc "c" (v: float1x1) -> int1x1 {…}

    asint_float1x2 ¶
    Source

    asint_float1x2 :: proc "c" (v: float1x2) -> int1x2 {…}

    asint_float1x3 ¶
    Source

    asint_float1x3 :: proc "c" (v: float1x3) -> int1x3 {…}

    asint_float1x4 ¶
    Source

    asint_float1x4 :: proc "c" (v: float1x4) -> int1x4 {…}

    asint_float2 ¶
    Source

    asint_float2 :: proc "c" (v: float2) -> int2 {…}

    asint_float2x1 ¶
    Source

    asint_float2x1 :: proc "c" (v: float2x1) -> int2x1 {…}

    asint_float2x2 ¶
    Source

    asint_float2x2 :: proc "c" (v: float2x2) -> int2x2 {…}

    asint_float2x3 ¶
    Source

    asint_float2x3 :: proc "c" (v: float2x3) -> int2x3 {…}

    asint_float2x4 ¶
    Source

    asint_float2x4 :: proc "c" (v: float2x4) -> int2x4 {…}

    asint_float3 ¶
    Source

    asint_float3 :: proc "c" (v: float3) -> int3 {…}

    asint_float3x1 ¶
    Source

    asint_float3x1 :: proc "c" (v: float3x1) -> int3x1 {…}

    asint_float3x2 ¶
    Source

    asint_float3x2 :: proc "c" (v: float3x2) -> int3x2 {…}

    asint_float3x3 ¶
    Source

    asint_float3x3 :: proc "c" (v: float3x3) -> int3x3 {…}

    asint_float3x4 ¶
    Source

    asint_float3x4 :: proc "c" (v: float3x4) -> int3x4 {…}

    asint_float4 ¶
    Source

    asint_float4 :: proc "c" (v: float4) -> int4 {…}

    asint_float4x1 ¶
    Source

    asint_float4x1 :: proc "c" (v: float4x1) -> int4x1 {…}

    asint_float4x2 ¶
    Source

    asint_float4x2 :: proc "c" (v: float4x2) -> int4x2 {…}

    asint_float4x3 ¶
    Source

    asint_float4x3 :: proc "c" (v: float4x3) -> int4x3 {…}

    asint_float4x4 ¶
    Source

    asint_float4x4 :: proc "c" (v: float4x4) -> int4x4 {…}

    asint_int ¶
    Source

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

    asint_int2 ¶
    Source

    asint_int2 :: proc "c" (v: int2) -> int2 {…}

    asint_int3 ¶
    Source

    asint_int3 :: proc "c" (v: int3) -> int3 {…}

    asint_int4 ¶
    Source

    asint_int4 :: proc "c" (v: int4) -> int4 {…}

    asint_uint ¶
    Source

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

    asint_uint2 ¶
    Source

    asint_uint2 :: proc "c" (v: uint2) -> int2 {…}

    asint_uint3 ¶
    Source

    asint_uint3 :: proc "c" (v: uint3) -> int3 {…}

    asint_uint4 ¶
    Source

    asint_uint4 :: proc "c" (v: uint4) -> int4 {…}

    asuint_bool2 ¶
    Source

    asuint_bool2 :: proc "c" (v: bool2) -> uint2 {…}

    asuint_bool3 ¶
    Source

    asuint_bool3 :: proc "c" (v: bool3) -> uint3 {…}

    asuint_bool4 ¶
    Source

    asuint_bool4 :: proc "c" (v: bool4) -> uint4 {…}

    asuint_double ¶
    Source

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

    asuint_double2 ¶
    Source

    asuint_double2 :: proc "c" (v: double2) -> uint2 {…}

    asuint_double3 ¶
    Source

    asuint_double3 :: proc "c" (v: double3) -> uint3 {…}

    asuint_double4 ¶
    Source

    asuint_double4 :: proc "c" (v: double4) -> uint4 {…}

    asuint_float ¶
    Source

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

    asuint_float2 ¶
    Source

    asuint_float2 :: proc "c" (v: float2) -> uint2 {…}

    asuint_float3 ¶
    Source

    asuint_float3 :: proc "c" (v: float3) -> uint3 {…}

    asuint_float4 ¶
    Source

    asuint_float4 :: proc "c" (v: float4) -> uint4 {…}

    asuint_int ¶
    Source

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

    asuint_int2 ¶
    Source

    asuint_int2 :: proc "c" (v: int2) -> uint2 {…}

    asuint_int3 ¶
    Source

    asuint_int3 :: proc "c" (v: int3) -> uint3 {…}

    asuint_int4 ¶
    Source

    asuint_int4 :: proc "c" (v: int4) -> uint4 {…}

    asuint_uint ¶
    Source

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

    asuint_uint2 ¶
    Source

    asuint_uint2 :: proc "c" (v: uint2) -> uint2 {…}

    asuint_uint3 ¶
    Source

    asuint_uint3 :: proc "c" (v: uint3) -> uint3 {…}

    asuint_uint4 ¶
    Source

    asuint_uint4 :: proc "c" (v: uint4) -> uint4 {…}

    atan2_double ¶
    Source

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

    atan2_double2 ¶
    Source

    atan2_double2 :: proc "c" (y, x: double2) -> double2 {…}

    atan2_double3 ¶
    Source

    atan2_double3 :: proc "c" (y, x: double3) -> double3 {…}

    atan2_double4 ¶
    Source

    atan2_double4 :: proc "c" (y, x: double4) -> double4 {…}

    atan2_float ¶
    Source

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

    atan2_float2 ¶
    Source

    atan2_float2 :: proc "c" (y, x: float2) -> float2 {…}

    atan2_float3 ¶
    Source

    atan2_float3 :: proc "c" (y, x: float3) -> float3 {…}

    atan2_float4 ¶
    Source

    atan2_float4 :: proc "c" (y, x: float4) -> float4 {…}

    atan_double ¶
    Source

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

    atan_double2 ¶
    Source

    atan_double2 :: proc "c" (x: double2) -> double2 {…}

    atan_double3 ¶
    Source

    atan_double3 :: proc "c" (x: double3) -> double3 {…}

    atan_double4 ¶
    Source

    atan_double4 :: proc "c" (x: double4) -> double4 {…}

    atan_float ¶
    Source

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

    atan_float2 ¶
    Source

    atan_float2 :: proc "c" (x: float2) -> float2 {…}

    atan_float3 ¶
    Source

    atan_float3 :: proc "c" (x: float3) -> float3 {…}

    atan_float4 ¶
    Source

    atan_float4 :: proc "c" (x: float4) -> float4 {…}

    atanh_double ¶
    Source

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

    atanh_double2 ¶
    Source

    atanh_double2 :: proc "c" (x: double2) -> double2 {…}

    atanh_double3 ¶
    Source

    atanh_double3 :: proc "c" (x: double3) -> double3 {…}

    atanh_double4 ¶
    Source

    atanh_double4 :: proc "c" (x: double4) -> double4 {…}

    atanh_float ¶
    Source

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

    atanh_float2 ¶
    Source

    atanh_float2 :: proc "c" (x: float2) -> float2 {…}

    atanh_float3 ¶
    Source

    atanh_float3 :: proc "c" (x: float3) -> float3 {…}

    atanh_float4 ¶
    Source

    atanh_float4 :: proc "c" (x: float4) -> float4 {…}

    ceil_double ¶
    Source

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

    ceil_double2 ¶
    Source

    ceil_double2 :: proc "c" (x: double2) -> double2 {…}

    ceil_double3 ¶
    Source

    ceil_double3 :: proc "c" (x: double3) -> double3 {…}

    ceil_double4 ¶
    Source

    ceil_double4 :: proc "c" (x: double4) -> double4 {…}

    ceil_float ¶
    Source

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

    ceil_float2 ¶
    Source

    ceil_float2 :: proc "c" (x: float2) -> float2 {…}

    ceil_float3 ¶
    Source

    ceil_float3 :: proc "c" (x: float3) -> float3 {…}

    ceil_float4 ¶
    Source

    ceil_float4 :: proc "c" (x: float4) -> float4 {…}

    clamp_double ¶
    Source

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

    clamp_double2 ¶
    Source

    clamp_double2 :: proc "c" (x, y, z: double2) -> double2 {…}

    clamp_double3 ¶
    Source

    clamp_double3 :: proc "c" (x, y, z: double3) -> double3 {…}

    clamp_double4 ¶
    Source

    clamp_double4 :: proc "c" (x, y, z: double4) -> double4 {…}

    clamp_float ¶
    Source

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

    clamp_float2 ¶
    Source

    clamp_float2 :: proc "c" (x, y, z: float2) -> float2 {…}

    clamp_float3 ¶
    Source

    clamp_float3 :: proc "c" (x, y, z: float3) -> float3 {…}

    clamp_float4 ¶
    Source

    clamp_float4 :: proc "c" (x, y, z: float4) -> float4 {…}

    clamp_int ¶
    Source

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

    clamp_int2 ¶
    Source

    clamp_int2 :: proc "c" (x, y, z: int2) -> int2 {…}

    clamp_int3 ¶
    Source

    clamp_int3 :: proc "c" (x, y, z: int3) -> int3 {…}

    clamp_int4 ¶
    Source

    clamp_int4 :: proc "c" (x, y, z: int4) -> int4 {…}

    clamp_uint ¶
    Source

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

    clamp_uint2 ¶
    Source

    clamp_uint2 :: proc "c" (x, y, z: uint2) -> uint2 {…}

    clamp_uint3 ¶
    Source

    clamp_uint3 :: proc "c" (x, y, z: uint3) -> uint3 {…}

    clamp_uint4 ¶
    Source

    clamp_uint4 :: proc "c" (x, y, z: uint4) -> uint4 {…}

    cos_double ¶
    Source

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

    cos_double2 ¶
    Source

    cos_double2 :: proc "c" (x: double2) -> double2 {…}

    cos_double3 ¶
    Source

    cos_double3 :: proc "c" (x: double3) -> double3 {…}

    cos_double4 ¶
    Source

    cos_double4 :: proc "c" (x: double4) -> double4 {…}

    cos_float ¶
    Source

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

    cos_float2 ¶
    Source

    cos_float2 :: proc "c" (x: float2) -> float2 {…}

    cos_float3 ¶
    Source

    cos_float3 :: proc "c" (x: float3) -> float3 {…}

    cos_float4 ¶
    Source

    cos_float4 :: proc "c" (x: float4) -> float4 {…}

    cosh_double ¶
    Source

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

    cosh_double2 ¶
    Source

    cosh_double2 :: proc "c" (x: double2) -> double2 {…}

    cosh_double3 ¶
    Source

    cosh_double3 :: proc "c" (x: double3) -> double3 {…}

    cosh_double4 ¶
    Source

    cosh_double4 :: proc "c" (x: double4) -> double4 {…}

    cosh_float ¶
    Source

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

    cosh_float2 ¶
    Source

    cosh_float2 :: proc "c" (x: float2) -> float2 {…}

    cosh_float3 ¶
    Source

    cosh_float3 :: proc "c" (x: float3) -> float3 {…}

    cosh_float4 ¶
    Source

    cosh_float4 :: proc "c" (x: float4) -> float4 {…}

    cross_double3 ¶
    Source

    cross_double3 :: proc "c" (a, b: double3) -> (c: double3) {…}

    cross_float3 ¶
    Source

    cross_float3 :: proc "c" (a, b: float3) -> (c: float3) {…}

    cross_int3 ¶
    Source

    cross_int3 :: proc "c" (a, b: int3) -> (c: int3) {…}

    degrees_double ¶
    Source

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

    degrees_double2 ¶
    Source

    degrees_double2 :: proc "c" (radians: double2) -> double2 {…}

    degrees_double3 ¶
    Source

    degrees_double3 :: proc "c" (radians: double3) -> double3 {…}

    degrees_double4 ¶
    Source

    degrees_double4 :: proc "c" (radians: double4) -> double4 {…}

    degrees_float ¶
    Source

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

    degrees_float2 ¶
    Source

    degrees_float2 :: proc "c" (radians: float2) -> float2 {…}

    degrees_float3 ¶
    Source

    degrees_float3 :: proc "c" (radians: float3) -> float3 {…}

    degrees_float4 ¶
    Source

    degrees_float4 :: proc "c" (radians: float4) -> float4 {…}

    determinant_matrix1x1 ¶
    Source

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

    determinant_matrix2x2 ¶
    Source

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

    determinant_matrix3x3 ¶
    Source

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

    determinant_matrix4x4 ¶
    Source

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

    distance_double ¶
    Source

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

    distance_double2 ¶
    Source

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

    distance_double3 ¶
    Source

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

    distance_double4 ¶
    Source

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

    distance_float ¶
    Source

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

    distance_float2 ¶
    Source

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

    distance_float3 ¶
    Source

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

    distance_float4 ¶
    Source

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

    dot_double ¶
    Source

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

    dot_double2 ¶
    Source

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

    dot_double3 ¶
    Source

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

    dot_double4 ¶
    Source

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

    dot_float ¶
    Source

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

    dot_float2 ¶
    Source

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

    dot_float3 ¶
    Source

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

    dot_float4 ¶
    Source

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

    dot_int ¶
    Source

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

    dot_int2 ¶
    Source

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

    dot_int3 ¶
    Source

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

    dot_int4 ¶
    Source

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

    dot_uint ¶
    Source

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

    dot_uint2 ¶
    Source

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

    dot_uint3 ¶
    Source

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

    dot_uint4 ¶
    Source

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

    equal_double ¶
    Source

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

    equal_double2 ¶
    Source

    equal_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    equal_double3 ¶
    Source

    equal_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    equal_double4 ¶
    Source

    equal_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    equal_float ¶
    Source

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

    equal_float2 ¶
    Source

    equal_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    equal_float3 ¶
    Source

    equal_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    equal_float4 ¶
    Source

    equal_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    equal_int ¶
    Source

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

    equal_int2 ¶
    Source

    equal_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    equal_int3 ¶
    Source

    equal_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    equal_int4 ¶
    Source

    equal_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    equal_uint ¶
    Source

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

    equal_uint2 ¶
    Source

    equal_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    equal_uint3 ¶
    Source

    equal_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    equal_uint4 ¶
    Source

    equal_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    exp2_double ¶
    Source

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

    exp2_double2 ¶
    Source

    exp2_double2 :: proc "c" (x: double2) -> double2 {…}

    exp2_double3 ¶
    Source

    exp2_double3 :: proc "c" (x: double3) -> double3 {…}

    exp2_double4 ¶
    Source

    exp2_double4 :: proc "c" (x: double4) -> double4 {…}

    exp2_float ¶
    Source

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

    exp2_float2 ¶
    Source

    exp2_float2 :: proc "c" (x: float2) -> float2 {…}

    exp2_float3 ¶
    Source

    exp2_float3 :: proc "c" (x: float3) -> float3 {…}

    exp2_float4 ¶
    Source

    exp2_float4 :: proc "c" (x: float4) -> float4 {…}

    exp_double ¶
    Source

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

    exp_double2 ¶
    Source

    exp_double2 :: proc "c" (x: double2) -> double2 {…}

    exp_double3 ¶
    Source

    exp_double3 :: proc "c" (x: double3) -> double3 {…}

    exp_double4 ¶
    Source

    exp_double4 :: proc "c" (x: double4) -> double4 {…}

    exp_float ¶
    Source

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

    exp_float2 ¶
    Source

    exp_float2 :: proc "c" (x: float2) -> float2 {…}

    exp_float3 ¶
    Source

    exp_float3 :: proc "c" (x: float3) -> float3 {…}

    exp_float4 ¶
    Source

    exp_float4 :: proc "c" (x: float4) -> float4 {…}

    faceforward_double ¶
    Source

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

    faceforward_double2 ¶
    Source

    faceforward_double2 :: proc "c" (N, I, Nref: double2) -> double2 {…}

    faceforward_double3 ¶
    Source

    faceforward_double3 :: proc "c" (N, I, Nref: double3) -> double3 {…}

    faceforward_double4 ¶
    Source

    faceforward_double4 :: proc "c" (N, I, Nref: double4) -> double4 {…}

    faceforward_float ¶
    Source

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

    faceforward_float2 ¶
    Source

    faceforward_float2 :: proc "c" (N, I, Nref: float2) -> float2 {…}

    faceforward_float3 ¶
    Source

    faceforward_float3 :: proc "c" (N, I, Nref: float3) -> float3 {…}

    faceforward_float4 ¶
    Source

    faceforward_float4 :: proc "c" (N, I, Nref: float4) -> float4 {…}

    floor_double ¶
    Source

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

    floor_double2 ¶
    Source

    floor_double2 :: proc "c" (x: double2) -> double2 {…}

    floor_double3 ¶
    Source

    floor_double3 :: proc "c" (x: double3) -> double3 {…}

    floor_double4 ¶
    Source

    floor_double4 :: proc "c" (x: double4) -> double4 {…}

    floor_float ¶
    Source

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

    floor_float2 ¶
    Source

    floor_float2 :: proc "c" (x: float2) -> float2 {…}

    floor_float3 ¶
    Source

    floor_float3 :: proc "c" (x: float3) -> float3 {…}

    floor_float4 ¶
    Source

    floor_float4 :: proc "c" (x: float4) -> float4 {…}

    fmod_double ¶
    Source

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

    fmod_double2 ¶
    Source

    fmod_double2 :: proc "c" (x, y: double2) -> double2 {…}

    fmod_double3 ¶
    Source

    fmod_double3 :: proc "c" (x, y: double3) -> double3 {…}

    fmod_double4 ¶
    Source

    fmod_double4 :: proc "c" (x, y: double4) -> double4 {…}

    fmod_float ¶
    Source

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

    fmod_float2 ¶
    Source

    fmod_float2 :: proc "c" (x, y: float2) -> float2 {…}

    fmod_float3 ¶
    Source

    fmod_float3 :: proc "c" (x, y: float3) -> float3 {…}

    fmod_float4 ¶
    Source

    fmod_float4 :: proc "c" (x, y: float4) -> float4 {…}

    frac_double ¶
    Source

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

    frac_double2 ¶
    Source

    frac_double2 :: proc "c" (x: double2) -> double2 {…}

    frac_double3 ¶
    Source

    frac_double3 :: proc "c" (x: double3) -> double3 {…}

    frac_double4 ¶
    Source

    frac_double4 :: proc "c" (x: double4) -> double4 {…}

    frac_float ¶
    Source

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

    frac_float2 ¶
    Source

    frac_float2 :: proc "c" (x: float2) -> float2 {…}

    frac_float3 ¶
    Source

    frac_float3 :: proc "c" (x: float3) -> float3 {…}

    frac_float4 ¶
    Source

    frac_float4 :: proc "c" (x: float4) -> float4 {…}

    greaterThanEqual_double ¶
    Source

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

    greaterThanEqual_double2 ¶
    Source

    greaterThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    greaterThanEqual_double3 ¶
    Source

    greaterThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    greaterThanEqual_double4 ¶
    Source

    greaterThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    greaterThanEqual_float ¶
    Source

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

    greaterThanEqual_float2 ¶
    Source

    greaterThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    greaterThanEqual_float3 ¶
    Source

    greaterThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    greaterThanEqual_float4 ¶
    Source

    greaterThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    greaterThanEqual_int ¶
    Source

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

    greaterThanEqual_int2 ¶
    Source

    greaterThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    greaterThanEqual_int3 ¶
    Source

    greaterThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    greaterThanEqual_int4 ¶
    Source

    greaterThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    greaterThanEqual_uint ¶
    Source

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

    greaterThanEqual_uint2 ¶
    Source

    greaterThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    greaterThanEqual_uint3 ¶
    Source

    greaterThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    greaterThanEqual_uint4 ¶
    Source

    greaterThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    greaterThan_double ¶
    Source

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

    greaterThan_double2 ¶
    Source

    greaterThan_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    greaterThan_double3 ¶
    Source

    greaterThan_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    greaterThan_double4 ¶
    Source

    greaterThan_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    greaterThan_float ¶
    Source

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

    greaterThan_float2 ¶
    Source

    greaterThan_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    greaterThan_float3 ¶
    Source

    greaterThan_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    greaterThan_float4 ¶
    Source

    greaterThan_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    greaterThan_int ¶
    Source

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

    greaterThan_int2 ¶
    Source

    greaterThan_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    greaterThan_int3 ¶
    Source

    greaterThan_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    greaterThan_int4 ¶
    Source

    greaterThan_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    greaterThan_uint ¶
    Source

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

    greaterThan_uint2 ¶
    Source

    greaterThan_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    greaterThan_uint3 ¶
    Source

    greaterThan_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    greaterThan_uint4 ¶
    Source

    greaterThan_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    hermitian_adjoint ¶
    Source

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

    inverse_double1x1 ¶
    Source

    inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 {…}

    inverse_double2x2 ¶
    Source

    inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 {…}

    inverse_double3x3 ¶
    Source

    inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 {…}

    inverse_double4x4 ¶
    Source

    inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 {…}

    inverse_float1x1 ¶
    Source

    inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 {…}

    inverse_float2x2 ¶
    Source

    inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 {…}

    inverse_float3x3 ¶
    Source

    inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 {…}

    inverse_float4x4 ¶
    Source

    inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 {…}

    inverse_matrix1x1 ¶
    Source

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

    inverse_matrix2x2 ¶
    Source

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

    inverse_matrix3x3 ¶
    Source

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

    inverse_matrix4x4 ¶
    Source

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

    inverse_transpose_matrix1x1 ¶
    Source

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

    inverse_transpose_matrix2x2 ¶
    Source

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

    inverse_transpose_matrix3x3 ¶
    Source

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

    inverse_transpose_matrix4x4 ¶
    Source

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

    isfinite_double ¶
    Source

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

    isfinite_double2 ¶
    Source

    isfinite_double2 :: proc "c" (x: double2) -> bool2 {…}

    isfinite_double3 ¶
    Source

    isfinite_double3 :: proc "c" (x: double3) -> bool3 {…}

    isfinite_double4 ¶
    Source

    isfinite_double4 :: proc "c" (x: double4) -> bool4 {…}

    isfinite_float ¶
    Source

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

    isfinite_float2 ¶
    Source

    isfinite_float2 :: proc "c" (x: float2) -> bool2 {…}

    isfinite_float3 ¶
    Source

    isfinite_float3 :: proc "c" (x: float3) -> bool3 {…}

    isfinite_float4 ¶
    Source

    isfinite_float4 :: proc "c" (x: float4) -> bool4 {…}

    isinf_double ¶
    Source

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

    isinf_double2 ¶
    Source

    isinf_double2 :: proc "c" (x: double2) -> bool2 {…}

    isinf_double3 ¶
    Source

    isinf_double3 :: proc "c" (x: double3) -> bool3 {…}

    isinf_double4 ¶
    Source

    isinf_double4 :: proc "c" (x: double4) -> bool4 {…}

    isinf_float ¶
    Source

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

    isinf_float2 ¶
    Source

    isinf_float2 :: proc "c" (x: float2) -> bool2 {…}

    isinf_float3 ¶
    Source

    isinf_float3 :: proc "c" (x: float3) -> bool3 {…}

    isinf_float4 ¶
    Source

    isinf_float4 :: proc "c" (x: float4) -> bool4 {…}

    isnan_double ¶
    Source

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

    isnan_double2 ¶
    Source

    isnan_double2 :: proc "c" (x: double2) -> bool2 {…}

    isnan_double3 ¶
    Source

    isnan_double3 :: proc "c" (x: double3) -> bool3 {…}

    isnan_double4 ¶
    Source

    isnan_double4 :: proc "c" (x: double4) -> bool4 {…}

    isnan_float ¶
    Source

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

    isnan_float2 ¶
    Source

    isnan_float2 :: proc "c" (x: float2) -> bool2 {…}

    isnan_float3 ¶
    Source

    isnan_float3 :: proc "c" (x: float3) -> bool3 {…}

    isnan_float4 ¶
    Source

    isnan_float4 :: proc "c" (x: float4) -> bool4 {…}

    length_double ¶
    Source

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

    length_double2 ¶
    Source

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

    length_double3 ¶
    Source

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

    length_double4 ¶
    Source

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

    length_float ¶
    Source

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

    length_float2 ¶
    Source

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

    length_float3 ¶
    Source

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

    length_float4 ¶
    Source

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

    lerp_double ¶
    Source

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

    lerp_double2 ¶
    Source

    lerp_double2 :: proc "c" (x, y, t: double2) -> double2 {…}

    lerp_double3 ¶
    Source

    lerp_double3 :: proc "c" (x, y, t: double3) -> double3 {…}

    lerp_double4 ¶
    Source

    lerp_double4 :: proc "c" (x, y, t: double4) -> double4 {…}

    lerp_float ¶
    Source

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

    lerp_float2 ¶
    Source

    lerp_float2 :: proc "c" (x, y, t: float2) -> float2 {…}

    lerp_float3 ¶
    Source

    lerp_float3 :: proc "c" (x, y, t: float3) -> float3 {…}

    lerp_float4 ¶
    Source

    lerp_float4 :: proc "c" (x, y, t: float4) -> float4 {…}

    lessThanEqual_double ¶
    Source

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

    lessThanEqual_double2 ¶
    Source

    lessThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    lessThanEqual_double3 ¶
    Source

    lessThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    lessThanEqual_double4 ¶
    Source

    lessThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    lessThanEqual_float ¶
    Source

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

    lessThanEqual_float2 ¶
    Source

    lessThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    lessThanEqual_float3 ¶
    Source

    lessThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    lessThanEqual_float4 ¶
    Source

    lessThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    lessThanEqual_int ¶
    Source

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

    lessThanEqual_int2 ¶
    Source

    lessThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    lessThanEqual_int3 ¶
    Source

    lessThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    lessThanEqual_int4 ¶
    Source

    lessThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    lessThanEqual_uint ¶
    Source

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

    lessThanEqual_uint2 ¶
    Source

    lessThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    lessThanEqual_uint3 ¶
    Source

    lessThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    lessThanEqual_uint4 ¶
    Source

    lessThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    lessThan_double ¶
    Source

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

    lessThan_double2 ¶
    Source

    lessThan_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    lessThan_double3 ¶
    Source

    lessThan_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    lessThan_double4 ¶
    Source

    lessThan_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    lessThan_float ¶
    Source

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

    lessThan_float2 ¶
    Source

    lessThan_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    lessThan_float3 ¶
    Source

    lessThan_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    lessThan_float4 ¶
    Source

    lessThan_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    lessThan_int ¶
    Source

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

    lessThan_int2 ¶
    Source

    lessThan_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    lessThan_int3 ¶
    Source

    lessThan_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    lessThan_int4 ¶
    Source

    lessThan_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    lessThan_uint ¶
    Source

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

    lessThan_uint2 ¶
    Source

    lessThan_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    lessThan_uint3 ¶
    Source

    lessThan_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    lessThan_uint4 ¶
    Source

    lessThan_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    log10_double ¶
    Source

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

    log10_double2 ¶
    Source

    log10_double2 :: proc "c" (x: double2) -> double2 {…}

    log10_double3 ¶
    Source

    log10_double3 :: proc "c" (x: double3) -> double3 {…}

    log10_double4 ¶
    Source

    log10_double4 :: proc "c" (x: double4) -> double4 {…}

    log10_float ¶
    Source

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

    log10_float2 ¶
    Source

    log10_float2 :: proc "c" (x: float2) -> float2 {…}

    log10_float3 ¶
    Source

    log10_float3 :: proc "c" (x: float3) -> float3 {…}

    log10_float4 ¶
    Source

    log10_float4 :: proc "c" (x: float4) -> float4 {…}

    log2_double ¶
    Source

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

    log2_double2 ¶
    Source

    log2_double2 :: proc "c" (x: double2) -> double2 {…}

    log2_double3 ¶
    Source

    log2_double3 :: proc "c" (x: double3) -> double3 {…}

    log2_double4 ¶
    Source

    log2_double4 :: proc "c" (x: double4) -> double4 {…}

    log2_float ¶
    Source

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

    log2_float2 ¶
    Source

    log2_float2 :: proc "c" (x: float2) -> float2 {…}

    log2_float3 ¶
    Source

    log2_float3 :: proc "c" (x: float3) -> float3 {…}

    log2_float4 ¶
    Source

    log2_float4 :: proc "c" (x: float4) -> float4 {…}

    log_double ¶
    Source

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

    log_double2 ¶
    Source

    log_double2 :: proc "c" (x: double2) -> double2 {…}

    log_double3 ¶
    Source

    log_double3 :: proc "c" (x: double3) -> double3 {…}

    log_double4 ¶
    Source

    log_double4 :: proc "c" (x: double4) -> double4 {…}

    log_float ¶
    Source

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

    log_float2 ¶
    Source

    log_float2 :: proc "c" (x: float2) -> float2 {…}

    log_float3 ¶
    Source

    log_float3 :: proc "c" (x: float3) -> float3 {…}

    log_float4 ¶
    Source

    log_float4 :: proc "c" (x: float4) -> float4 {…}

    matrix_minor ¶
    Source

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

    max_double ¶
    Source

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

    max_double2 ¶
    Source

    max_double2 :: proc "c" (x, y: double2) -> double2 {…}

    max_double3 ¶
    Source

    max_double3 :: proc "c" (x, y: double3) -> double3 {…}

    max_double4 ¶
    Source

    max_double4 :: proc "c" (x, y: double4) -> double4 {…}

    max_float ¶
    Source

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

    max_float2 ¶
    Source

    max_float2 :: proc "c" (x, y: float2) -> float2 {…}

    max_float3 ¶
    Source

    max_float3 :: proc "c" (x, y: float3) -> float3 {…}

    max_float4 ¶
    Source

    max_float4 :: proc "c" (x, y: float4) -> float4 {…}

    max_int ¶
    Source

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

    max_int2 ¶
    Source

    max_int2 :: proc "c" (x, y: int2) -> int2 {…}

    max_int3 ¶
    Source

    max_int3 :: proc "c" (x, y: int3) -> int3 {…}

    max_int4 ¶
    Source

    max_int4 :: proc "c" (x, y: int4) -> int4 {…}

    max_uint ¶
    Source

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

    max_uint2 ¶
    Source

    max_uint2 :: proc "c" (x, y: uint2) -> uint2 {…}

    max_uint3 ¶
    Source

    max_uint3 :: proc "c" (x, y: uint3) -> uint3 {…}

    max_uint4 ¶
    Source

    max_uint4 :: proc "c" (x, y: uint4) -> uint4 {…}

    min_double ¶
    Source

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

    min_double2 ¶
    Source

    min_double2 :: proc "c" (x, y: double2) -> double2 {…}

    min_double3 ¶
    Source

    min_double3 :: proc "c" (x, y: double3) -> double3 {…}

    min_double4 ¶
    Source

    min_double4 :: proc "c" (x, y: double4) -> double4 {…}

    min_float ¶
    Source

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

    min_float2 ¶
    Source

    min_float2 :: proc "c" (x, y: float2) -> float2 {…}

    min_float3 ¶
    Source

    min_float3 :: proc "c" (x, y: float3) -> float3 {…}

    min_float4 ¶
    Source

    min_float4 :: proc "c" (x, y: float4) -> float4 {…}

    min_int ¶
    Source

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

    min_int2 ¶
    Source

    min_int2 :: proc "c" (x, y: int2) -> int2 {…}

    min_int3 ¶
    Source

    min_int3 :: proc "c" (x, y: int3) -> int3 {…}

    min_int4 ¶
    Source

    min_int4 :: proc "c" (x, y: int4) -> int4 {…}

    min_uint ¶
    Source

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

    min_uint2 ¶
    Source

    min_uint2 :: proc "c" (x, y: uint2) -> uint2 {…}

    min_uint3 ¶
    Source

    min_uint3 :: proc "c" (x, y: uint3) -> uint3 {…}

    min_uint4 ¶
    Source

    min_uint4 :: proc "c" (x, y: uint4) -> uint4 {…}

    normalize_double ¶
    Source

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

    normalize_double2 ¶
    Source

    normalize_double2 :: proc "c" (x: double2) -> double2 {…}

    normalize_double3 ¶
    Source

    normalize_double3 :: proc "c" (x: double3) -> double3 {…}

    normalize_double4 ¶
    Source

    normalize_double4 :: proc "c" (x: double4) -> double4 {…}

    normalize_float ¶
    Source

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

    normalize_float2 ¶
    Source

    normalize_float2 :: proc "c" (x: float2) -> float2 {…}

    normalize_float3 ¶
    Source

    normalize_float3 :: proc "c" (x: float3) -> float3 {…}

    normalize_float4 ¶
    Source

    normalize_float4 :: proc "c" (x: float4) -> float4 {…}

    notEqual_double ¶
    Source

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

    notEqual_double2 ¶
    Source

    notEqual_double2 :: proc "c" (a, b: double2) -> bool2 {…}

    notEqual_double3 ¶
    Source

    notEqual_double3 :: proc "c" (a, b: double3) -> bool3 {…}

    notEqual_double4 ¶
    Source

    notEqual_double4 :: proc "c" (a, b: double4) -> bool4 {…}

    notEqual_float ¶
    Source

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

    notEqual_float2 ¶
    Source

    notEqual_float2 :: proc "c" (a, b: float2) -> bool2 {…}

    notEqual_float3 ¶
    Source

    notEqual_float3 :: proc "c" (a, b: float3) -> bool3 {…}

    notEqual_float4 ¶
    Source

    notEqual_float4 :: proc "c" (a, b: float4) -> bool4 {…}

    notEqual_int ¶
    Source

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

    notEqual_int2 ¶
    Source

    notEqual_int2 :: proc "c" (a, b: int2) -> bool2 {…}

    notEqual_int3 ¶
    Source

    notEqual_int3 :: proc "c" (a, b: int3) -> bool3 {…}

    notEqual_int4 ¶
    Source

    notEqual_int4 :: proc "c" (a, b: int4) -> bool4 {…}

    notEqual_uint ¶
    Source

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

    notEqual_uint2 ¶
    Source

    notEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 {…}

    notEqual_uint3 ¶
    Source

    notEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 {…}

    notEqual_uint4 ¶
    Source

    notEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 {…}

    not_bool ¶
    Source

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

    not_bool2 ¶
    Source

    not_bool2 :: proc "c" (v: bool2) -> bool2 {…}

    not_bool3 ¶
    Source

    not_bool3 :: proc "c" (v: bool3) -> bool3 {…}

    not_bool4 ¶
    Source

    not_bool4 :: proc "c" (v: bool4) -> bool4 {…}

    pow_double ¶
    Source

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

    pow_double2 ¶
    Source

    pow_double2 :: proc "c" (x, y: double2) -> double2 {…}

    pow_double3 ¶
    Source

    pow_double3 :: proc "c" (x, y: double3) -> double3 {…}

    pow_double4 ¶
    Source

    pow_double4 :: proc "c" (x, y: double4) -> double4 {…}

    pow_float ¶
    Source

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

    pow_float2 ¶
    Source

    pow_float2 :: proc "c" (x, y: float2) -> float2 {…}

    pow_float3 ¶
    Source

    pow_float3 :: proc "c" (x, y: float3) -> float3 {…}

    pow_float4 ¶
    Source

    pow_float4 :: proc "c" (x, y: float4) -> float4 {…}

    radians_double ¶
    Source

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

    radians_double2 ¶
    Source

    radians_double2 :: proc "c" (degrees: double2) -> double2 {…}

    radians_double3 ¶
    Source

    radians_double3 :: proc "c" (degrees: double3) -> double3 {…}

    radians_double4 ¶
    Source

    radians_double4 :: proc "c" (degrees: double4) -> double4 {…}

    radians_float ¶
    Source

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

    radians_float2 ¶
    Source

    radians_float2 :: proc "c" (degrees: float2) -> float2 {…}

    radians_float3 ¶
    Source

    radians_float3 :: proc "c" (degrees: float3) -> float3 {…}

    radians_float4 ¶
    Source

    radians_float4 :: proc "c" (degrees: float4) -> float4 {…}

    rcp_double ¶
    Source

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

    rcp_double2 ¶
    Source

    rcp_double2 :: proc "c" (x: double2) -> double2 {…}

    rcp_double3 ¶
    Source

    rcp_double3 :: proc "c" (x: double3) -> double3 {…}

    rcp_double4 ¶
    Source

    rcp_double4 :: proc "c" (x: double4) -> double4 {…}

    rcp_float ¶
    Source

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

    rcp_float2 ¶
    Source

    rcp_float2 :: proc "c" (x: float2) -> float2 {…}

    rcp_float3 ¶
    Source

    rcp_float3 :: proc "c" (x: float3) -> float3 {…}

    rcp_float4 ¶
    Source

    rcp_float4 :: proc "c" (x: float4) -> float4 {…}

    reflect_double ¶
    Source

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

    reflect_double2 ¶
    Source

    reflect_double2 :: proc "c" (I, N: double2) -> double2 {…}

    reflect_double3 ¶
    Source

    reflect_double3 :: proc "c" (I, N: double3) -> double3 {…}

    reflect_double4 ¶
    Source

    reflect_double4 :: proc "c" (I, N: double4) -> double4 {…}

    reflect_float ¶
    Source

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

    reflect_float2 ¶
    Source

    reflect_float2 :: proc "c" (I, N: float2) -> float2 {…}

    reflect_float3 ¶
    Source

    reflect_float3 :: proc "c" (I, N: float3) -> float3 {…}

    reflect_float4 ¶
    Source

    reflect_float4 :: proc "c" (I, N: float4) -> float4 {…}

    refract_double ¶
    Source

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

    refract_double2 ¶
    Source

    refract_double2 :: proc "c" (i, n, eta: double2) -> double2 {…}

    refract_double3 ¶
    Source

    refract_double3 :: proc "c" (i, n, eta: double3) -> double3 {…}

    refract_double4 ¶
    Source

    refract_double4 :: proc "c" (i, n, eta: double4) -> double4 {…}

    refract_float ¶
    Source

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

    refract_float2 ¶
    Source

    refract_float2 :: proc "c" (i, n, eta: float2) -> float2 {…}

    refract_float3 ¶
    Source

    refract_float3 :: proc "c" (i, n, eta: float3) -> float3 {…}

    refract_float4 ¶
    Source

    refract_float4 :: proc "c" (i, n, eta: float4) -> float4 {…}

    round_double ¶
    Source

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

    round_double2 ¶
    Source

    round_double2 :: proc "c" (x: double2) -> double2 {…}

    round_double3 ¶
    Source

    round_double3 :: proc "c" (x: double3) -> double3 {…}

    round_double4 ¶
    Source

    round_double4 :: proc "c" (x: double4) -> double4 {…}

    round_float ¶
    Source

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

    round_float2 ¶
    Source

    round_float2 :: proc "c" (x: float2) -> float2 {…}

    round_float3 ¶
    Source

    round_float3 :: proc "c" (x: float3) -> float3 {…}

    round_float4 ¶
    Source

    round_float4 :: proc "c" (x: float4) -> float4 {…}

    rsqrt_double ¶
    Source

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

    rsqrt_double2 ¶
    Source

    rsqrt_double2 :: proc "c" (x: double2) -> double2 {…}

    rsqrt_double3 ¶
    Source

    rsqrt_double3 :: proc "c" (x: double3) -> double3 {…}

    rsqrt_double4 ¶
    Source

    rsqrt_double4 :: proc "c" (x: double4) -> double4 {…}

    rsqrt_float ¶
    Source

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

    rsqrt_float2 ¶
    Source

    rsqrt_float2 :: proc "c" (x: float2) -> float2 {…}

    rsqrt_float3 ¶
    Source

    rsqrt_float3 :: proc "c" (x: float3) -> float3 {…}

    rsqrt_float4 ¶
    Source

    rsqrt_float4 :: proc "c" (x: float4) -> float4 {…}

    saturate_double ¶
    Source

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

    saturate_double2 ¶
    Source

    saturate_double2 :: proc "c" (v: double2) -> double2 {…}

    saturate_double3 ¶
    Source

    saturate_double3 :: proc "c" (v: double3) -> double3 {…}

    saturate_double4 ¶
    Source

    saturate_double4 :: proc "c" (v: double4) -> double4 {…}

    saturate_float ¶
    Source

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

    saturate_float2 ¶
    Source

    saturate_float2 :: proc "c" (v: float2) -> float2 {…}

    saturate_float3 ¶
    Source

    saturate_float3 :: proc "c" (v: float3) -> float3 {…}

    saturate_float4 ¶
    Source

    saturate_float4 :: proc "c" (v: float4) -> float4 {…}

    saturate_int ¶
    Source

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

    saturate_int2 ¶
    Source

    saturate_int2 :: proc "c" (v: int2) -> int2 {…}

    saturate_int3 ¶
    Source

    saturate_int3 :: proc "c" (v: int3) -> int3 {…}

    saturate_int4 ¶
    Source

    saturate_int4 :: proc "c" (v: int4) -> int4 {…}

    saturate_uint ¶
    Source

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

    saturate_uint2 ¶
    Source

    saturate_uint2 :: proc "c" (v: uint2) -> uint2 {…}

    saturate_uint3 ¶
    Source

    saturate_uint3 :: proc "c" (v: uint3) -> uint3 {…}

    saturate_uint4 ¶
    Source

    saturate_uint4 :: proc "c" (v: uint4) -> uint4 {…}

    scalarTripleProduct_double3 ¶
    Source

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

    scalarTripleProduct_float3 ¶
    Source

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

    scalarTripleProduct_int3 ¶
    Source

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

    sign_double ¶
    Source

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

    sign_double2 ¶
    Source

    sign_double2 :: proc "c" (x: double2) -> double2 {…}

    sign_double3 ¶
    Source

    sign_double3 :: proc "c" (x: double3) -> double3 {…}

    sign_double4 ¶
    Source

    sign_double4 :: proc "c" (x: double4) -> double4 {…}

    sign_float ¶
    Source

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

    sign_float2 ¶
    Source

    sign_float2 :: proc "c" (x: float2) -> float2 {…}

    sign_float3 ¶
    Source

    sign_float3 :: proc "c" (x: float3) -> float3 {…}

    sign_float4 ¶
    Source

    sign_float4 :: proc "c" (x: float4) -> float4 {…}

    sign_int ¶
    Source

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

    sign_int2 ¶
    Source

    sign_int2 :: proc "c" (x: int2) -> int2 {…}

    sign_int3 ¶
    Source

    sign_int3 :: proc "c" (x: int3) -> int3 {…}

    sign_int4 ¶
    Source

    sign_int4 :: proc "c" (x: int4) -> int4 {…}

    sign_uint ¶
    Source

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

    sign_uint2 ¶
    Source

    sign_uint2 :: proc "c" (x: uint2) -> uint2 {…}

    sign_uint3 ¶
    Source

    sign_uint3 :: proc "c" (x: uint3) -> uint3 {…}

    sign_uint4 ¶
    Source

    sign_uint4 :: proc "c" (x: uint4) -> uint4 {…}

    sin_double ¶
    Source

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

    sin_double2 ¶
    Source

    sin_double2 :: proc "c" (x: double2) -> double2 {…}

    sin_double3 ¶
    Source

    sin_double3 :: proc "c" (x: double3) -> double3 {…}

    sin_double4 ¶
    Source

    sin_double4 :: proc "c" (x: double4) -> double4 {…}

    sin_float ¶
    Source

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

    sin_float2 ¶
    Source

    sin_float2 :: proc "c" (x: float2) -> float2 {…}

    sin_float3 ¶
    Source

    sin_float3 :: proc "c" (x: float3) -> float3 {…}

    sin_float4 ¶
    Source

    sin_float4 :: proc "c" (x: float4) -> float4 {…}

    sinh_double ¶
    Source

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

    sinh_double2 ¶
    Source

    sinh_double2 :: proc "c" (x: double2) -> double2 {…}

    sinh_double3 ¶
    Source

    sinh_double3 :: proc "c" (x: double3) -> double3 {…}

    sinh_double4 ¶
    Source

    sinh_double4 :: proc "c" (x: double4) -> double4 {…}

    sinh_float ¶
    Source

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

    sinh_float2 ¶
    Source

    sinh_float2 :: proc "c" (x: float2) -> float2 {…}

    sinh_float3 ¶
    Source

    sinh_float3 :: proc "c" (x: float3) -> float3 {…}

    sinh_float4 ¶
    Source

    sinh_float4 :: proc "c" (x: float4) -> float4 {…}

    smoothstep_double ¶
    Source

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

    smoothstep_double2 ¶
    Source

    smoothstep_double2 :: proc "c" (edge0, edge1, x: double2) -> double2 {…}

    smoothstep_double3 ¶
    Source

    smoothstep_double3 :: proc "c" (edge0, edge1, x: double3) -> double3 {…}

    smoothstep_double4 ¶
    Source

    smoothstep_double4 :: proc "c" (edge0, edge1, x: double4) -> double4 {…}

    smoothstep_float ¶
    Source

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

    smoothstep_float2 ¶
    Source

    smoothstep_float2 :: proc "c" (edge0, edge1, x: float2) -> float2 {…}

    smoothstep_float3 ¶
    Source

    smoothstep_float3 :: proc "c" (edge0, edge1, x: float3) -> float3 {…}

    smoothstep_float4 ¶
    Source

    smoothstep_float4 :: proc "c" (edge0, edge1, x: float4) -> float4 {…}

    sqrt_double ¶
    Source

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

    sqrt_double2 ¶
    Source

    sqrt_double2 :: proc "c" (x: double2) -> double2 {…}

    sqrt_double3 ¶
    Source

    sqrt_double3 :: proc "c" (x: double3) -> double3 {…}

    sqrt_double4 ¶
    Source

    sqrt_double4 :: proc "c" (x: double4) -> double4 {…}

    sqrt_float ¶
    Source

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

    sqrt_float2 ¶
    Source

    sqrt_float2 :: proc "c" (x: float2) -> float2 {…}

    sqrt_float3 ¶
    Source

    sqrt_float3 :: proc "c" (x: float3) -> float3 {…}

    sqrt_float4 ¶
    Source

    sqrt_float4 :: proc "c" (x: float4) -> float4 {…}

    step_double ¶
    Source

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

    step_double2 ¶
    Source

    step_double2 :: proc "c" (edge, x: double2) -> double2 {…}

    step_double3 ¶
    Source

    step_double3 :: proc "c" (edge, x: double3) -> double3 {…}

    step_double4 ¶
    Source

    step_double4 :: proc "c" (edge, x: double4) -> double4 {…}

    step_float ¶
    Source

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

    step_float2 ¶
    Source

    step_float2 :: proc "c" (edge, x: float2) -> float2 {…}

    step_float3 ¶
    Source

    step_float3 :: proc "c" (edge, x: float3) -> float3 {…}

    step_float4 ¶
    Source

    step_float4 :: proc "c" (edge, x: float4) -> float4 {…}

    tan_double ¶
    Source

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

    tan_double2 ¶
    Source

    tan_double2 :: proc "c" (x: double2) -> double2 {…}

    tan_double3 ¶
    Source

    tan_double3 :: proc "c" (x: double3) -> double3 {…}

    tan_double4 ¶
    Source

    tan_double4 :: proc "c" (x: double4) -> double4 {…}

    tan_float ¶
    Source

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

    tan_float2 ¶
    Source

    tan_float2 :: proc "c" (x: float2) -> float2 {…}

    tan_float3 ¶
    Source

    tan_float3 :: proc "c" (x: float3) -> float3 {…}

    tan_float4 ¶
    Source

    tan_float4 :: proc "c" (x: float4) -> float4 {…}

    tanh_double ¶
    Source

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

    tanh_double2 ¶
    Source

    tanh_double2 :: proc "c" (x: double2) -> double2 {…}

    tanh_double3 ¶
    Source

    tanh_double3 :: proc "c" (x: double3) -> double3 {…}

    tanh_double4 ¶
    Source

    tanh_double4 :: proc "c" (x: double4) -> double4 {…}

    tanh_float ¶
    Source

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

    tanh_float2 ¶
    Source

    tanh_float2 :: proc "c" (x: float2) -> float2 {…}

    tanh_float3 ¶
    Source

    tanh_float3 :: proc "c" (x: float3) -> float3 {…}

    tanh_float4 ¶
    Source

    tanh_float4 :: proc "c" (x: float4) -> float4 {…}

    trace ¶
    Source

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

    transpose ¶

    transpose :: intrinsics.transpose

    vectorTripleProduct_double3 ¶
    Source

    vectorTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double3 {…}

    vectorTripleProduct_float3 ¶
    Source

    vectorTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float3 {…}

    vectorTripleProduct_int3 ¶
    Source

    vectorTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int3 {…}

    Procedure Groups

    abs ¶
    Source

    acos ¶
    Source

    acosh ¶
    Source

    adjugate ¶
    Source

    all ¶
    Source

    all :: proc{
	all_bool,
	all_bool2,
	all_bool3,
	all_bool4,
}

    any ¶
    Source

    any :: proc{
	any_bool,
	any_bool2,
	any_bool3,
	any_bool4,
}

    asdouble ¶
    Source

    asdouble :: proc{
	asdouble_float,
	asdouble_double,
	asdouble_int,
	asdouble_uint,
	asdouble_float1x1,
	asdouble_float2x2,
	asdouble_float3x3,
	asdouble_float4x4,
	asdouble_float1x2,
	asdouble_float1x3,
	asdouble_float1x4,
	asdouble_float2x1,
	asdouble_float2x3,
	asdouble_float2x4,
	asdouble_float3x1,
	asdouble_float3x2,
	asdouble_float3x4,
	asdouble_float4x1,
	asdouble_float4x2,
	asdouble_float4x3,
	asdouble_float2,
	asdouble_float3,
	asdouble_float4,
	asdouble_int2,
	asdouble_int3,
	asdouble_int4,
	asdouble_uint2,
	asdouble_uint3,
	asdouble_uint4,
	asdouble_bool2,
	asdouble_bool3,
	asdouble_bool4,
	asdouble_double1x1,
	asdouble_double2x2,
	asdouble_double3x3,
	asdouble_double4x4,
	asdouble_double1x2,
	asdouble_double1x3,
	asdouble_double1x4,
	asdouble_double2x1,
	asdouble_double2x3,
	asdouble_double2x4,
	asdouble_double3x1,
	asdouble_double3x2,
	asdouble_double3x4,
	asdouble_double4x1,
	asdouble_double4x2,
	asdouble_double4x3,
	asdouble_double2,
	asdouble_double3,
	asdouble_double4,
}

    asfloat ¶
    Source

    asfloat :: proc{
	asfloat_float,
	asfloat_double,
	asfloat_int,
	asfloat_uint,
	asfloat_float1x1,
	asfloat_float2x2,
	asfloat_float3x3,
	asfloat_float4x4,
	asfloat_float1x2,
	asfloat_float1x3,
	asfloat_float1x4,
	asfloat_float2x1,
	asfloat_float2x3,
	asfloat_float2x4,
	asfloat_float3x1,
	asfloat_float3x2,
	asfloat_float3x4,
	asfloat_float4x1,
	asfloat_float4x2,
	asfloat_float4x3,
	asfloat_float2,
	asfloat_float3,
	asfloat_float4,
	asfloat_int2,
	asfloat_int3,
	asfloat_int4,
	asfloat_uint2,
	asfloat_uint3,
	asfloat_uint4,
	asfloat_bool2,
	asfloat_bool3,
	asfloat_bool4,
	asfloat_double1x1,
	asfloat_double2x2,
	asfloat_double3x3,
	asfloat_double4x4,
	asfloat_double1x2,
	asfloat_double1x3,
	asfloat_double1x4,
	asfloat_double2x1,
	asfloat_double2x3,
	asfloat_double2x4,
	asfloat_double3x1,
	asfloat_double3x2,
	asfloat_double3x4,
	asfloat_double4x1,
	asfloat_double4x2,
	asfloat_double4x3,
	asfloat_double2,
	asfloat_double3,
	asfloat_double4,
}

    asin ¶
    Source

    asinh ¶
    Source

    asint ¶
    Source

    asuint ¶
    Source

    atan ¶
    Source

    atan2 ¶
    Source

    atanh ¶
    Source

    ceil ¶
    Source

    clamp ¶
    Source

    cos ¶
    Source

    cosh ¶
    Source

    cross ¶
    Source

    cross :: proc{
	cross_float3,
	cross_double3,
	cross_int3,
}

    degrees ¶
    Source

    determinant ¶
    Source

    distance ¶
    Source

    dot ¶
    Source

    equal ¶
    Source

    exp ¶
    Source

    exp2 ¶
    Source

    faceforward ¶
    Source

    floor ¶
    Source

    fmod ¶
    Source

    frac ¶
    Source

    greaterThan ¶
    Source

    greaterThanEqual ¶
    Source

    inverse ¶
    Source

    inverse_transpose ¶
    Source

    isfinite ¶
    Source

     

    isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite

    isinf ¶
    Source

     

    isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite

    isnan ¶
    Source

     

    isnan returns true if the input value is the special case of Not-A-Number

    length ¶
    Source

    lerp ¶
    Source

    lessThan ¶
    Source

    lessThanEqual ¶
    Source

    log ¶
    Source

    log10 ¶
    Source

    log2 ¶
    Source

    max ¶
    Source

    min ¶
    Source

    normalize ¶
    Source

    not ¶
    Source

    not :: proc{
	not_bool,
	not_bool2,
	not_bool3,
	not_bool4,
}

    notEqual ¶
    Source

    pow ¶
    Source

    radians ¶
    Source

    rcp ¶
    Source

    reflect ¶
    Source

    refract ¶
    Source

    round ¶
    Source

    rsqrt ¶
    Source

    saturate ¶
    Source

    scalarTripleProduct ¶
    Source

    sign ¶
    Source

    sin ¶
    Source

    sinh ¶
    Source

    smoothstep ¶
    Source

    sqrt ¶
    Source

    step ¶
    Source

    tan ¶
    Source

    tanh ¶
    Source

    vectorTripleProduct ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2024-04 (vendor "odin") Windows_amd64 @ 2024-04-25 21:10:21.909784100 +0000 UTC