package core:math/linalg

⌘K
Ctrl+K
or
/

    Overview

    core:math/linalg implements linear algebra procedures useful for 3D spatial transformations

    Index

    Types (77)
    Variables (0)

    This section is empty.

    Procedures (637)
    Procedure Groups (205)

    Types

    Matrix1x1f16 ¶

    Matrix1x1f16 :: distinct matrix[1, 1]f16

    Matrix1x1f32 ¶

    Matrix1x1f32 :: distinct matrix[1, 1]f32

    Matrix1x1f64 ¶

    Matrix1x1f64 :: distinct matrix[1, 1]f64

    Matrix1x2f16 ¶

    Matrix1x2f16 :: distinct matrix[1, 2]f16

    Matrix1x2f32 ¶

    Matrix1x2f32 :: distinct matrix[1, 2]f32

    Matrix1x2f64 ¶

    Matrix1x2f64 :: distinct matrix[1, 2]f64

    Matrix1x3f16 ¶

    Matrix1x3f16 :: distinct matrix[1, 3]f16

    Matrix1x3f32 ¶

    Matrix1x3f32 :: distinct matrix[1, 3]f32

    Matrix1x3f64 ¶

    Matrix1x3f64 :: distinct matrix[1, 3]f64

    Matrix1x4f16 ¶

    Matrix1x4f16 :: distinct matrix[1, 4]f16

    Matrix1x4f32 ¶

    Matrix1x4f32 :: distinct matrix[1, 4]f32

    Matrix1x4f64 ¶

    Matrix1x4f64 :: distinct matrix[1, 4]f64

    Matrix2x1f16 ¶

    Matrix2x1f16 :: distinct matrix[2, 1]f16

    Matrix2x1f32 ¶

    Matrix2x1f32 :: distinct matrix[2, 1]f32

    Matrix2x1f64 ¶

    Matrix2x1f64 :: distinct matrix[2, 1]f64

    Matrix2x2f16 ¶

    Matrix2x2f16 :: distinct matrix[2, 2]f16
    Related Procedures With Parameters
    Related Procedures With Returns

    Matrix2x2f32 ¶

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

    Matrix2x2f64 ¶

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

    Matrix2x3f16 ¶

    Matrix2x3f16 :: distinct matrix[2, 3]f16

    Matrix2x3f32 ¶

    Matrix2x3f32 :: distinct matrix[2, 3]f32

    Matrix2x3f64 ¶

    Matrix2x3f64 :: distinct matrix[2, 3]f64

    Matrix2x4f16 ¶

    Matrix2x4f16 :: distinct matrix[2, 4]f16

    Matrix2x4f32 ¶

    Matrix2x4f32 :: distinct matrix[2, 4]f32

    Matrix2x4f64 ¶

    Matrix2x4f64 :: distinct matrix[2, 4]f64

    Matrix3x1f16 ¶

    Matrix3x1f16 :: distinct matrix[3, 1]f16

    Matrix3x1f32 ¶

    Matrix3x1f32 :: distinct matrix[3, 1]f32

    Matrix3x1f64 ¶

    Matrix3x1f64 :: distinct matrix[3, 1]f64

    Matrix3x2f16 ¶

    Matrix3x2f16 :: distinct matrix[3, 2]f16

    Matrix3x2f32 ¶

    Matrix3x2f32 :: distinct matrix[3, 2]f32

    Matrix3x2f64 ¶

    Matrix3x2f64 :: distinct matrix[3, 2]f64

    Matrix3x3f16 ¶

    Matrix3x3f16 :: distinct matrix[3, 3]f16
    Related Procedures With Parameters
    Related Procedures With Returns

    Matrix3x3f32 ¶

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

    Matrix3x3f64 ¶

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

    Matrix3x4f16 ¶

    Matrix3x4f16 :: distinct matrix[3, 4]f16

    Matrix3x4f32 ¶

    Matrix3x4f32 :: distinct matrix[3, 4]f32

    Matrix3x4f64 ¶

    Matrix3x4f64 :: distinct matrix[3, 4]f64

    Matrix4x1f16 ¶

    Matrix4x1f16 :: distinct matrix[4, 1]f16

    Matrix4x1f32 ¶

    Matrix4x1f32 :: distinct matrix[4, 1]f32

    Matrix4x1f64 ¶

    Matrix4x1f64 :: distinct matrix[4, 1]f64

    Matrix4x2f16 ¶

    Matrix4x2f16 :: distinct matrix[4, 2]f16

    Matrix4x2f32 ¶

    Matrix4x2f32 :: distinct matrix[4, 2]f32

    Matrix4x2f64 ¶

    Matrix4x2f64 :: distinct matrix[4, 2]f64

    Matrix4x3f16 ¶

    Matrix4x3f16 :: distinct matrix[4, 3]f16

    Matrix4x3f32 ¶

    Matrix4x3f32 :: distinct matrix[4, 3]f32

    Matrix4x3f64 ¶

    Matrix4x3f64 :: distinct matrix[4, 3]f64

    Matrix4x4f16 ¶

    Matrix4x4f16 :: distinct matrix[4, 4]f16
    Related Procedures With Parameters
    Related Procedures With Returns

    Matrix4x4f32 ¶

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

    Matrix4x4f64 ¶

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

    Quaternionf16 ¶

    Quaternionf16 :: distinct quaternion64
    Related Procedures With Parameters
    Related Procedures With Returns

    Quaternionf32 ¶

    Quaternionf32 :: distinct quaternion128
    Related Procedures With Parameters
    Related Procedures With Returns

    Quaternionf64 ¶

    Quaternionf64 :: distinct quaternion256
    Related Procedures With Parameters
    Related Procedures With Returns

    Vector2_Components ¶

    Vector2_Components :: enum u8 {
    	x = 0, 
    	y = 1, 
    	r = 0, 
    	g = 1, 
    }
    Related Procedures With Parameters

    Vector2f16 ¶

    Vector2f16 :: distinct [2]f16
    Related Procedures With Parameters

    Vector2f32 ¶

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

    Vector2f64 ¶

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

    Vector3_Components ¶

    Vector3_Components :: enum u8 {
    	x = 0, 
    	y = 1, 
    	z = 2, 
    	r = 0, 
    	g = 1, 
    	b = 2, 
    }
    Related Procedures With Parameters

    Vector3f32 ¶

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

    Vector3f64 ¶

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

    Vector4_Components ¶

    Vector4_Components :: enum u8 {
    	x = 0, 
    	y = 1, 
    	z = 2, 
    	w = 3, 
    	r = 0, 
    	g = 1, 
    	b = 2, 
    	a = 3, 
    }
    Related Procedures With Parameters

    Vector4f16 ¶

    Vector4f16 :: distinct [4]f16
    Related Procedures With Parameters
    Related Procedures With Returns

    Vector4f32 ¶

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

    Vector4f64 ¶

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

    Constants

    DEG_PER_RAD ¶

    DEG_PER_RAD :: 360.0 / TAU

    E ¶

    E :: 2.71828182845904523536

    F16_EPSILON ¶

    F16_EPSILON :: 1e-3

    F32_EPSILON ¶

    F32_EPSILON :: 1e-7

    F64_EPSILON ¶

    F64_EPSILON :: 1e-15

    LN10 ¶

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶

    LN2 :: 0.693147180559945309417232121458176568

    MATRIX1F16_IDENTITY ¶

    MATRIX1F16_IDENTITY: Matrix1x1f16 : Matrix1f16(1)

    MATRIX1F32_IDENTITY ¶

    MATRIX1F32_IDENTITY: Matrix1x1f32 : Matrix1f32(1)

    MATRIX1F64_IDENTITY ¶

    MATRIX1F64_IDENTITY: Matrix1x1f64 : Matrix1f64(1)

    MATRIX2F16_IDENTITY ¶

    MATRIX2F16_IDENTITY: Matrix2x2f16 : Matrix2f16(1)

    MATRIX2F32_IDENTITY ¶

    MATRIX2F32_IDENTITY: Matrix2x2f32 : Matrix2f32(1)

    MATRIX2F64_IDENTITY ¶

    MATRIX2F64_IDENTITY: Matrix2x2f64 : Matrix2f64(1)

    MATRIX3F16_IDENTITY ¶

    MATRIX3F16_IDENTITY: Matrix3x3f16 : Matrix3f16(1)

    MATRIX3F32_IDENTITY ¶

    MATRIX3F32_IDENTITY: Matrix3x3f32 : Matrix3f32(1)

    MATRIX3F64_IDENTITY ¶

    MATRIX3F64_IDENTITY: Matrix3x3f64 : Matrix3f64(1)

    MATRIX4F16_IDENTITY ¶

    MATRIX4F16_IDENTITY: Matrix4x4f16 : Matrix4f16(1)

    MATRIX4F32_IDENTITY ¶

    MATRIX4F32_IDENTITY: Matrix4x4f32 : Matrix4f32(1)

    MATRIX4F64_IDENTITY ¶

    MATRIX4F64_IDENTITY: Matrix4x4f64 : Matrix4f64(1)

    MAX_F32_PRECISION ¶

    MAX_F32_PRECISION :: 8
     

    Maximum number of meaningful digits after the decimal point for 'f32'

    MAX_F64_PRECISION ¶

    MAX_F64_PRECISION :: 16
     

    Maximum number of meaningful digits after the decimal point for 'f64'

    PI ¶

    PI :: 3.14159265358979323846264338327950288

    QUATERNIONF16_IDENTITY ¶

    QUATERNIONF16_IDENTITY :: Quaternionf16(1)

    QUATERNIONF32_IDENTITY ¶

    QUATERNIONF32_IDENTITY :: Quaternionf32(1)

    QUATERNIONF64_IDENTITY ¶

    QUATERNIONF64_IDENTITY :: Quaternionf64(1)

    RAD_PER_DEG ¶

    RAD_PER_DEG :: TAU / 360.0

    SQRT_FIVE ¶

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶

    TAU :: 6.28318530717958647692528676655900576

    VECTOR3F16_X_AXIS ¶

    VECTOR3F16_X_AXIS :: Vector3f16{1, 0, 0}

    VECTOR3F16_Y_AXIS ¶

    VECTOR3F16_Y_AXIS :: Vector3f16{0, 1, 0}

    VECTOR3F16_Z_AXIS ¶

    VECTOR3F16_Z_AXIS :: Vector3f16{0, 0, 1}

    VECTOR3F32_X_AXIS ¶

    VECTOR3F32_X_AXIS :: Vector3f32{1, 0, 0}

    VECTOR3F32_Y_AXIS ¶

    VECTOR3F32_Y_AXIS :: Vector3f32{0, 1, 0}

    VECTOR3F32_Z_AXIS ¶

    VECTOR3F32_Z_AXIS :: Vector3f32{0, 0, 1}

    VECTOR3F64_X_AXIS ¶

    VECTOR3F64_X_AXIS :: Vector3f64{1, 0, 0}

    VECTOR3F64_Y_AXIS ¶

    VECTOR3F64_Y_AXIS :: Vector3f64{0, 1, 0}

    VECTOR3F64_Z_AXIS ¶

    VECTOR3F64_Z_AXIS :: Vector3f64{0, 0, 1}

    e ¶

    e :: E

    π ¶

    π :: PI

    τ ¶

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs ¶

    abs :: proc "contextless" (a: $T) -> (out: $T) {…}

    acos ¶

    acos :: proc "contextless" (x: $T) -> (out: $T) {…}

    all ¶

    all :: proc "contextless" (x: $A/[0]bool) -> (out: bool) {…}

    angle_axis_from_quaternion_f16 ¶

    angle_axis_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (angle: f16, axis: Vector3f16) {…}

    angle_axis_from_quaternion_f32 ¶

    angle_axis_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (angle: f32, axis: Vector3f32) {…}

    angle_axis_from_quaternion_f64 ¶

    angle_axis_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (angle: f64, axis: Vector3f64) {…}

    angle_from_quaternion_f16 ¶

    angle_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 {…}

    angle_from_quaternion_f32 ¶

    angle_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 {…}

    angle_from_quaternion_f64 ¶

    angle_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 {…}

    any ¶

    any :: proc "contextless" (x: $A/[0]bool) -> (out: bool) {…}

    array_cast ¶

    array_cast :: proc "contextless" (v: $V/[0]$T, $Elem_Type: typeid) -> (w: [0]typeid) {…}

    asin ¶

    asin :: proc "contextless" (x: $T) -> (out: $T) {…}

    atan ¶

    atan :: proc "contextless" (x: $T) -> (out: $T) {…}

    atan2 ¶

    atan2 :: proc "contextless" (y, x: $T) -> (out: $T) {…}

    axis_from_quaternion_f16 ¶

    axis_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> Vector3f16 {…}

    axis_from_quaternion_f32 ¶

    axis_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> Vector3f32 {…}

    axis_from_quaternion_f64 ¶

    axis_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> Vector3f64 {…}

    catmull_rom ¶

    catmull_rom :: proc "contextless" (v1, v2, v3, v4: $V/[0]$T, s: $T) -> $V/[0]$T {…}

    ceil ¶

    ceil :: proc "contextless" (x: $T) -> (out: $T) {…}

    clamp ¶

    clamp :: proc "contextless" (x, a, b: $T) -> (out: $T) {…}

    classify_array ¶

    classify_array :: proc "contextless" (x: $V/[0]$T) -> (out: [0]math.Float_Class) {…}

    classify_single ¶

    classify_single :: proc "contextless" (x: $T) -> math.Float_Class {…}

    cos ¶

    cos :: proc "contextless" (x: $T) -> (out: $T) {…}

    cubic ¶

    cubic :: proc "contextless" (v1, v2, v3, v4: $V/[0]$T, s: $T) -> $V/[0]$T {…}

    distance ¶

    distance :: proc "contextless" (p0, p1: $V/[0]$T) -> $T {…}

    equal_array ¶

    equal_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    equal_single ¶

    equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    euclidean_from_polar_f16 ¶

    euclidean_from_polar_f16 :: proc "contextless" (polar: Vector2f16) -> Vector3f16 {…}

    euclidean_from_polar_f32 ¶

    euclidean_from_polar_f32 :: proc "contextless" (polar: Vector2f32) -> Vector3f32 {…}

    euclidean_from_polar_f64 ¶

    euclidean_from_polar_f64 :: proc "contextless" (polar: Vector2f64) -> Vector3f64 {…}

    euler_angles_from_matrix3_f16 ¶

    euler_angles_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

    euler_angles_from_matrix3_f32 ¶

    euler_angles_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

    euler_angles_from_matrix3_f64 ¶

    euler_angles_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

    euler_angles_from_matrix4_f16 ¶

    euler_angles_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

    euler_angles_from_matrix4_f32 ¶

    euler_angles_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

    euler_angles_from_matrix4_f64 ¶

    euler_angles_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

    euler_angles_from_quaternion_f16 ¶

    euler_angles_from_quaternion_f16 :: proc "contextless" (m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

    euler_angles_from_quaternion_f32 ¶

    euler_angles_from_quaternion_f32 :: proc "contextless" (m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

    euler_angles_from_quaternion_f64 ¶

    euler_angles_from_quaternion_f64 :: proc "contextless" (m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

    euler_angles_xyx_from_matrix3_f16 ¶

    euler_angles_xyx_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyx_from_matrix3_f32 ¶

    euler_angles_xyx_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyx_from_matrix3_f64 ¶

    euler_angles_xyx_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xyx_from_matrix4_f16 ¶

    euler_angles_xyx_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyx_from_matrix4_f32 ¶

    euler_angles_xyx_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyx_from_matrix4_f64 ¶

    euler_angles_xyx_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xyx_from_quaternion_f16 ¶

    euler_angles_xyx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyx_from_quaternion_f32 ¶

    euler_angles_xyx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyx_from_quaternion_f64 ¶

    euler_angles_xyx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_xyz_from_matrix3_f16 ¶

    euler_angles_xyz_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyz_from_matrix3_f32 ¶

    euler_angles_xyz_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyz_from_matrix3_f64 ¶

    euler_angles_xyz_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xyz_from_matrix4_f16 ¶

    euler_angles_xyz_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyz_from_matrix4_f32 ¶

    euler_angles_xyz_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyz_from_matrix4_f64 ¶

    euler_angles_xyz_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xyz_from_quaternion_f16 ¶

    euler_angles_xyz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_xyz_from_quaternion_f32 ¶

    euler_angles_xyz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_xyz_from_quaternion_f64 ¶

    euler_angles_xyz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzx_from_matrix3_f16 ¶

    euler_angles_xzx_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzx_from_matrix3_f32 ¶

    euler_angles_xzx_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzx_from_matrix3_f64 ¶

    euler_angles_xzx_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzx_from_matrix4_f16 ¶

    euler_angles_xzx_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzx_from_matrix4_f32 ¶

    euler_angles_xzx_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzx_from_matrix4_f64 ¶

    euler_angles_xzx_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzx_from_quaternion_f16 ¶

    euler_angles_xzx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzx_from_quaternion_f32 ¶

    euler_angles_xzx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzx_from_quaternion_f64 ¶

    euler_angles_xzx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzy_from_matrix3_f16 ¶

    euler_angles_xzy_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzy_from_matrix3_f32 ¶

    euler_angles_xzy_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzy_from_matrix3_f64 ¶

    euler_angles_xzy_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzy_from_matrix4_f16 ¶

    euler_angles_xzy_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzy_from_matrix4_f32 ¶

    euler_angles_xzy_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzy_from_matrix4_f64 ¶

    euler_angles_xzy_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_xzy_from_quaternion_f16 ¶

    euler_angles_xzy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_xzy_from_quaternion_f32 ¶

    euler_angles_xzy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_xzy_from_quaternion_f64 ¶

    euler_angles_xzy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxy_from_matrix3_f16 ¶

    euler_angles_yxy_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxy_from_matrix3_f32 ¶

    euler_angles_yxy_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxy_from_matrix3_f64 ¶

    euler_angles_yxy_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxy_from_matrix4_f16 ¶

    euler_angles_yxy_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxy_from_matrix4_f32 ¶

    euler_angles_yxy_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxy_from_matrix4_f64 ¶

    euler_angles_yxy_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxy_from_quaternion_f16 ¶

    euler_angles_yxy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxy_from_quaternion_f32 ¶

    euler_angles_yxy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxy_from_quaternion_f64 ¶

    euler_angles_yxy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxz_from_matrix3_f16 ¶

    euler_angles_yxz_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxz_from_matrix3_f32 ¶

    euler_angles_yxz_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxz_from_matrix3_f64 ¶

    euler_angles_yxz_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxz_from_matrix4_f16 ¶

    euler_angles_yxz_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxz_from_matrix4_f32 ¶

    euler_angles_yxz_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxz_from_matrix4_f64 ¶

    euler_angles_yxz_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yxz_from_quaternion_f16 ¶

    euler_angles_yxz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_yxz_from_quaternion_f32 ¶

    euler_angles_yxz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_yxz_from_quaternion_f64 ¶

    euler_angles_yxz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzx_from_matrix3_f16 ¶

    euler_angles_yzx_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzx_from_matrix3_f32 ¶

    euler_angles_yzx_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzx_from_matrix3_f64 ¶

    euler_angles_yzx_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzx_from_matrix4_f16 ¶

    euler_angles_yzx_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzx_from_matrix4_f32 ¶

    euler_angles_yzx_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzx_from_matrix4_f64 ¶

    euler_angles_yzx_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzx_from_quaternion_f16 ¶

    euler_angles_yzx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzx_from_quaternion_f32 ¶

    euler_angles_yzx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzx_from_quaternion_f64 ¶

    euler_angles_yzx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzy_from_matrix3_f16 ¶

    euler_angles_yzy_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzy_from_matrix3_f32 ¶

    euler_angles_yzy_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzy_from_matrix3_f64 ¶

    euler_angles_yzy_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzy_from_matrix4_f16 ¶

    euler_angles_yzy_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzy_from_matrix4_f32 ¶

    euler_angles_yzy_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzy_from_matrix4_f64 ¶

    euler_angles_yzy_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_yzy_from_quaternion_f16 ¶

    euler_angles_yzy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_yzy_from_quaternion_f32 ¶

    euler_angles_yzy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_yzy_from_quaternion_f64 ¶

    euler_angles_yzy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxy_from_matrix3_f16 ¶

    euler_angles_zxy_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxy_from_matrix3_f32 ¶

    euler_angles_zxy_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxy_from_matrix3_f64 ¶

    euler_angles_zxy_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxy_from_matrix4_f16 ¶

    euler_angles_zxy_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxy_from_matrix4_f32 ¶

    euler_angles_zxy_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxy_from_matrix4_f64 ¶

    euler_angles_zxy_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxy_from_quaternion_f16 ¶

    euler_angles_zxy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxy_from_quaternion_f32 ¶

    euler_angles_zxy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxy_from_quaternion_f64 ¶

    euler_angles_zxy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxz_from_matrix3_f16 ¶

    euler_angles_zxz_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxz_from_matrix3_f32 ¶

    euler_angles_zxz_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxz_from_matrix3_f64 ¶

    euler_angles_zxz_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxz_from_matrix4_f16 ¶

    euler_angles_zxz_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxz_from_matrix4_f32 ¶

    euler_angles_zxz_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxz_from_matrix4_f64 ¶

    euler_angles_zxz_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zxz_from_quaternion_f16 ¶

    euler_angles_zxz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_zxz_from_quaternion_f32 ¶

    euler_angles_zxz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_zxz_from_quaternion_f64 ¶

    euler_angles_zxz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyx_from_matrix3_f16 ¶

    euler_angles_zyx_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyx_from_matrix3_f32 ¶

    euler_angles_zyx_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyx_from_matrix3_f64 ¶

    euler_angles_zyx_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyx_from_matrix4_f16 ¶

    euler_angles_zyx_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyx_from_matrix4_f32 ¶

    euler_angles_zyx_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyx_from_matrix4_f64 ¶

    euler_angles_zyx_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyx_from_quaternion_f16 ¶

    euler_angles_zyx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyx_from_quaternion_f32 ¶

    euler_angles_zyx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyx_from_quaternion_f64 ¶

    euler_angles_zyx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyz_from_matrix3_f16 ¶

    euler_angles_zyz_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyz_from_matrix3_f32 ¶

    euler_angles_zyz_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyz_from_matrix3_f64 ¶

    euler_angles_zyz_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyz_from_matrix4_f16 ¶

    euler_angles_zyz_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyz_from_matrix4_f32 ¶

    euler_angles_zyz_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyz_from_matrix4_f64 ¶

    euler_angles_zyz_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

    euler_angles_zyz_from_quaternion_f16 ¶

    euler_angles_zyz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

    euler_angles_zyz_from_quaternion_f32 ¶

    euler_angles_zyz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

    euler_angles_zyz_from_quaternion_f64 ¶

    euler_angles_zyz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

    exp ¶

    exp :: proc "contextless" (x: $T) -> (out: $T) {…}

    exp10 ¶

    exp10 :: proc "contextless" (x: $T) -> (out: $T) {…}

    exp2 ¶

    exp2 :: proc "contextless" (x: $T) -> (out: $T) {…}

    face_forward ¶

    face_forward :: proc "contextless" (N, I, N_ref: $T) -> (out: $T) {…}

    floor ¶

    floor :: proc "contextless" (x: $T) -> (out: $T) {…}

    fract ¶

    fract :: proc "contextless" (x: $T) -> $T {…}

    greater_than_array ¶

    greater_than_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    greater_than_equal_array ¶

    greater_than_equal_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    greater_than_equal_single ¶

    greater_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    greater_than_single ¶

    greater_than_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    hermite ¶

    hermite :: proc "contextless" (v1, t1, v2, t2: $V/[0]$T, s: $T) -> $V/[0]$T {…}

    identity ¶

    identity :: proc "contextless" ($T: typeid/[0][0]T) -> (m: $/[0][0]T) {…}

    inverse_sqrt ¶

    inverse_sqrt :: proc "contextless" (x: $T) -> (out: $T) {…}

    is_inf_array ¶

    is_inf_array :: proc "contextless" (x: $V/[0]$T) -> (out: [0]bool) {…}

    is_inf_single ¶

    is_inf_single :: proc "contextless" (x: $T) -> bool {…}

    is_nan_array ¶

    is_nan_array :: proc "contextless" (x: $V/[0]$T) -> (out: [0]bool) {…}

    is_nan_single ¶

    is_nan_single :: proc "contextless" (x: $T) -> bool {…}

    lerp ¶

    lerp :: proc "contextless" (a, b, t: $T) -> (out: $T) {…}

    less_than_array ¶

    less_than_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    less_than_equal_array ¶

    less_than_equal_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    less_than_equal_single ¶

    less_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    less_than_single ¶

    less_than_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    ln ¶

    ln :: proc "contextless" (x: $T) -> (out: $T) {…}

    log ¶

    log :: proc "contextless" (x, b: $T) -> (out: $T) {…}

    log10 ¶

    log10 :: proc "contextless" (x: $T) -> (out: $T) {…}

    log2 ¶

    log2 :: proc "contextless" (x: $T) -> (out: $T) {…}

    matrix2_adjoint_f16 ¶

    matrix2_adjoint_f16 :: proc "contextless" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

    matrix2_adjoint_f32 ¶

    matrix2_adjoint_f32 :: proc "contextless" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

    matrix2_adjoint_f64 ¶

    matrix2_adjoint_f64 :: proc "contextless" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

    matrix2_determinant_f16 ¶

    matrix2_determinant_f16 :: proc "contextless" (m: Matrix2x2f16) -> f16 {…}

    matrix2_determinant_f32 ¶

    matrix2_determinant_f32 :: proc "contextless" (m: Matrix2x2f32) -> f32 {…}

    matrix2_determinant_f64 ¶

    matrix2_determinant_f64 :: proc "contextless" (m: Matrix2x2f64) -> f64 {…}

    matrix2_from_matrix3_f16 ¶

    matrix2_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (r: Matrix2x2f16) {…}

    matrix2_from_matrix3_f32 ¶

    matrix2_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (r: Matrix2x2f32) {…}

    matrix2_from_matrix3_f64 ¶

    matrix2_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (r: Matrix2x2f64) {…}

    matrix2_from_matrix4_f16 ¶

    matrix2_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (r: Matrix2x2f16) {…}

    matrix2_from_matrix4_f32 ¶

    matrix2_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (r: Matrix2x2f32) {…}

    matrix2_from_matrix4_f64 ¶

    matrix2_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (r: Matrix2x2f64) {…}

    matrix2_from_scalar_f16 ¶

    matrix2_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix2x2f16) {…}

    matrix2_from_scalar_f32 ¶

    matrix2_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix2x2f32) {…}

    matrix2_from_scalar_f64 ¶

    matrix2_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix2x2f64) {…}

    matrix2_inverse_f16 ¶

    matrix2_inverse_f16 :: proc "contextless" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

    matrix2_inverse_f32 ¶

    matrix2_inverse_f32 :: proc "contextless" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

    matrix2_inverse_f64 ¶

    matrix2_inverse_f64 :: proc "contextless" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

    matrix2_inverse_transpose_f16 ¶

    matrix2_inverse_transpose_f16 :: proc "contextless" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

    matrix2_inverse_transpose_f32 ¶

    matrix2_inverse_transpose_f32 :: proc "contextless" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

    matrix2_inverse_transpose_f64 ¶

    matrix2_inverse_transpose_f64 :: proc "contextless" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

    matrix2_orthonormalize_f16 ¶

    matrix2_orthonormalize_f16 :: proc "contextless" (m: Matrix2x2f16) -> (r: Matrix2x2f16) {…}

    matrix2_orthonormalize_f32 ¶

    matrix2_orthonormalize_f32 :: proc "contextless" (m: Matrix2x2f32) -> (r: Matrix2x2f32) {…}

    matrix2_orthonormalize_f64 ¶

    matrix2_orthonormalize_f64 :: proc "contextless" (m: Matrix2x2f64) -> (r: Matrix2x2f64) {…}

    matrix3_adjoint_f16 ¶

    matrix3_adjoint_f16 :: proc "contextless" (m: Matrix3x3f16) -> (adjoint: Matrix3x3f16) {…}

    matrix3_adjoint_f32 ¶

    matrix3_adjoint_f32 :: proc "contextless" (m: Matrix3x3f32) -> (adjoint: Matrix3x3f32) {…}

    matrix3_adjoint_f64 ¶

    matrix3_adjoint_f64 :: proc "contextless" (m: Matrix3x3f64) -> (adjoint: Matrix3x3f64) {…}

    matrix3_determinant_f16 ¶

    matrix3_determinant_f16 :: proc "contextless" (m: Matrix3x3f16) -> f16 {…}

    matrix3_determinant_f32 ¶

    matrix3_determinant_f32 :: proc "contextless" (m: Matrix3x3f32) -> f32 {…}

    matrix3_determinant_f64 ¶

    matrix3_determinant_f64 :: proc "contextless" (m: Matrix3x3f64) -> f64 {…}

    matrix3_from_derived_euler_angle_x_f16 ¶

    matrix3_from_derived_euler_angle_x_f16 :: proc "contextless" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_derived_euler_angle_x_f32 ¶

    matrix3_from_derived_euler_angle_x_f32 :: proc "contextless" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_derived_euler_angle_x_f64 ¶

    matrix3_from_derived_euler_angle_x_f64 :: proc "contextless" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_derived_euler_angle_y_f16 ¶

    matrix3_from_derived_euler_angle_y_f16 :: proc "contextless" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_derived_euler_angle_y_f32 ¶

    matrix3_from_derived_euler_angle_y_f32 :: proc "contextless" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_derived_euler_angle_y_f64 ¶

    matrix3_from_derived_euler_angle_y_f64 :: proc "contextless" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_derived_euler_angle_z_f16 ¶

    matrix3_from_derived_euler_angle_z_f16 :: proc "contextless" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_derived_euler_angle_z_f32 ¶

    matrix3_from_derived_euler_angle_z_f32 :: proc "contextless" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_derived_euler_angle_z_f64 ¶

    matrix3_from_derived_euler_angle_z_f64 :: proc "contextless" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angle_x_f16 ¶

    matrix3_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angle_x_f32 ¶

    matrix3_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angle_x_f64 ¶

    matrix3_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angle_y_f16 ¶

    matrix3_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angle_y_f32 ¶

    matrix3_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angle_y_f64 ¶

    matrix3_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angle_z_f16 ¶

    matrix3_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angle_z_f32 ¶

    matrix3_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angle_z_f64 ¶

    matrix3_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_f16 ¶

    matrix3_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_f32 ¶

    matrix3_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_f64 ¶

    matrix3_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xy_f16 ¶

    matrix3_from_euler_angles_xy_f16 :: proc "contextless" (angle_x, angle_y: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xy_f32 ¶

    matrix3_from_euler_angles_xy_f32 :: proc "contextless" (angle_x, angle_y: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xy_f64 ¶

    matrix3_from_euler_angles_xy_f64 :: proc "contextless" (angle_x, angle_y: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xyx_f16 ¶

    matrix3_from_euler_angles_xyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xyx_f32 ¶

    matrix3_from_euler_angles_xyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xyx_f64 ¶

    matrix3_from_euler_angles_xyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xyz_f16 ¶

    matrix3_from_euler_angles_xyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xyz_f32 ¶

    matrix3_from_euler_angles_xyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xyz_f64 ¶

    matrix3_from_euler_angles_xyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xz_f16 ¶

    matrix3_from_euler_angles_xz_f16 :: proc "contextless" (angle_x, angle_z: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xz_f32 ¶

    matrix3_from_euler_angles_xz_f32 :: proc "contextless" (angle_x, angle_z: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xz_f64 ¶

    matrix3_from_euler_angles_xz_f64 :: proc "contextless" (angle_x, angle_z: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xzx_f16 ¶

    matrix3_from_euler_angles_xzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xzx_f32 ¶

    matrix3_from_euler_angles_xzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xzx_f64 ¶

    matrix3_from_euler_angles_xzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_xzy_f16 ¶

    matrix3_from_euler_angles_xzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_xzy_f32 ¶

    matrix3_from_euler_angles_xzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_xzy_f64 ¶

    matrix3_from_euler_angles_xzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yx_f16 ¶

    matrix3_from_euler_angles_yx_f16 :: proc "contextless" (angle_y, angle_x: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yx_f32 ¶

    matrix3_from_euler_angles_yx_f32 :: proc "contextless" (angle_y, angle_x: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yx_f64 ¶

    matrix3_from_euler_angles_yx_f64 :: proc "contextless" (angle_y, angle_x: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yxy_f16 ¶

    matrix3_from_euler_angles_yxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yxy_f32 ¶

    matrix3_from_euler_angles_yxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yxy_f64 ¶

    matrix3_from_euler_angles_yxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yxz_f16 ¶

    matrix3_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yxz_f32 ¶

    matrix3_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yxz_f64 ¶

    matrix3_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yz_f16 ¶

    matrix3_from_euler_angles_yz_f16 :: proc "contextless" (angle_y, angle_z: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yz_f32 ¶

    matrix3_from_euler_angles_yz_f32 :: proc "contextless" (angle_y, angle_z: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yz_f64 ¶

    matrix3_from_euler_angles_yz_f64 :: proc "contextless" (angle_y, angle_z: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yzx_f16 ¶

    matrix3_from_euler_angles_yzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yzx_f32 ¶

    matrix3_from_euler_angles_yzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yzx_f64 ¶

    matrix3_from_euler_angles_yzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_yzy_f16 ¶

    matrix3_from_euler_angles_yzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_yzy_f32 ¶

    matrix3_from_euler_angles_yzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_yzy_f64 ¶

    matrix3_from_euler_angles_yzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zx_f16 ¶

    matrix3_from_euler_angles_zx_f16 :: proc "contextless" (angle_z, angle_x: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zx_f32 ¶

    matrix3_from_euler_angles_zx_f32 :: proc "contextless" (angle_z, angle_x: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zx_f64 ¶

    matrix3_from_euler_angles_zx_f64 :: proc "contextless" (angle_z, angle_x: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zxy_f16 ¶

    matrix3_from_euler_angles_zxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zxy_f32 ¶

    matrix3_from_euler_angles_zxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zxy_f64 ¶

    matrix3_from_euler_angles_zxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zxz_f16 ¶

    matrix3_from_euler_angles_zxz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zxz_f32 ¶

    matrix3_from_euler_angles_zxz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zxz_f64 ¶

    matrix3_from_euler_angles_zxz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zy_f16 ¶

    matrix3_from_euler_angles_zy_f16 :: proc "contextless" (angle_z, angle_y: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zy_f32 ¶

    matrix3_from_euler_angles_zy_f32 :: proc "contextless" (angle_z, angle_y: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zy_f64 ¶

    matrix3_from_euler_angles_zy_f64 :: proc "contextless" (angle_z, angle_y: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zyx_f16 ¶

    matrix3_from_euler_angles_zyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zyx_f32 ¶

    matrix3_from_euler_angles_zyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zyx_f64 ¶

    matrix3_from_euler_angles_zyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_euler_angles_zyz_f16 ¶

    matrix3_from_euler_angles_zyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_euler_angles_zyz_f32 ¶

    matrix3_from_euler_angles_zyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_euler_angles_zyz_f64 ¶

    matrix3_from_euler_angles_zyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_matrix2_f16 ¶

    matrix3_from_matrix2_f16 :: proc "contextless" (m: Matrix2x2f16) -> (r: Matrix3x3f16) {…}

    matrix3_from_matrix2_f32 ¶

    matrix3_from_matrix2_f32 :: proc "contextless" (m: Matrix2x2f32) -> (r: Matrix3x3f32) {…}

    matrix3_from_matrix2_f64 ¶

    matrix3_from_matrix2_f64 :: proc "contextless" (m: Matrix2x2f64) -> (r: Matrix3x3f64) {…}

    matrix3_from_matrix4_f16 ¶

    matrix3_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (r: Matrix3x3f16) {…}

    matrix3_from_matrix4_f32 ¶

    matrix3_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (r: Matrix3x3f32) {…}

    matrix3_from_matrix4_f64 ¶

    matrix3_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (r: Matrix3x3f64) {…}

    matrix3_from_quaternion_f16 ¶

    matrix3_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (m: Matrix3x3f16) {…}

    matrix3_from_quaternion_f32 ¶

    matrix3_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (m: Matrix3x3f32) {…}

    matrix3_from_quaternion_f64 ¶

    matrix3_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (m: Matrix3x3f64) {…}

    matrix3_from_scalar_f16 ¶

    matrix3_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_scalar_f32 ¶

    matrix3_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_scalar_f64 ¶

    matrix3_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix3x3f64) {…}

    matrix3_from_yaw_pitch_roll_f16 ¶

    matrix3_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix3x3f16) {…}

    matrix3_from_yaw_pitch_roll_f32 ¶

    matrix3_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix3x3f32) {…}

    matrix3_from_yaw_pitch_roll_f64 ¶

    matrix3_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix3x3f64) {…}

    matrix3_inverse_f16 ¶

    matrix3_inverse_f16 :: proc "contextless" (m: Matrix3x3f16) -> Matrix3x3f16 {…}

    matrix3_inverse_f32 ¶

    matrix3_inverse_f32 :: proc "contextless" (m: Matrix3x3f32) -> Matrix3x3f32 {…}

    matrix3_inverse_f64 ¶

    matrix3_inverse_f64 :: proc "contextless" (m: Matrix3x3f64) -> Matrix3x3f64 {…}

    matrix3_inverse_transpose_f16 ¶

    matrix3_inverse_transpose_f16 :: proc "contextless" (m: Matrix3x3f16) -> (inverse_transpose: Matrix3x3f16) {…}

    matrix3_inverse_transpose_f32 ¶

    matrix3_inverse_transpose_f32 :: proc "contextless" (m: Matrix3x3f32) -> (inverse_transpose: Matrix3x3f32) {…}

    matrix3_inverse_transpose_f64 ¶

    matrix3_inverse_transpose_f64 :: proc "contextless" (m: Matrix3x3f64) -> (inverse_transpose: Matrix3x3f64) {…}

    matrix3_look_at_f16 ¶

    matrix3_look_at_f16 :: proc "contextless" (eye, centre: Vector3f16, up: Vector3f16) -> Matrix3x3f16 {…}

    matrix3_look_at_f32 ¶

    matrix3_look_at_f32 :: proc "contextless" (eye, centre: Vector3f32, up: Vector3f32) -> Matrix3x3f32 {…}

    matrix3_look_at_f64 ¶

    matrix3_look_at_f64 :: proc "contextless" (eye, centre: Vector3f64, up: Vector3f64) -> Matrix3x3f64 {…}

    matrix3_orthonormalize_f16 ¶

    matrix3_orthonormalize_f16 :: proc "contextless" (m: Matrix3x3f16) -> (r: Matrix3x3f16) {…}

    matrix3_orthonormalize_f32 ¶

    matrix3_orthonormalize_f32 :: proc "contextless" (m: Matrix3x3f32) -> (r: Matrix3x3f32) {…}

    matrix3_orthonormalize_f64 ¶

    matrix3_orthonormalize_f64 :: proc "contextless" (m: Matrix3x3f64) -> (r: Matrix3x3f64) {…}

    matrix3_rotate_f16 ¶

    matrix3_rotate_f16 :: proc "contextless" (angle_radians: f16, v: Vector3f16) -> (rot: Matrix3x3f16) {…}

    matrix3_rotate_f32 ¶

    matrix3_rotate_f32 :: proc "contextless" (angle_radians: f32, v: Vector3f32) -> (rot: Matrix3x3f32) {…}

    matrix3_rotate_f64 ¶

    matrix3_rotate_f64 :: proc "contextless" (angle_radians: f64, v: Vector3f64) -> (rot: Matrix3x3f64) {…}

    matrix3_scale_f16 ¶

    matrix3_scale_f16 :: proc "contextless" (s: Vector3f16) -> (m: Matrix3x3f16) {…}

    matrix3_scale_f32 ¶

    matrix3_scale_f32 :: proc "contextless" (s: Vector3f32) -> (m: Matrix3x3f32) {…}

    matrix3_scale_f64 ¶

    matrix3_scale_f64 :: proc "contextless" (s: Vector3f64) -> (m: Matrix3x3f64) {…}

    matrix4_adjoint_f16 ¶

    matrix4_adjoint_f16 :: proc "contextless" (m: Matrix4x4f16) -> (adjoint: Matrix4x4f16) {…}

    matrix4_adjoint_f32 ¶

    matrix4_adjoint_f32 :: proc "contextless" (m: Matrix4x4f32) -> (adjoint: Matrix4x4f32) {…}

    matrix4_adjoint_f64 ¶

    matrix4_adjoint_f64 :: proc "contextless" (m: Matrix4x4f64) -> (adjoint: Matrix4x4f64) {…}

    matrix4_cofactor_f16 ¶

    matrix4_cofactor_f16 :: proc "contextless" (m: Matrix4x4f16, c, r: int) -> f16 {…}

    matrix4_cofactor_f32 ¶

    matrix4_cofactor_f32 :: proc "contextless" (m: Matrix4x4f32, c, r: int) -> f32 {…}

    matrix4_cofactor_f64 ¶

    matrix4_cofactor_f64 :: proc "contextless" (m: Matrix4x4f64, c, r: int) -> f64 {…}

    matrix4_determinant_f16 ¶

    matrix4_determinant_f16 :: proc "contextless" (m: Matrix4x4f16) -> (determinant: f16) {…}

    matrix4_determinant_f32 ¶

    matrix4_determinant_f32 :: proc "contextless" (m: Matrix4x4f32) -> (determinant: f32) {…}

    matrix4_determinant_f64 ¶

    matrix4_determinant_f64 :: proc "contextless" (m: Matrix4x4f64) -> (determinant: f64) {…}

    matrix4_from_derived_euler_angle_x_f16 ¶

    matrix4_from_derived_euler_angle_x_f16 :: proc "contextless" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_derived_euler_angle_x_f32 ¶

    matrix4_from_derived_euler_angle_x_f32 :: proc "contextless" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_derived_euler_angle_x_f64 ¶

    matrix4_from_derived_euler_angle_x_f64 :: proc "contextless" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_derived_euler_angle_y_f16 ¶

    matrix4_from_derived_euler_angle_y_f16 :: proc "contextless" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_derived_euler_angle_y_f32 ¶

    matrix4_from_derived_euler_angle_y_f32 :: proc "contextless" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_derived_euler_angle_y_f64 ¶

    matrix4_from_derived_euler_angle_y_f64 :: proc "contextless" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_derived_euler_angle_z_f16 ¶

    matrix4_from_derived_euler_angle_z_f16 :: proc "contextless" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_derived_euler_angle_z_f32 ¶

    matrix4_from_derived_euler_angle_z_f32 :: proc "contextless" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_derived_euler_angle_z_f64 ¶

    matrix4_from_derived_euler_angle_z_f64 :: proc "contextless" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angle_x_f16 ¶

    matrix4_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angle_x_f32 ¶

    matrix4_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angle_x_f64 ¶

    matrix4_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angle_y_f16 ¶

    matrix4_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angle_y_f32 ¶

    matrix4_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angle_y_f64 ¶

    matrix4_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angle_z_f16 ¶

    matrix4_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angle_z_f32 ¶

    matrix4_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angle_z_f64 ¶

    matrix4_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_f16 ¶

    matrix4_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_f32 ¶

    matrix4_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_f64 ¶

    matrix4_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xy_f16 ¶

    matrix4_from_euler_angles_xy_f16 :: proc "contextless" (angle_x, angle_y: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xy_f32 ¶

    matrix4_from_euler_angles_xy_f32 :: proc "contextless" (angle_x, angle_y: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xy_f64 ¶

    matrix4_from_euler_angles_xy_f64 :: proc "contextless" (angle_x, angle_y: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xyx_f16 ¶

    matrix4_from_euler_angles_xyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xyx_f32 ¶

    matrix4_from_euler_angles_xyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xyx_f64 ¶

    matrix4_from_euler_angles_xyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xyz_f16 ¶

    matrix4_from_euler_angles_xyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xyz_f32 ¶

    matrix4_from_euler_angles_xyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xyz_f64 ¶

    matrix4_from_euler_angles_xyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xz_f16 ¶

    matrix4_from_euler_angles_xz_f16 :: proc "contextless" (angle_x, angle_z: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xz_f32 ¶

    matrix4_from_euler_angles_xz_f32 :: proc "contextless" (angle_x, angle_z: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xz_f64 ¶

    matrix4_from_euler_angles_xz_f64 :: proc "contextless" (angle_x, angle_z: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xzx_f16 ¶

    matrix4_from_euler_angles_xzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xzx_f32 ¶

    matrix4_from_euler_angles_xzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xzx_f64 ¶

    matrix4_from_euler_angles_xzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_xzy_f16 ¶

    matrix4_from_euler_angles_xzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_xzy_f32 ¶

    matrix4_from_euler_angles_xzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_xzy_f64 ¶

    matrix4_from_euler_angles_xzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yx_f16 ¶

    matrix4_from_euler_angles_yx_f16 :: proc "contextless" (angle_y, angle_x: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yx_f32 ¶

    matrix4_from_euler_angles_yx_f32 :: proc "contextless" (angle_y, angle_x: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yx_f64 ¶

    matrix4_from_euler_angles_yx_f64 :: proc "contextless" (angle_y, angle_x: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yxy_f16 ¶

    matrix4_from_euler_angles_yxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yxy_f32 ¶

    matrix4_from_euler_angles_yxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yxy_f64 ¶

    matrix4_from_euler_angles_yxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yxz_f16 ¶

    matrix4_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yxz_f32 ¶

    matrix4_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yxz_f64 ¶

    matrix4_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yz_f16 ¶

    matrix4_from_euler_angles_yz_f16 :: proc "contextless" (angle_y, angle_z: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yz_f32 ¶

    matrix4_from_euler_angles_yz_f32 :: proc "contextless" (angle_y, angle_z: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yz_f64 ¶

    matrix4_from_euler_angles_yz_f64 :: proc "contextless" (angle_y, angle_z: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yzx_f16 ¶

    matrix4_from_euler_angles_yzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yzx_f32 ¶

    matrix4_from_euler_angles_yzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yzx_f64 ¶

    matrix4_from_euler_angles_yzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_yzy_f16 ¶

    matrix4_from_euler_angles_yzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_yzy_f32 ¶

    matrix4_from_euler_angles_yzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_yzy_f64 ¶

    matrix4_from_euler_angles_yzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zx_f16 ¶

    matrix4_from_euler_angles_zx_f16 :: proc "contextless" (angle_z, angle_x: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zx_f32 ¶

    matrix4_from_euler_angles_zx_f32 :: proc "contextless" (angle_z, angle_x: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zx_f64 ¶

    matrix4_from_euler_angles_zx_f64 :: proc "contextless" (angle_z, angle_x: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zxy_f16 ¶

    matrix4_from_euler_angles_zxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zxy_f32 ¶

    matrix4_from_euler_angles_zxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zxy_f64 ¶

    matrix4_from_euler_angles_zxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zxz_f16 ¶

    matrix4_from_euler_angles_zxz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zxz_f32 ¶

    matrix4_from_euler_angles_zxz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zxz_f64 ¶

    matrix4_from_euler_angles_zxz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zy_f16 ¶

    matrix4_from_euler_angles_zy_f16 :: proc "contextless" (angle_z, angle_y: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zy_f32 ¶

    matrix4_from_euler_angles_zy_f32 :: proc "contextless" (angle_z, angle_y: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zy_f64 ¶

    matrix4_from_euler_angles_zy_f64 :: proc "contextless" (angle_z, angle_y: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zyx_f16 ¶

    matrix4_from_euler_angles_zyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zyx_f32 ¶

    matrix4_from_euler_angles_zyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zyx_f64 ¶

    matrix4_from_euler_angles_zyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_euler_angles_zyz_f16 ¶

    matrix4_from_euler_angles_zyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_euler_angles_zyz_f32 ¶

    matrix4_from_euler_angles_zyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_euler_angles_zyz_f64 ¶

    matrix4_from_euler_angles_zyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_matrix2_f16 ¶

    matrix4_from_matrix2_f16 :: proc "contextless" (m: Matrix2x2f16) -> (r: Matrix4x4f16) {…}

    matrix4_from_matrix2_f32 ¶

    matrix4_from_matrix2_f32 :: proc "contextless" (m: Matrix2x2f32) -> (r: Matrix4x4f32) {…}

    matrix4_from_matrix2_f64 ¶

    matrix4_from_matrix2_f64 :: proc "contextless" (m: Matrix2x2f64) -> (r: Matrix4x4f64) {…}

    matrix4_from_matrix3_f16 ¶

    matrix4_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (r: Matrix4x4f16) {…}

    matrix4_from_matrix3_f32 ¶

    matrix4_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (r: Matrix4x4f32) {…}

    matrix4_from_matrix3_f64 ¶

    matrix4_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (r: Matrix4x4f64) {…}

    matrix4_from_quaternion_f16 ¶

    matrix4_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (m: Matrix4x4f16) {…}

    matrix4_from_quaternion_f32 ¶

    matrix4_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (m: Matrix4x4f32) {…}

    matrix4_from_quaternion_f64 ¶

    matrix4_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (m: Matrix4x4f64) {…}

    matrix4_from_scalar_f16 ¶

    matrix4_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_scalar_f32 ¶

    matrix4_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_scalar_f64 ¶

    matrix4_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix4x4f64) {…}

    matrix4_from_trs_f16 ¶

    matrix4_from_trs_f16 :: proc "contextless" (t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4x4f16 {…}

    matrix4_from_trs_f32 ¶

    matrix4_from_trs_f32 :: proc "contextless" (t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4x4f32 {…}

    matrix4_from_trs_f64 ¶

    matrix4_from_trs_f64 :: proc "contextless" (t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4x4f64 {…}

    matrix4_from_yaw_pitch_roll_f16 ¶

    matrix4_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix4x4f16) {…}

    matrix4_from_yaw_pitch_roll_f32 ¶

    matrix4_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix4x4f32) {…}

    matrix4_from_yaw_pitch_roll_f64 ¶

    matrix4_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix4x4f64) {…}

    matrix4_infinite_perspective_f16 ¶

    matrix4_infinite_perspective_f16 :: proc "contextless" (fovy, aspect, near: f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

    matrix4_infinite_perspective_f32 ¶

    matrix4_infinite_perspective_f32 :: proc "contextless" (fovy, aspect, near: f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

    matrix4_infinite_perspective_f64 ¶

    matrix4_infinite_perspective_f64 :: proc "contextless" (fovy, aspect, near: f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

    matrix4_inverse_f16 ¶

    matrix4_inverse_f16 :: proc "contextless" (m: Matrix4x4f16) -> Matrix4x4f16 {…}

    matrix4_inverse_f32 ¶

    matrix4_inverse_f32 :: proc "contextless" (m: Matrix4x4f32) -> Matrix4x4f32 {…}

    matrix4_inverse_f64 ¶

    matrix4_inverse_f64 :: proc "contextless" (m: Matrix4x4f64) -> Matrix4x4f64 {…}

    matrix4_inverse_transpose_f16 ¶

    matrix4_inverse_transpose_f16 :: proc "contextless" (m: Matrix4x4f16) -> (inverse_transpose: Matrix4x4f16) {…}

    matrix4_inverse_transpose_f32 ¶

    matrix4_inverse_transpose_f32 :: proc "contextless" (m: Matrix4x4f32) -> (inverse_transpose: Matrix4x4f32) {…}

    matrix4_inverse_transpose_f64 ¶

    matrix4_inverse_transpose_f64 :: proc "contextless" (m: Matrix4x4f64) -> (inverse_transpose: Matrix4x4f64) {…}

    matrix4_look_at_f16 ¶

    matrix4_look_at_f16 :: proc "contextless" (eye, centre, up: Vector3f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

    matrix4_look_at_f32 ¶

    matrix4_look_at_f32 :: proc "contextless" (eye, centre, up: Vector3f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

    matrix4_look_at_f64 ¶

    matrix4_look_at_f64 :: proc "contextless" (eye, centre, up: Vector3f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

    matrix4_look_at_from_fru_f16 ¶

    matrix4_look_at_from_fru_f16 :: proc "contextless" (eye, f, r, u: Vector3f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

    matrix4_look_at_from_fru_f32 ¶

    matrix4_look_at_from_fru_f32 :: proc "contextless" (eye, f, r, u: Vector3f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

    matrix4_look_at_from_fru_f64 ¶

    matrix4_look_at_from_fru_f64 :: proc "contextless" (eye, f, r, u: Vector3f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

    matrix4_minor_f16 ¶

    matrix4_minor_f16 :: proc "contextless" (m: Matrix4x4f16, c, r: int) -> f16 {…}

    matrix4_minor_f32 ¶

    matrix4_minor_f32 :: proc "contextless" (m: Matrix4x4f32, c, r: int) -> f32 {…}

    matrix4_minor_f64 ¶

    matrix4_minor_f64 :: proc "contextless" (m: Matrix4x4f64, c, r: int) -> f64 {…}

    matrix4_orientation_f16 ¶

    matrix4_orientation_f16 :: proc "contextless" (normal, up: Vector3f16) -> Matrix4x4f16 {…}

    matrix4_orientation_f32 ¶

    matrix4_orientation_f32 :: proc "contextless" (normal, up: Vector3f32) -> Matrix4x4f32 {…}

    matrix4_orientation_f64 ¶

    matrix4_orientation_f64 :: proc "contextless" (normal, up: Vector3f64) -> Matrix4x4f64 {…}

    matrix4_perspective_f16 ¶

    matrix4_perspective_f16 :: proc "contextless" (fovy, aspect, near, far: f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

    matrix4_perspective_f32 ¶

    matrix4_perspective_f32 :: proc "contextless" (fovy, aspect, near, far: f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

    matrix4_perspective_f64 ¶

    matrix4_perspective_f64 :: proc "contextless" (fovy, aspect, near, far: f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

    matrix4_rotate_f16 ¶

    matrix4_rotate_f16 :: proc "contextless" (angle_radians: f16, v: Vector3f16) -> Matrix4x4f16 {…}

    matrix4_rotate_f32 ¶

    matrix4_rotate_f32 :: proc "contextless" (angle_radians: f32, v: Vector3f32) -> Matrix4x4f32 {…}

    matrix4_rotate_f64 ¶

    matrix4_rotate_f64 :: proc "contextless" (angle_radians: f64, v: Vector3f64) -> Matrix4x4f64 {…}

    matrix4_scale_f16 ¶

    matrix4_scale_f16 :: proc "contextless" (v: Vector3f16) -> (m: Matrix4x4f16) {…}

    matrix4_scale_f32 ¶

    matrix4_scale_f32 :: proc "contextless" (v: Vector3f32) -> (m: Matrix4x4f32) {…}

    matrix4_scale_f64 ¶

    matrix4_scale_f64 :: proc "contextless" (v: Vector3f64) -> (m: Matrix4x4f64) {…}

    matrix4_translate_f16 ¶

    matrix4_translate_f16 :: proc "contextless" (v: Vector3f16) -> Matrix4x4f16 {…}

    matrix4_translate_f32 ¶

    matrix4_translate_f32 :: proc "contextless" (v: Vector3f32) -> Matrix4x4f32 {…}

    matrix4_translate_f64 ¶

    matrix4_translate_f64 :: proc "contextless" (v: Vector3f64) -> Matrix4x4f64 {…}

    matrix_cast ¶

    matrix_cast :: proc "contextless" (v: $M/matrix[0, 0]$T, $Elem_Type: typeid) -> (w: matrix[0, 0]typeid) {…}

    matrix_comp_mul ¶

    matrix_comp_mul :: proc "contextless" (a, b: $M/matrix[0, 0]$T) -> (c: $M/matrix[0, 0]$T) {…}

    matrix_mul ¶

    matrix_mul :: proc "contextless" (a, b: $M/matrix[0, 0]$T) -> (c: $M/matrix[0, 0]$T) {…}

    matrix_mul_differ ¶

    matrix_mul_differ :: proc "contextless" (a, b: $M/matrix[0, 0]$T) -> (c: matrix[0, 0]$T) {…}

    matrix_mul_vector ¶

    matrix_mul_vector :: proc "contextless" (a: $A/matrix[4, 4]$T, b: $V/[0]$T) -> (c: $V/[0]$T) {…}

    matrix_ortho3d_f16 ¶

    matrix_ortho3d_f16 :: proc "contextless" (
    	left, right, bottom, top, near, far: f16, 
    	flip_z_axis:                         bool = true, 
    ) -> (m: Matrix4x4f16) {…}

    matrix_ortho3d_f32 ¶

    matrix_ortho3d_f32 :: proc "contextless" (
    	left, right, bottom, top, near, far: f32, 
    	flip_z_axis:                         bool = true, 
    ) -> (m: Matrix4x4f32) {…}

    matrix_ortho3d_f64 ¶

    matrix_ortho3d_f64 :: proc "contextless" (
    	left, right, bottom, top, near, far: f64, 
    	flip_z_axis:                         bool = true, 
    ) -> (m: Matrix4x4f64) {…}

    matrix_to_ptr ¶

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

    max_double ¶

    max_double :: proc "contextless" (a, b: $T) -> (out: $T) {…}

    max_single ¶

    max_single :: proc "contextless" (a: $T) -> (out: $T) {…}

    max_triple ¶

    max_triple :: proc "contextless" (a, b, c: $T) -> $T {…}

    min_double ¶

    min_double :: proc "contextless" (a, b: $T) -> (out: $T) {…}

    min_single ¶

    min_single :: proc "contextless" (a: $T) -> (out: $T) {…}

    min_triple ¶

    min_triple :: proc "contextless" (a, b, c: $T) -> $T {…}

    mix ¶

    mix :: proc "contextless" (a, b, t: $T) -> (out: $T) {…}

    mod ¶

    mod :: proc "contextless" (x, m: $T) -> $T {…}

    not ¶

    not :: proc "contextless" (x: $A/[0]bool) -> (out: $A/[0]bool) {…}

    not_equal_array ¶

    not_equal_array :: proc "contextless" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

    not_equal_single ¶

    not_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

    outer_product ¶

    outer_product :: builtin.outer_product

    pitch_from_quaternion_f16 ¶

    pitch_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 {…}

    pitch_from_quaternion_f32 ¶

    pitch_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 {…}

    pitch_from_quaternion_f64 ¶

    pitch_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 {…}

    pitch_yaw_roll_from_quaternion_f16 ¶

    pitch_yaw_roll_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (pitch, yaw, roll: f16) {…}

    pitch_yaw_roll_from_quaternion_f32 ¶

    pitch_yaw_roll_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (pitch, yaw, roll: f32) {…}

    pitch_yaw_roll_from_quaternion_f64 ¶

    pitch_yaw_roll_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (pitch, yaw, roll: f64) {…}

    polar_from_euclidean_f16 ¶

    polar_from_euclidean_f16 :: proc "contextless" (euclidean: Vector3f16) -> Vector3f16 {…}

    polar_from_euclidean_f32 ¶

    polar_from_euclidean_f32 :: proc "contextless" (euclidean: Vector3f32) -> Vector3f32 {…}

    polar_from_euclidean_f64 ¶

    polar_from_euclidean_f64 :: proc "contextless" (euclidean: Vector3f64) -> Vector3f64 {…}

    pow ¶

    pow :: proc "contextless" (x, e: $T) -> (out: $T) {…}

    projection ¶

    projection :: proc "contextless" (x, normal: $V/[0]$T) -> $V/[0]$T {…}

    quaternion128_dot ¶

    quaternion128_dot :: proc "contextless" (a, b: $T/quaternion128) -> (c: f32) {…}

    quaternion128_mul_vector3 ¶

    quaternion128_mul_vector3 :: proc "contextless" (q: $T/quaternion128, v: $V/[3]$F/f32) -> $V/[3]$F/f32 {…}

    quaternion256_dot ¶

    quaternion256_dot :: proc "contextless" (a, b: $T/quaternion256) -> (c: f64) {…}

    quaternion256_mul_vector3 ¶

    quaternion256_mul_vector3 :: proc "contextless" (q: $T/quaternion256, v: $V/[3]$F/f64) -> $V/[3]$F/f64 {…}

    quaternion64_dot ¶

    quaternion64_dot :: proc "contextless" (a, b: $T/quaternion64) -> (c: f16) {…}

    quaternion64_mul_vector3 ¶

    quaternion64_mul_vector3 :: proc "contextless" (q: $T/quaternion64, v: $V/[3]$F/f16) -> $V/[3]$F/f16 {…}

    quaternion_angle_axis_f16 ¶

    quaternion_angle_axis_f16 :: proc "contextless" (angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) {…}

    quaternion_angle_axis_f32 ¶

    quaternion_angle_axis_f32 :: proc "contextless" (angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) {…}

    quaternion_angle_axis_f64 ¶

    quaternion_angle_axis_f64 :: proc "contextless" (angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) {…}

    quaternion_between_two_vector3_f16 ¶

    quaternion_between_two_vector3_f16 :: proc "contextless" (from, to: Vector3f16) -> (q: Quaternionf16) {…}

    quaternion_between_two_vector3_f32 ¶

    quaternion_between_two_vector3_f32 :: proc "contextless" (from, to: Vector3f32) -> (q: Quaternionf32) {…}

    quaternion_between_two_vector3_f64 ¶

    quaternion_between_two_vector3_f64 :: proc "contextless" (from, to: Vector3f64) -> (q: Quaternionf64) {…}

    quaternion_cross ¶

    quaternion_cross :: proc "contextless" (q1, q2: $T) -> (q3: $T) {…}

    quaternion_from_euler_angle_x_f16 ¶

    quaternion_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (q: Quaternionf16) {…}

    quaternion_from_euler_angle_x_f32 ¶

    quaternion_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (q: Quaternionf32) {…}

    quaternion_from_euler_angle_x_f64 ¶

    quaternion_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (q: Quaternionf64) {…}

    quaternion_from_euler_angle_y_f16 ¶

    quaternion_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (q: Quaternionf16) {…}

    quaternion_from_euler_angle_y_f32 ¶

    quaternion_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (q: Quaternionf32) {…}

    quaternion_from_euler_angle_y_f64 ¶

    quaternion_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (q: Quaternionf64) {…}

    quaternion_from_euler_angle_z_f16 ¶

    quaternion_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (q: Quaternionf16) {…}

    quaternion_from_euler_angle_z_f32 ¶

    quaternion_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (q: Quaternionf32) {…}

    quaternion_from_euler_angle_z_f64 ¶

    quaternion_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (q: Quaternionf64) {…}

    quaternion_from_euler_angles_f16 ¶

    quaternion_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 {…}

    quaternion_from_euler_angles_f32 ¶

    quaternion_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 {…}

    quaternion_from_euler_angles_f64 ¶

    quaternion_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 {…}

    quaternion_from_forward_and_up_f16 ¶

    quaternion_from_forward_and_up_f16 :: proc "contextless" (forward, up: Vector3f16) -> Quaternionf16 {…}

    quaternion_from_forward_and_up_f32 ¶

    quaternion_from_forward_and_up_f32 :: proc "contextless" (forward, up: Vector3f32) -> Quaternionf32 {…}

    quaternion_from_forward_and_up_f64 ¶

    quaternion_from_forward_and_up_f64 :: proc "contextless" (forward, up: Vector3f64) -> Quaternionf64 {…}

    quaternion_from_matrix3_f16 ¶

    quaternion_from_matrix3_f16 :: proc "contextless" (m: Matrix3x3f16) -> (q: Quaternionf16) {…}

    quaternion_from_matrix3_f32 ¶

    quaternion_from_matrix3_f32 :: proc "contextless" (m: Matrix3x3f32) -> (q: Quaternionf32) {…}

    quaternion_from_matrix3_f64 ¶

    quaternion_from_matrix3_f64 :: proc "contextless" (m: Matrix3x3f64) -> (q: Quaternionf64) {…}

    quaternion_from_matrix4_f16 ¶

    quaternion_from_matrix4_f16 :: proc "contextless" (m: Matrix4x4f16) -> (q: Quaternionf16) {…}

    quaternion_from_matrix4_f32 ¶

    quaternion_from_matrix4_f32 :: proc "contextless" (m: Matrix4x4f32) -> (q: Quaternionf32) {…}

    quaternion_from_matrix4_f64 ¶

    quaternion_from_matrix4_f64 :: proc "contextless" (m: Matrix4x4f64) -> (q: Quaternionf64) {…}

    quaternion_from_pitch_yaw_roll_f16 ¶

    quaternion_from_pitch_yaw_roll_f16 :: proc "contextless" (pitch, yaw, roll: f16) -> Quaternionf16 {…}

    quaternion_from_pitch_yaw_roll_f32 ¶

    quaternion_from_pitch_yaw_roll_f32 :: proc "contextless" (pitch, yaw, roll: f32) -> Quaternionf32 {…}

    quaternion_from_pitch_yaw_roll_f64 ¶

    quaternion_from_pitch_yaw_roll_f64 :: proc "contextless" (pitch, yaw, roll: f64) -> Quaternionf64 {…}

    quaternion_from_scalar_f16 ¶

    quaternion_from_scalar_f16 :: proc "contextless" (f: f16) -> (q: Quaternionf16) {…}

    quaternion_from_scalar_f32 ¶

    quaternion_from_scalar_f32 :: proc "contextless" (f: f32) -> (q: Quaternionf32) {…}

    quaternion_from_scalar_f64 ¶

    quaternion_from_scalar_f64 :: proc "contextless" (f: f64) -> (q: Quaternionf64) {…}

    quaternion_inverse ¶

    quaternion_inverse :: proc "contextless" (q: $T) -> $T {…}

    quaternion_length ¶

    quaternion_length :: proc "contextless" (q: $T) -> $T {…}

    quaternion_length2 ¶

    quaternion_length2 :: proc "contextless" (q: $T) -> $T {…}

    quaternion_look_at_f16 ¶

    quaternion_look_at_f16 :: proc "contextless" (eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 {…}

    quaternion_look_at_f32 ¶

    quaternion_look_at_f32 :: proc "contextless" (eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 {…}

    quaternion_look_at_f64 ¶

    quaternion_look_at_f64 :: proc "contextless" (eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 {…}

    quaternion_mul_quaternion ¶

    quaternion_mul_quaternion :: proc "contextless" (q1, q2: $T) -> $T {…}

    quaternion_nlerp_f16 ¶

    quaternion_nlerp_f16 :: proc "contextless" (a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) {…}

    quaternion_nlerp_f32 ¶

    quaternion_nlerp_f32 :: proc "contextless" (a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) {…}

    quaternion_nlerp_f64 ¶

    quaternion_nlerp_f64 :: proc "contextless" (a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) {…}

    quaternion_normalize ¶

    quaternion_normalize :: proc "contextless" (q: $T) -> $T {…}

    quaternion_normalize0 ¶

    quaternion_normalize0 :: proc "contextless" (q: $T) -> $T {…}

    quaternion_slerp_f16 ¶

    quaternion_slerp_f16 :: proc "contextless" (x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) {…}

    quaternion_slerp_f32 ¶

    quaternion_slerp_f32 :: proc "contextless" (x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) {…}

    quaternion_slerp_f64 ¶

    quaternion_slerp_f64 :: proc "contextless" (x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) {…}

    quaternion_squad_f16 ¶

    quaternion_squad_f16 :: proc "contextless" (q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 {…}

    quaternion_squad_f32 ¶

    quaternion_squad_f32 :: proc "contextless" (q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 {…}

    quaternion_squad_f64 ¶

    quaternion_squad_f64 :: proc "contextless" (q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 {…}

    reflect ¶

    reflect :: proc "contextless" (I, N: $T) -> (out: $T) {…}

    refract ¶

    refract :: proc "contextless" (I, Normal: $V/[0]$T, eta: $T) -> (out: $V/[0]$T) {…}

    roll_from_quaternion_f16 ¶

    roll_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 {…}

    roll_from_quaternion_f32 ¶

    roll_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 {…}

    roll_from_quaternion_f64 ¶

    roll_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 {…}

    round ¶

    round :: proc "contextless" (x: $T) -> (out: $T) {…}

    saturate ¶

    saturate :: proc "contextless" (x: $T) -> $T {…}

    scalar_cross ¶

    scalar_cross :: proc "contextless" (a, b: $T) -> $T {…}

    scalar_dot ¶

    scalar_dot :: proc "contextless" (a, b: $T) -> $T {…}

    scalar_f32_swizzle1 ¶

    scalar_f32_swizzle1 :: proc "contextless" (f: f32, c0: Scalar_Components) -> f32 {…}

    scalar_f32_swizzle2 ¶

    scalar_f32_swizzle2 :: proc "contextless" (f: f32, c0, c1: Scalar_Components) -> Vector2f32 {…}

    scalar_f32_swizzle3 ¶

    scalar_f32_swizzle3 :: proc "contextless" (f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 {…}

    scalar_f32_swizzle4 ¶

    scalar_f32_swizzle4 :: proc "contextless" (f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 {…}

    scalar_f64_swizzle1 ¶

    scalar_f64_swizzle1 :: proc "contextless" (f: f64, c0: Scalar_Components) -> f64 {…}

    scalar_f64_swizzle2 ¶

    scalar_f64_swizzle2 :: proc "contextless" (f: f64, c0, c1: Scalar_Components) -> Vector2f64 {…}

    scalar_f64_swizzle3 ¶

    scalar_f64_swizzle3 :: proc "contextless" (f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 {…}

    scalar_f64_swizzle4 ¶

    scalar_f64_swizzle4 :: proc "contextless" (f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 {…}

    scalar_triple_product ¶

    scalar_triple_product :: proc "contextless" (a, b, c: $V/[0]$T) -> $T {…}

    sign ¶

    sign :: proc "contextless" (a: $T) -> (out: $T) {…}

    sin ¶

    sin :: proc "contextless" (x: $T) -> (out: $T) {…}

    smootherstep ¶

    smootherstep :: proc "contextless" (e0, e1, x: $T) -> $T {…}

    smoothstep ¶

    smoothstep :: proc "contextless" (e0, e1, x: $T) -> $T {…}

    sqrt ¶

    sqrt :: proc "contextless" (x: $T) -> (out: $T) {…}

    step ¶

    step :: proc "contextless" (e, x: $T) -> (out: $T) {…}

    tan ¶

    tan :: proc "contextless" (x: $T) -> (out: $T) {…}

    to_complex128 ¶

    to_complex128 :: proc(v: $V/[0]$T) -> [0]complex128 {…}

    to_complex32 ¶

    to_complex32 :: proc(v: $V/[0]$T) -> [0]complex32 {…}

    to_complex64 ¶

    to_complex64 :: proc(v: $V/[0]$T) -> [0]complex64 {…}

    to_degrees ¶

    to_degrees :: proc "contextless" (radians: $T) -> (out: $T) {…}

    to_f32 ¶

    to_f32 :: proc(v: $V/[0]$T) -> [0]f32 {…}

    to_f64 ¶

    to_f64 :: proc(v: $V/[0]$T) -> [0]f64 {…}

    to_i16 ¶

    to_i16 :: proc(v: $V/[0]$T) -> [0]i16 {…}

    to_i32 ¶

    to_i32 :: proc(v: $V/[0]$T) -> [0]i32 {…}

    to_i64 ¶

    to_i64 :: proc(v: $V/[0]$T) -> [0]i64 {…}

    to_i8 ¶

    to_i8 :: proc(v: $V/[0]$T) -> [0]i8 {…}

    to_int ¶

    to_int :: proc(v: $V/[0]$T) -> [0]int {…}

    to_quaternion128 ¶

    to_quaternion128 :: proc(v: $V/[0]$T) -> [0]quaternion128 {…}

    to_quaternion256 ¶

    to_quaternion256 :: proc(v: $V/[0]$T) -> [0]quaternion256 {…}

    to_quaternion64 ¶

    to_quaternion64 :: proc(v: $V/[0]$T) -> [0]quaternion64 {…}

    to_radians ¶

    to_radians :: proc "contextless" (degrees: $T) -> (out: $T) {…}

    to_u16 ¶

    to_u16 :: proc(v: $V/[0]$T) -> [0]u16 {…}

    to_u32 ¶

    to_u32 :: proc(v: $V/[0]$T) -> [0]u32 {…}

    to_u64 ¶

    to_u64 :: proc(v: $V/[0]$T) -> [0]u64 {…}

    to_u8 ¶

    to_u8 :: proc(v: $V/[0]$T) -> [0]u8 {…}

    to_uint ¶

    to_uint :: proc(v: $V/[0]$T) -> [0]uint {…}

    transpose ¶

    transpose :: builtin.transpose

    unlerp ¶

    unlerp :: proc "contextless" (a, b, x: $T) -> $T {…}

    vector2_orthogonal ¶

    vector2_orthogonal :: proc "contextless" (v: $T/[2]$T) -> $T/[2]$T {…}

    vector2f32_swizzle1 ¶

    vector2f32_swizzle1 :: proc "contextless" (v: Vector2f32, c0: Vector2_Components) -> f32 {…}

    vector2f32_swizzle2 ¶

    vector2f32_swizzle2 :: proc "contextless" (v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 {…}

    vector2f32_swizzle3 ¶

    vector2f32_swizzle3 :: proc "contextless" (v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 {…}

    vector2f32_swizzle4 ¶

    vector2f32_swizzle4 :: proc "contextless" (v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 {…}

    vector2f64_swizzle1 ¶

    vector2f64_swizzle1 :: proc "contextless" (v: Vector2f64, c0: Vector2_Components) -> f64 {…}

    vector2f64_swizzle2 ¶

    vector2f64_swizzle2 :: proc "contextless" (v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 {…}

    vector2f64_swizzle3 ¶

    vector2f64_swizzle3 :: proc "contextless" (v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 {…}

    vector2f64_swizzle4 ¶

    vector2f64_swizzle4 :: proc "contextless" (v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 {…}

    vector3_orthogonal ¶

    vector3_orthogonal :: proc "contextless" (v: $T/[3]$T) -> $T/[3]$T {…}

    vector3_orthonormalize_f16 ¶

    vector3_orthonormalize_f16 :: proc "contextless" (x, y: Vector3f16) -> (z: Vector3f16) {…}

    vector3_orthonormalize_f32 ¶

    vector3_orthonormalize_f32 :: proc "contextless" (x, y: Vector3f32) -> (z: Vector3f32) {…}

    vector3_orthonormalize_f64 ¶

    vector3_orthonormalize_f64 :: proc "contextless" (x, y: Vector3f64) -> (z: Vector3f64) {…}

    vector3f32_swizzle1 ¶

    vector3f32_swizzle1 :: proc "contextless" (v: Vector3f32, c0: Vector3_Components) -> f32 {…}

    vector3f32_swizzle2 ¶

    vector3f32_swizzle2 :: proc "contextless" (v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 {…}

    vector3f32_swizzle3 ¶

    vector3f32_swizzle3 :: proc "contextless" (v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 {…}

    vector3f32_swizzle4 ¶

    vector3f32_swizzle4 :: proc "contextless" (v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 {…}

    vector3f64_swizzle1 ¶

    vector3f64_swizzle1 :: proc "contextless" (v: Vector3f64, c0: Vector3_Components) -> f64 {…}

    vector3f64_swizzle2 ¶

    vector3f64_swizzle2 :: proc "contextless" (v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 {…}

    vector3f64_swizzle3 ¶

    vector3f64_swizzle3 :: proc "contextless" (v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 {…}

    vector3f64_swizzle4 ¶

    vector3f64_swizzle4 :: proc "contextless" (v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 {…}

    vector4_hsl_to_rgb_f16 ¶

    vector4_hsl_to_rgb_f16 :: proc "contextless" (h, s, l: f16, a: f16 = 1) -> Vector4f16 {…}

    vector4_hsl_to_rgb_f32 ¶

    vector4_hsl_to_rgb_f32 :: proc "contextless" (h, s, l: f32, a: f32 = 1) -> Vector4f32 {…}

    vector4_hsl_to_rgb_f64 ¶

    vector4_hsl_to_rgb_f64 :: proc "contextless" (h, s, l: f64, a: f64 = 1) -> Vector4f64 {…}

    vector4_linear_to_srgb_f16 ¶

    vector4_linear_to_srgb_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 {…}

    vector4_linear_to_srgb_f32 ¶

    vector4_linear_to_srgb_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 {…}

    vector4_linear_to_srgb_f64 ¶

    vector4_linear_to_srgb_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 {…}

    vector4_rgb_to_hsl_f16 ¶

    vector4_rgb_to_hsl_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 {…}

    vector4_rgb_to_hsl_f32 ¶

    vector4_rgb_to_hsl_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 {…}

    vector4_rgb_to_hsl_f64 ¶

    vector4_rgb_to_hsl_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 {…}

    vector4_srgb_to_linear_f16 ¶

    vector4_srgb_to_linear_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 {…}

    vector4_srgb_to_linear_f32 ¶

    vector4_srgb_to_linear_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 {…}

    vector4_srgb_to_linear_f64 ¶

    vector4_srgb_to_linear_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 {…}

    vector4f32_swizzle1 ¶

    vector4f32_swizzle1 :: proc "contextless" (v: Vector4f32, c0: Vector4_Components) -> f32 {…}

    vector4f32_swizzle2 ¶

    vector4f32_swizzle2 :: proc "contextless" (v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 {…}

    vector4f32_swizzle3 ¶

    vector4f32_swizzle3 :: proc "contextless" (v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 {…}

    vector4f32_swizzle4 ¶

    vector4f32_swizzle4 :: proc "contextless" (v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 {…}

    vector4f64_swizzle1 ¶

    vector4f64_swizzle1 :: proc "contextless" (v: Vector4f64, c0: Vector4_Components) -> f64 {…}

    vector4f64_swizzle2 ¶

    vector4f64_swizzle2 :: proc "contextless" (v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 {…}

    vector4f64_swizzle3 ¶

    vector4f64_swizzle3 :: proc "contextless" (v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 {…}

    vector4f64_swizzle4 ¶

    vector4f64_swizzle4 :: proc "contextless" (v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 {…}

    vector_cross2 ¶

    vector_cross2 :: proc "contextless" (a, b: $T/[2]$T) -> $T {…}

    vector_cross3 ¶

    vector_cross3 :: proc "contextless" (a, b: $T/[3]$T) -> (c: $T/[3]$T) {…}

    vector_dot ¶

    vector_dot :: proc "contextless" (a, b: $V/[0]$T) -> (c: $T) {…}

    vector_length ¶

    vector_length :: proc "contextless" (v: $V/[0]$T) -> $T {…}

    vector_length2 ¶

    vector_length2 :: proc "contextless" (v: $V/[0]$T) -> $T {…}

    vector_normalize ¶

    vector_normalize :: proc "contextless" (v: $V/[0]$T) -> $V/[0]$T {…}

    vector_normalize0 ¶

    vector_normalize0 :: proc "contextless" (v: $V/[0]$T) -> $V/[0]$T {…}

    vector_slerp ¶

    vector_slerp :: proc "contextless" (x, y: $V/[0]$T, a: $T) -> $V/[0]$T {…}

    vector_to_ptr ¶

    vector_to_ptr :: proc "contextless" (v: ^$V/[0]$T) -> ^$T {…}

    vector_triple_product ¶

    vector_triple_product :: proc "contextless" (a, b, c: $V/[0]$T) -> $V/[0]$T {…}

    yaw_from_quaternion_f16 ¶

    yaw_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 {…}

    yaw_from_quaternion_f32 ¶

    yaw_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 {…}

    yaw_from_quaternion_f64 ¶

    yaw_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 {…}

    Procedure Groups

    Source Files

    Generation Information

    Generated with odin version dev-2023-10 (vendor "odin") Windows_amd64 @ 2023-10-03 21:09:46.779559000 +0000 UTC