package core:math/linalg/hlsl

⌘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 (738)

    Types

    bool2 ¶

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

    bool3 ¶

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

    bool4 ¶

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

    double ¶

    double :: f64

    double1x1 ¶

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

    double1x2 ¶

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

    double1x3 ¶

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

    double1x4 ¶

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

    double2 ¶

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

    double2x1 ¶

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

    double2x2 ¶

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

    double2x3 ¶

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

    double2x4 ¶

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

    double3 ¶

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

    double3x1 ¶

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

    double3x2 ¶

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

    double3x3 ¶

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

    double3x4 ¶

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

    double4 ¶

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

    double4x1 ¶

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

    double4x2 ¶

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

    double4x3 ¶

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

    double4x4 ¶

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

    float ¶

    float :: f32
     

    Aliases (not distinct) of types

    float1x1 ¶

    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 ¶

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

    float1x3 ¶

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

    float1x4 ¶

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

    float2 ¶

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

    float2x1 ¶

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

    float2x2 ¶

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

    float2x3 ¶

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

    float2x4 ¶

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

    float3 ¶

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

    float3x1 ¶

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

    float3x2 ¶

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

    float3x3 ¶

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

    float3x4 ¶

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

    float4 ¶

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

    float4x1 ¶

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

    float4x2 ¶

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

    float4x3 ¶

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

    float4x4 ¶

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

    int1x1 ¶

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

    int1x2 ¶

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

    int1x3 ¶

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

    int1x4 ¶

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

    int2 ¶

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

    int2x1 ¶

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

    int2x2 ¶

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

    int2x3 ¶

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

    int2x4 ¶

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

    int3 ¶

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

    int3x1 ¶

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

    int3x2 ¶

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

    int3x3 ¶

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

    int3x4 ¶

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

    int4 ¶

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

    int4x1 ¶

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

    int4x2 ¶

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

    int4x3 ¶

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

    int4x4 ¶

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

    uint2 ¶

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

    uint3 ¶

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

    uint4 ¶

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

    Constants

    DOUBLE_EPSILON ¶

    DOUBLE_EPSILON :: 1e-15

    E ¶

    E :: 2.71828182845904523536

    FLOAT_EPSILON ¶

    FLOAT_EPSILON :: 1e-7

    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_double ¶

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

    abs_double2 ¶

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

    abs_double3 ¶

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

    abs_double4 ¶

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

    abs_float ¶

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

    abs_float2 ¶

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

    abs_float3 ¶

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

    abs_float4 ¶

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

    abs_int ¶

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

    abs_int2 ¶

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

    abs_int3 ¶

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

    abs_int4 ¶

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

    abs_uint ¶

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

    abs_uint2 ¶

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

    abs_uint3 ¶

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

    abs_uint4 ¶

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

    acos_double ¶

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

    acos_double2 ¶

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

    acos_double3 ¶

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

    acos_double4 ¶

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

    acos_float ¶

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

    acos_float2 ¶

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

    acos_float3 ¶

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

    acos_float4 ¶

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

    acosh_double ¶

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

    acosh_double2 ¶

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

    acosh_double3 ¶

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

    acosh_double4 ¶

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

    acosh_float ¶

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

    acosh_float2 ¶

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

    acosh_float3 ¶

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

    acosh_float4 ¶

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

    all_bool ¶

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

    all_bool2 ¶

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

    all_bool3 ¶

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

    all_bool4 ¶

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

    any_bool ¶

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

    any_bool2 ¶

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

    any_bool3 ¶

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

    any_bool4 ¶

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

    asdouble_bool2 ¶

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

    asdouble_bool3 ¶

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

    asdouble_bool4 ¶

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

    asdouble_double ¶

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

    asdouble_double1x1 ¶

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

    asdouble_double1x2 ¶

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

    asdouble_double1x3 ¶

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

    asdouble_double1x4 ¶

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

    asdouble_double2 ¶

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

    asdouble_double2x1 ¶

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

    asdouble_double2x2 ¶

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

    asdouble_double2x3 ¶

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

    asdouble_double2x4 ¶

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

    asdouble_double3 ¶

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

    asdouble_double3x1 ¶

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

    asdouble_double3x2 ¶

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

    asdouble_double3x3 ¶

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

    asdouble_double3x4 ¶

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

    asdouble_double4 ¶

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

    asdouble_double4x1 ¶

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

    asdouble_double4x2 ¶

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

    asdouble_double4x3 ¶

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

    asdouble_double4x4 ¶

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

    asdouble_float ¶

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

    asdouble_float1x1 ¶

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

    asdouble_float1x2 ¶

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

    asdouble_float1x3 ¶

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

    asdouble_float1x4 ¶

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

    asdouble_float2 ¶

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

    asdouble_float2x1 ¶

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

    asdouble_float2x2 ¶

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

    asdouble_float2x3 ¶

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

    asdouble_float2x4 ¶

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

    asdouble_float3 ¶

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

    asdouble_float3x1 ¶

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

    asdouble_float3x2 ¶

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

    asdouble_float3x3 ¶

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

    asdouble_float3x4 ¶

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

    asdouble_float4 ¶

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

    asdouble_float4x1 ¶

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

    asdouble_float4x2 ¶

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

    asdouble_float4x3 ¶

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

    asdouble_float4x4 ¶

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

    asdouble_int ¶

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

    asdouble_int2 ¶

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

    asdouble_int3 ¶

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

    asdouble_int4 ¶

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

    asdouble_uint ¶

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

    asdouble_uint2 ¶

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

    asdouble_uint3 ¶

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

    asdouble_uint4 ¶

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

    asfloat_bool2 ¶

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

    asfloat_bool3 ¶

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

    asfloat_bool4 ¶

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

    asfloat_double ¶

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

    asfloat_double1x1 ¶

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

    asfloat_double1x2 ¶

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

    asfloat_double1x3 ¶

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

    asfloat_double1x4 ¶

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

    asfloat_double2 ¶

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

    asfloat_double2x1 ¶

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

    asfloat_double2x2 ¶

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

    asfloat_double2x3 ¶

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

    asfloat_double2x4 ¶

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

    asfloat_double3 ¶

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

    asfloat_double3x1 ¶

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

    asfloat_double3x2 ¶

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

    asfloat_double3x3 ¶

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

    asfloat_double3x4 ¶

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

    asfloat_double4 ¶

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

    asfloat_double4x1 ¶

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

    asfloat_double4x2 ¶

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

    asfloat_double4x3 ¶

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

    asfloat_double4x4 ¶

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

    asfloat_float ¶

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

    asfloat_float1x1 ¶

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

    asfloat_float1x2 ¶

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

    asfloat_float1x3 ¶

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

    asfloat_float1x4 ¶

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

    asfloat_float2 ¶

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

    asfloat_float2x1 ¶

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

    asfloat_float2x2 ¶

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

    asfloat_float2x3 ¶

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

    asfloat_float2x4 ¶

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

    asfloat_float3 ¶

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

    asfloat_float3x1 ¶

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

    asfloat_float3x2 ¶

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

    asfloat_float3x3 ¶

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

    asfloat_float3x4 ¶

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

    asfloat_float4 ¶

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

    asfloat_float4x1 ¶

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

    asfloat_float4x2 ¶

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

    asfloat_float4x3 ¶

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

    asfloat_float4x4 ¶

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

    asfloat_int ¶

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

    asfloat_int2 ¶

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

    asfloat_int3 ¶

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

    asfloat_int4 ¶

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

    asfloat_uint ¶

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

    asfloat_uint2 ¶

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

    asfloat_uint3 ¶

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

    asfloat_uint4 ¶

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

    asin_double ¶

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

    asin_double2 ¶

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

    asin_double3 ¶

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

    asin_double4 ¶

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

    asin_float ¶

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

    asin_float2 ¶

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

    asin_float3 ¶

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

    asin_float4 ¶

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

    asinh_double ¶

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

    asinh_double2 ¶

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

    asinh_double3 ¶

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

    asinh_double4 ¶

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

    asinh_float ¶

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

    asinh_float2 ¶

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

    asinh_float3 ¶

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

    asinh_float4 ¶

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

    asint_bool2 ¶

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

    asint_bool3 ¶

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

    asint_bool4 ¶

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

    asint_double ¶

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

    asint_double1x1 ¶

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

    asint_double1x2 ¶

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

    asint_double1x3 ¶

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

    asint_double1x4 ¶

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

    asint_double2 ¶

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

    asint_double2x1 ¶

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

    asint_double2x2 ¶

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

    asint_double2x3 ¶

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

    asint_double2x4 ¶

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

    asint_double3 ¶

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

    asint_double3x1 ¶

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

    asint_double3x2 ¶

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

    asint_double3x3 ¶

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

    asint_double3x4 ¶

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

    asint_double4 ¶

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

    asint_double4x1 ¶

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

    asint_double4x2 ¶

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

    asint_double4x3 ¶

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

    asint_double4x4 ¶

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

    asint_float ¶

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

    asint_float1x1 ¶

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

    asint_float1x2 ¶

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

    asint_float1x3 ¶

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

    asint_float1x4 ¶

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

    asint_float2 ¶

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

    asint_float2x1 ¶

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

    asint_float2x2 ¶

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

    asint_float2x3 ¶

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

    asint_float2x4 ¶

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

    asint_float3 ¶

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

    asint_float3x1 ¶

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

    asint_float3x2 ¶

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

    asint_float3x3 ¶

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

    asint_float3x4 ¶

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

    asint_float4 ¶

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

    asint_float4x1 ¶

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

    asint_float4x2 ¶

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

    asint_float4x3 ¶

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

    asint_float4x4 ¶

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

    asint_int ¶

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

    asint_int2 ¶

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

    asint_int3 ¶

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

    asint_int4 ¶

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

    asint_uint ¶

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

    asint_uint2 ¶

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

    asint_uint3 ¶

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

    asint_uint4 ¶

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

    asuint_bool2 ¶

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

    asuint_bool3 ¶

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

    asuint_bool4 ¶

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

    asuint_double ¶

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

    asuint_double2 ¶

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

    asuint_double3 ¶

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

    asuint_double4 ¶

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

    asuint_float ¶

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

    asuint_float2 ¶

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

    asuint_float3 ¶

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

    asuint_float4 ¶

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

    asuint_int ¶

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

    asuint_int2 ¶

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

    asuint_int3 ¶

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

    asuint_int4 ¶

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

    asuint_uint ¶

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

    asuint_uint2 ¶

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

    asuint_uint3 ¶

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

    asuint_uint4 ¶

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

    atan2_double ¶

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

    atan2_double2 ¶

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

    atan2_double3 ¶

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

    atan2_double4 ¶

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

    atan2_float ¶

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

    atan2_float2 ¶

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

    atan2_float3 ¶

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

    atan2_float4 ¶

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

    atan_double ¶

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

    atan_double2 ¶

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

    atan_double3 ¶

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

    atan_double4 ¶

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

    atan_float ¶

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

    atan_float2 ¶

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

    atan_float3 ¶

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

    atan_float4 ¶

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

    atanh_double ¶

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

    atanh_double2 ¶

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

    atanh_double3 ¶

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

    atanh_double4 ¶

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

    atanh_float ¶

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

    atanh_float2 ¶

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

    atanh_float3 ¶

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

    atanh_float4 ¶

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

    ceil_double ¶

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

    ceil_double2 ¶

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

    ceil_double3 ¶

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

    ceil_double4 ¶

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

    ceil_float ¶

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

    ceil_float2 ¶

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

    ceil_float3 ¶

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

    ceil_float4 ¶

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

    clamp_double ¶

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

    clamp_double2 ¶

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

    clamp_double3 ¶

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

    clamp_double4 ¶

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

    clamp_float ¶

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

    clamp_float2 ¶

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

    clamp_float3 ¶

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

    clamp_float4 ¶

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

    clamp_int ¶

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

    clamp_int2 ¶

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

    clamp_int3 ¶

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

    clamp_int4 ¶

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

    clamp_uint ¶

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

    clamp_uint2 ¶

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

    clamp_uint3 ¶

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

    clamp_uint4 ¶

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

    cos_double ¶

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

    cos_double2 ¶

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

    cos_double3 ¶

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

    cos_double4 ¶

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

    cos_float ¶

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

    cos_float2 ¶

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

    cos_float3 ¶

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

    cos_float4 ¶

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

    cosh_double ¶

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

    cosh_double2 ¶

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

    cosh_double3 ¶

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

    cosh_double4 ¶

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

    cosh_float ¶

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

    cosh_float2 ¶

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

    cosh_float3 ¶

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

    cosh_float4 ¶

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

    cross_double3 ¶

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

    cross_float3 ¶

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

    cross_int3 ¶

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

    degrees_double ¶

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

    degrees_double2 ¶

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

    degrees_double3 ¶

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

    degrees_double4 ¶

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

    degrees_float ¶

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

    degrees_float2 ¶

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

    degrees_float3 ¶

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

    degrees_float4 ¶

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

    distance_double ¶

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

    distance_double2 ¶

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

    distance_double3 ¶

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

    distance_double4 ¶

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

    distance_float ¶

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

    distance_float2 ¶

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

    distance_float3 ¶

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

    distance_float4 ¶

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

    dot_double ¶

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

    dot_double2 ¶

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

    dot_double3 ¶

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

    dot_double4 ¶

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

    dot_float ¶

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

    dot_float2 ¶

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

    dot_float3 ¶

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

    dot_float4 ¶

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

    dot_int ¶

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

    dot_int2 ¶

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

    dot_int3 ¶

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

    dot_int4 ¶

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

    dot_uint ¶

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

    dot_uint2 ¶

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

    dot_uint3 ¶

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

    dot_uint4 ¶

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

    equal_double ¶

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

    equal_double2 ¶

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

    equal_double3 ¶

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

    equal_double4 ¶

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

    equal_float ¶

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

    equal_float2 ¶

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

    equal_float3 ¶

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

    equal_float4 ¶

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

    equal_int ¶

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

    equal_int2 ¶

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

    equal_int3 ¶

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

    equal_int4 ¶

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

    equal_uint ¶

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

    equal_uint2 ¶

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

    equal_uint3 ¶

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

    equal_uint4 ¶

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

    exp2_double ¶

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

    exp2_double2 ¶

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

    exp2_double3 ¶

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

    exp2_double4 ¶

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

    exp2_float ¶

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

    exp2_float2 ¶

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

    exp2_float3 ¶

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

    exp2_float4 ¶

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

    exp_double ¶

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

    exp_double2 ¶

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

    exp_double3 ¶

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

    exp_double4 ¶

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

    exp_float ¶

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

    exp_float2 ¶

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

    exp_float3 ¶

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

    exp_float4 ¶

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

    faceforward_double ¶

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

    faceforward_double2 ¶

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

    faceforward_double3 ¶

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

    faceforward_double4 ¶

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

    faceforward_float ¶

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

    faceforward_float2 ¶

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

    faceforward_float3 ¶

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

    faceforward_float4 ¶

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

    floor_double ¶

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

    floor_double2 ¶

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

    floor_double3 ¶

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

    floor_double4 ¶

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

    floor_float ¶

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

    floor_float2 ¶

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

    floor_float3 ¶

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

    floor_float4 ¶

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

    fmod_double ¶

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

    fmod_double2 ¶

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

    fmod_double3 ¶

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

    fmod_double4 ¶

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

    fmod_float ¶

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

    fmod_float2 ¶

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

    fmod_float3 ¶

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

    fmod_float4 ¶

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

    frac_double ¶

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

    frac_double2 ¶

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

    frac_double3 ¶

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

    frac_double4 ¶

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

    frac_float ¶

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

    frac_float2 ¶

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

    frac_float3 ¶

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

    frac_float4 ¶

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

    greaterThanEqual_double ¶

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

    greaterThanEqual_double2 ¶

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

    greaterThanEqual_double3 ¶

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

    greaterThanEqual_double4 ¶

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

    greaterThanEqual_float ¶

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

    greaterThanEqual_float2 ¶

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

    greaterThanEqual_float3 ¶

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

    greaterThanEqual_float4 ¶

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

    greaterThanEqual_int ¶

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

    greaterThanEqual_int2 ¶

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

    greaterThanEqual_int3 ¶

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

    greaterThanEqual_int4 ¶

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

    greaterThanEqual_uint ¶

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

    greaterThanEqual_uint2 ¶

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

    greaterThanEqual_uint3 ¶

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

    greaterThanEqual_uint4 ¶

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

    greaterThan_double ¶

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

    greaterThan_double2 ¶

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

    greaterThan_double3 ¶

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

    greaterThan_double4 ¶

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

    greaterThan_float ¶

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

    greaterThan_float2 ¶

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

    greaterThan_float3 ¶

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

    greaterThan_float4 ¶

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

    greaterThan_int ¶

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

    greaterThan_int2 ¶

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

    greaterThan_int3 ¶

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

    greaterThan_int4 ¶

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

    greaterThan_uint ¶

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

    greaterThan_uint2 ¶

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

    greaterThan_uint3 ¶

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

    greaterThan_uint4 ¶

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

    inverse_double1x1 ¶

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

    inverse_double2x2 ¶

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

    inverse_double3x3 ¶

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

    inverse_double4x4 ¶

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

    inverse_float1x1 ¶

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

    inverse_float2x2 ¶

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

    inverse_float3x3 ¶

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

    inverse_float4x4 ¶

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

    isfinite_double ¶

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

    isfinite_double2 ¶

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

    isfinite_double3 ¶

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

    isfinite_double4 ¶

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

    isfinite_float ¶

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

    isfinite_float2 ¶

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

    isfinite_float3 ¶

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

    isfinite_float4 ¶

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

    isinf_double ¶

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

    isinf_double2 ¶

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

    isinf_double3 ¶

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

    isinf_double4 ¶

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

    isinf_float ¶

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

    isinf_float2 ¶

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

    isinf_float3 ¶

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

    isinf_float4 ¶

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

    isnan_double ¶

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

    isnan_double2 ¶

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

    isnan_double3 ¶

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

    isnan_double4 ¶

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

    isnan_float ¶

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

    isnan_float2 ¶

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

    isnan_float3 ¶

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

    isnan_float4 ¶

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

    length_double ¶

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

    length_double2 ¶

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

    length_double3 ¶

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

    length_double4 ¶

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

    length_float ¶

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

    length_float2 ¶

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

    length_float3 ¶

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

    length_float4 ¶

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

    lerp_double ¶

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

    lerp_double2 ¶

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

    lerp_double3 ¶

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

    lerp_double4 ¶

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

    lerp_float ¶

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

    lerp_float2 ¶

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

    lerp_float3 ¶

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

    lerp_float4 ¶

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

    lessThanEqual_double ¶

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

    lessThanEqual_double2 ¶

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

    lessThanEqual_double3 ¶

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

    lessThanEqual_double4 ¶

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

    lessThanEqual_float ¶

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

    lessThanEqual_float2 ¶

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

    lessThanEqual_float3 ¶

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

    lessThanEqual_float4 ¶

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

    lessThanEqual_int ¶

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

    lessThanEqual_int2 ¶

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

    lessThanEqual_int3 ¶

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

    lessThanEqual_int4 ¶

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

    lessThanEqual_uint ¶

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

    lessThanEqual_uint2 ¶

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

    lessThanEqual_uint3 ¶

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

    lessThanEqual_uint4 ¶

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

    lessThan_double ¶

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

    lessThan_double2 ¶

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

    lessThan_double3 ¶

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

    lessThan_double4 ¶

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

    lessThan_float ¶

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

    lessThan_float2 ¶

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

    lessThan_float3 ¶

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

    lessThan_float4 ¶

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

    lessThan_int ¶

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

    lessThan_int2 ¶

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

    lessThan_int3 ¶

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

    lessThan_int4 ¶

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

    lessThan_uint ¶

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

    lessThan_uint2 ¶

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

    lessThan_uint3 ¶

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

    lessThan_uint4 ¶

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

    log10_double ¶

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

    log10_double2 ¶

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

    log10_double3 ¶

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

    log10_double4 ¶

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

    log10_float ¶

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

    log10_float2 ¶

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

    log10_float3 ¶

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

    log10_float4 ¶

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

    log2_double ¶

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

    log2_double2 ¶

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

    log2_double3 ¶

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

    log2_double4 ¶

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

    log2_float ¶

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

    log2_float2 ¶

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

    log2_float3 ¶

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

    log2_float4 ¶

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

    log_double ¶

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

    log_double2 ¶

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

    log_double3 ¶

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

    log_double4 ¶

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

    log_float ¶

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

    log_float2 ¶

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

    log_float3 ¶

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

    log_float4 ¶

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

    max_double ¶

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

    max_double2 ¶

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

    max_double3 ¶

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

    max_double4 ¶

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

    max_float ¶

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

    max_float2 ¶

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

    max_float3 ¶

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

    max_float4 ¶

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

    max_int ¶

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

    max_int2 ¶

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

    max_int3 ¶

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

    max_int4 ¶

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

    max_uint ¶

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

    max_uint2 ¶

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

    max_uint3 ¶

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

    max_uint4 ¶

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

    min_double ¶

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

    min_double2 ¶

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

    min_double3 ¶

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

    min_double4 ¶

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

    min_float ¶

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

    min_float2 ¶

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

    min_float3 ¶

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

    min_float4 ¶

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

    min_int ¶

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

    min_int2 ¶

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

    min_int3 ¶

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

    min_int4 ¶

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

    min_uint ¶

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

    min_uint2 ¶

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

    min_uint3 ¶

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

    min_uint4 ¶

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

    normalize_double ¶

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

    normalize_double2 ¶

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

    normalize_double3 ¶

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

    normalize_double4 ¶

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

    normalize_float ¶

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

    normalize_float2 ¶

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

    normalize_float3 ¶

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

    normalize_float4 ¶

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

    notEqual_double ¶

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

    notEqual_double2 ¶

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

    notEqual_double3 ¶

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

    notEqual_double4 ¶

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

    notEqual_float ¶

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

    notEqual_float2 ¶

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

    notEqual_float3 ¶

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

    notEqual_float4 ¶

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

    notEqual_int ¶

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

    notEqual_int2 ¶

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

    notEqual_int3 ¶

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

    notEqual_int4 ¶

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

    notEqual_uint ¶

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

    notEqual_uint2 ¶

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

    notEqual_uint3 ¶

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

    notEqual_uint4 ¶

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

    not_bool ¶

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

    not_bool2 ¶

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

    not_bool3 ¶

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

    not_bool4 ¶

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

    pow_double ¶

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

    pow_double2 ¶

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

    pow_double3 ¶

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

    pow_double4 ¶

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

    pow_float ¶

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

    pow_float2 ¶

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

    pow_float3 ¶

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

    pow_float4 ¶

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

    radians_double ¶

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

    radians_double2 ¶

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

    radians_double3 ¶

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

    radians_double4 ¶

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

    radians_float ¶

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

    radians_float2 ¶

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

    radians_float3 ¶

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

    radians_float4 ¶

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

    rcp_double ¶

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

    rcp_double2 ¶

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

    rcp_double3 ¶

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

    rcp_double4 ¶

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

    rcp_float ¶

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

    rcp_float2 ¶

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

    rcp_float3 ¶

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

    rcp_float4 ¶

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

    reflect_double ¶

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

    reflect_double2 ¶

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

    reflect_double3 ¶

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

    reflect_double4 ¶

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

    reflect_float ¶

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

    reflect_float2 ¶

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

    reflect_float3 ¶

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

    reflect_float4 ¶

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

    refract_double ¶

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

    refract_double2 ¶

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

    refract_double3 ¶

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

    refract_double4 ¶

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

    refract_float ¶

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

    refract_float2 ¶

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

    refract_float3 ¶

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

    refract_float4 ¶

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

    round_double ¶

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

    round_double2 ¶

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

    round_double3 ¶

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

    round_double4 ¶

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

    round_float ¶

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

    round_float2 ¶

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

    round_float3 ¶

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

    round_float4 ¶

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

    rsqrt_double ¶

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

    rsqrt_double2 ¶

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

    rsqrt_double3 ¶

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

    rsqrt_double4 ¶

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

    rsqrt_float ¶

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

    rsqrt_float2 ¶

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

    rsqrt_float3 ¶

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

    rsqrt_float4 ¶

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

    saturate_double ¶

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

    saturate_double2 ¶

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

    saturate_double3 ¶

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

    saturate_double4 ¶

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

    saturate_float ¶

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

    saturate_float2 ¶

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

    saturate_float3 ¶

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

    saturate_float4 ¶

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

    saturate_int ¶

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

    saturate_int2 ¶

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

    saturate_int3 ¶

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

    saturate_int4 ¶

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

    saturate_uint ¶

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

    saturate_uint2 ¶

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

    saturate_uint3 ¶

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

    saturate_uint4 ¶

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

    scalarTripleProduct_double3 ¶

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

    scalarTripleProduct_float3 ¶

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

    scalarTripleProduct_int3 ¶

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

    sign_double ¶

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

    sign_double2 ¶

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

    sign_double3 ¶

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

    sign_double4 ¶

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

    sign_float ¶

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

    sign_float2 ¶

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

    sign_float3 ¶

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

    sign_float4 ¶

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

    sign_int ¶

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

    sign_int2 ¶

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

    sign_int3 ¶

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

    sign_int4 ¶

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

    sign_uint ¶

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

    sign_uint2 ¶

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

    sign_uint3 ¶

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

    sign_uint4 ¶

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

    sin_double ¶

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

    sin_double2 ¶

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

    sin_double3 ¶

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

    sin_double4 ¶

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

    sin_float ¶

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

    sin_float2 ¶

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

    sin_float3 ¶

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

    sin_float4 ¶

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

    sinh_double ¶

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

    sinh_double2 ¶

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

    sinh_double3 ¶

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

    sinh_double4 ¶

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

    sinh_float ¶

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

    sinh_float2 ¶

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

    sinh_float3 ¶

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

    sinh_float4 ¶

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

    smoothstep_double ¶

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

    smoothstep_double2 ¶

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

    smoothstep_double3 ¶

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

    smoothstep_double4 ¶

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

    smoothstep_float ¶

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

    smoothstep_float2 ¶

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

    smoothstep_float3 ¶

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

    smoothstep_float4 ¶

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

    sqrt_double ¶

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

    sqrt_double2 ¶

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

    sqrt_double3 ¶

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

    sqrt_double4 ¶

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

    sqrt_float ¶

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

    sqrt_float2 ¶

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

    sqrt_float3 ¶

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

    sqrt_float4 ¶

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

    step_double ¶

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

    step_double2 ¶

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

    step_double3 ¶

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

    step_double4 ¶

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

    step_float ¶

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

    step_float2 ¶

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

    step_float3 ¶

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

    step_float4 ¶

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

    tan_double ¶

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

    tan_double2 ¶

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

    tan_double3 ¶

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

    tan_double4 ¶

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

    tan_float ¶

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

    tan_float2 ¶

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

    tan_float3 ¶

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

    tan_float4 ¶

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

    tanh_double ¶

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

    tanh_double2 ¶

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

    tanh_double3 ¶

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

    tanh_double4 ¶

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

    tanh_float ¶

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

    tanh_float2 ¶

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

    tanh_float3 ¶

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

    tanh_float4 ¶

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

    transpose ¶

    transpose :: builtin.transpose

    vectorTripleProduct_double3 ¶

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

    vectorTripleProduct_float3 ¶

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

    vectorTripleProduct_int3 ¶

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

    Procedure Groups

    adjugate ¶

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

    isfinite ¶

     

    isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite

    isinf ¶

     

    isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite

    isnan ¶

     

    isnan returns true if the input value is the special case of Not-A-Number

    Source Files

    Generation Information

    Generated with odin version dev-2023-10 (vendor "odin") Windows_amd64 @ 2023-10-03 21:09:46.580860200 +0000 UTC