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

Collection Info

View Source
Collection
core
Path
math/linalg/hlsl
Entries
1289
Constants 13
Jump to Constants
DOUBLE_EPSILON e E FLOAT_EPSILON LN10 LN2 PI SQRT_FIVE SQRT_THREE SQRT_TWO TAU π τ
Types 87
Jump to Types
bool2 bool3 bool4 double double1x1 double1x2 double1x3 double1x4 double2 double2x1 double2x2 double2x3 double2x4 double3 double3x1 double3x2 +71 more
Procedures 1119
Jump to Procedures
abs_double abs_double2 abs_double3 abs_double4 abs_float abs_float2 abs_float3 abs_float4 abs_half abs_half2 abs_half3 abs_half4 abs_int abs_int2 abs_int3 abs_int4 +1103 more
Procedure Groups 70
Jump to Procedure Groups
abs acos acosh adjugate all any asdouble asfloat ashalf asin asinh asint asuint atan atan2 atanh +54 more
Variables 0

Source Files

Constants

13

SQRT_FIVE #

Source 
SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE #

Source 
SQRT_THREE :: 1.73205080756887729352744634150587236

Types

87

float1x1 #

Source 
float1x1 :: matrix[1, 1]f32

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

Procedures

1119

adjugate_matrix1x1 #

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

adjugate_matrix2x2 #

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

adjugate_matrix3x3 #

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

adjugate_matrix4x4 #

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

asdouble_double1x1 #

Source 
@(require_results)
asdouble_double1x1 :: proc "c" (v: matrix[1, 1]f64) -> matrix[1, 1]f64 {…}

asdouble_double1x2 #

Source 
@(require_results)
asdouble_double1x2 :: proc "c" (v: matrix[1, 2]f64) -> matrix[1, 2]f64 {…}

asdouble_double1x3 #

Source 
@(require_results)
asdouble_double1x3 :: proc "c" (v: matrix[1, 3]f64) -> matrix[1, 3]f64 {…}

asdouble_double1x4 #

Source 
@(require_results)
asdouble_double1x4 :: proc "c" (v: matrix[1, 4]f64) -> matrix[1, 4]f64 {…}

asdouble_double2 #

Source 
@(require_results)
asdouble_double2 :: proc "c" (v: [2]f64) -> [2]f64 {…}

asdouble_double2x1 #

Source 
@(require_results)
asdouble_double2x1 :: proc "c" (v: matrix[2, 1]f64) -> matrix[2, 1]f64 {…}

asdouble_double2x2 #

Source 
@(require_results)
asdouble_double2x2 :: proc "c" (v: matrix[2, 2]f64) -> matrix[2, 2]f64 {…}

asdouble_double2x3 #

Source 
@(require_results)
asdouble_double2x3 :: proc "c" (v: matrix[2, 3]f64) -> matrix[2, 3]f64 {…}

asdouble_double2x4 #

Source 
@(require_results)
asdouble_double2x4 :: proc "c" (v: matrix[2, 4]f64) -> matrix[2, 4]f64 {…}

asdouble_double3 #

Source 
@(require_results)
asdouble_double3 :: proc "c" (v: [3]f64) -> [3]f64 {…}

asdouble_double3x1 #

Source 
@(require_results)
asdouble_double3x1 :: proc "c" (v: matrix[3, 1]f64) -> matrix[3, 1]f64 {…}

asdouble_double3x2 #

Source 
@(require_results)
asdouble_double3x2 :: proc "c" (v: matrix[3, 2]f64) -> matrix[3, 2]f64 {…}

asdouble_double3x3 #

Source 
@(require_results)
asdouble_double3x3 :: proc "c" (v: matrix[3, 3]f64) -> matrix[3, 3]f64 {…}

asdouble_double3x4 #

Source 
@(require_results)
asdouble_double3x4 :: proc "c" (v: matrix[3, 4]f64) -> matrix[3, 4]f64 {…}

asdouble_double4 #

Source 
@(require_results)
asdouble_double4 :: proc "c" (v: [4]f64) -> [4]f64 {…}

asdouble_double4x1 #

Source 
@(require_results)
asdouble_double4x1 :: proc "c" (v: matrix[4, 1]f64) -> matrix[4, 1]f64 {…}

asdouble_double4x2 #

Source 
@(require_results)
asdouble_double4x2 :: proc "c" (v: matrix[4, 2]f64) -> matrix[4, 2]f64 {…}

asdouble_double4x3 #

Source 
@(require_results)
asdouble_double4x3 :: proc "c" (v: matrix[4, 3]f64) -> matrix[4, 3]f64 {…}

asdouble_double4x4 #

Source 
@(require_results)
asdouble_double4x4 :: proc "c" (v: matrix[4, 4]f64) -> matrix[4, 4]f64 {…}

asdouble_float1x1 #

Source 
@(require_results)
asdouble_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]f64 {…}

asdouble_float1x2 #

Source 
@(require_results)
asdouble_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]f64 {…}

asdouble_float1x3 #

Source 
@(require_results)
asdouble_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]f64 {…}

asdouble_float1x4 #

Source 
@(require_results)
asdouble_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]f64 {…}

asdouble_float2 #

Source 
@(require_results)
asdouble_float2 :: proc "c" (v: [2]f32) -> [2]f64 {…}

asdouble_float2x1 #

Source 
@(require_results)
asdouble_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]f64 {…}

asdouble_float2x2 #

Source 
@(require_results)
asdouble_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]f64 {…}

asdouble_float2x3 #

Source 
@(require_results)
asdouble_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]f64 {…}

asdouble_float2x4 #

Source 
@(require_results)
asdouble_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]f64 {…}

asdouble_float3 #

Source 
@(require_results)
asdouble_float3 :: proc "c" (v: [3]f32) -> [3]f64 {…}

asdouble_float3x1 #

Source 
@(require_results)
asdouble_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]f64 {…}

asdouble_float3x2 #

Source 
@(require_results)
asdouble_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]f64 {…}

asdouble_float3x3 #

Source 
@(require_results)
asdouble_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]f64 {…}

asdouble_float3x4 #

Source 
@(require_results)
asdouble_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]f64 {…}

asdouble_float4 #

Source 
@(require_results)
asdouble_float4 :: proc "c" (v: [4]f32) -> [4]f64 {…}

asdouble_float4x1 #

Source 
@(require_results)
asdouble_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]f64 {…}

asdouble_float4x2 #

Source 
@(require_results)
asdouble_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]f64 {…}

asdouble_float4x3 #

Source 
@(require_results)
asdouble_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]f64 {…}

asdouble_float4x4 #

Source 
@(require_results)
asdouble_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]f64 {…}

asdouble_half1x1 #

Source 
@(require_results)
asdouble_half1x1 :: proc "c" (v: matrix[1, 1]f16) -> matrix[1, 1]f64 {…}

asdouble_half1x2 #

Source 
@(require_results)
asdouble_half1x2 :: proc "c" (v: matrix[1, 2]f16) -> matrix[1, 2]f64 {…}

asdouble_half1x3 #

Source 
@(require_results)
asdouble_half1x3 :: proc "c" (v: matrix[1, 3]f16) -> matrix[1, 3]f64 {…}

asdouble_half1x4 #

Source 
@(require_results)
asdouble_half1x4 :: proc "c" (v: matrix[1, 4]f16) -> matrix[1, 4]f64 {…}

asdouble_half2x1 #

Source 
@(require_results)
asdouble_half2x1 :: proc "c" (v: matrix[2, 1]f16) -> matrix[2, 1]f64 {…}

asdouble_half2x2 #

Source 
@(require_results)
asdouble_half2x2 :: proc "c" (v: matrix[2, 2]f16) -> matrix[2, 2]f64 {…}

asdouble_half2x3 #

Source 
@(require_results)
asdouble_half2x3 :: proc "c" (v: matrix[2, 3]f16) -> matrix[2, 3]f64 {…}

asdouble_half2x4 #

Source 
@(require_results)
asdouble_half2x4 :: proc "c" (v: matrix[2, 4]f16) -> matrix[2, 4]f64 {…}

asdouble_half3x1 #

Source 
@(require_results)
asdouble_half3x1 :: proc "c" (v: matrix[3, 1]f16) -> matrix[3, 1]f64 {…}

asdouble_half3x2 #

Source 
@(require_results)
asdouble_half3x2 :: proc "c" (v: matrix[3, 2]f16) -> matrix[3, 2]f64 {…}

asdouble_half3x3 #

Source 
@(require_results)
asdouble_half3x3 :: proc "c" (v: matrix[3, 3]f16) -> matrix[3, 3]f64 {…}

asdouble_half3x4 #

Source 
@(require_results)
asdouble_half3x4 :: proc "c" (v: matrix[3, 4]f16) -> matrix[3, 4]f64 {…}

asdouble_half4x1 #

Source 
@(require_results)
asdouble_half4x1 :: proc "c" (v: matrix[4, 1]f16) -> matrix[4, 1]f64 {…}

asdouble_half4x2 #

Source 
@(require_results)
asdouble_half4x2 :: proc "c" (v: matrix[4, 2]f16) -> matrix[4, 2]f64 {…}

asdouble_half4x3 #

Source 
@(require_results)
asdouble_half4x3 :: proc "c" (v: matrix[4, 3]f16) -> matrix[4, 3]f64 {…}

asdouble_half4x4 #

Source 
@(require_results)
asdouble_half4x4 :: proc "c" (v: matrix[4, 4]f16) -> matrix[4, 4]f64 {…}

asfloat_double1x1 #

Source 
@(require_results)
asfloat_double1x1 :: proc "c" (v: matrix[1, 1]f64) -> matrix[1, 1]f32 {…}

asfloat_double1x2 #

Source 
@(require_results)
asfloat_double1x2 :: proc "c" (v: matrix[1, 2]f64) -> matrix[1, 2]f32 {…}

asfloat_double1x3 #

Source 
@(require_results)
asfloat_double1x3 :: proc "c" (v: matrix[1, 3]f64) -> matrix[1, 3]f32 {…}

asfloat_double1x4 #

Source 
@(require_results)
asfloat_double1x4 :: proc "c" (v: matrix[1, 4]f64) -> matrix[1, 4]f32 {…}

asfloat_double2 #

Source 
@(require_results)
asfloat_double2 :: proc "c" (v: [2]f64) -> [2]f32 {…}

asfloat_double2x1 #

Source 
@(require_results)
asfloat_double2x1 :: proc "c" (v: matrix[2, 1]f64) -> matrix[2, 1]f32 {…}

asfloat_double2x2 #

Source 
@(require_results)
asfloat_double2x2 :: proc "c" (v: matrix[2, 2]f64) -> matrix[2, 2]f32 {…}

asfloat_double2x3 #

Source 
@(require_results)
asfloat_double2x3 :: proc "c" (v: matrix[2, 3]f64) -> matrix[2, 3]f32 {…}

asfloat_double2x4 #

Source 
@(require_results)
asfloat_double2x4 :: proc "c" (v: matrix[2, 4]f64) -> matrix[2, 4]f32 {…}

asfloat_double3 #

Source 
@(require_results)
asfloat_double3 :: proc "c" (v: [3]f64) -> [3]f32 {…}

asfloat_double3x1 #

Source 
@(require_results)
asfloat_double3x1 :: proc "c" (v: matrix[3, 1]f64) -> matrix[3, 1]f32 {…}

asfloat_double3x2 #

Source 
@(require_results)
asfloat_double3x2 :: proc "c" (v: matrix[3, 2]f64) -> matrix[3, 2]f32 {…}

asfloat_double3x3 #

Source 
@(require_results)
asfloat_double3x3 :: proc "c" (v: matrix[3, 3]f64) -> matrix[3, 3]f32 {…}

asfloat_double3x4 #

Source 
@(require_results)
asfloat_double3x4 :: proc "c" (v: matrix[3, 4]f64) -> matrix[3, 4]f32 {…}

asfloat_double4 #

Source 
@(require_results)
asfloat_double4 :: proc "c" (v: [4]f64) -> [4]f32 {…}

asfloat_double4x1 #

Source 
@(require_results)
asfloat_double4x1 :: proc "c" (v: matrix[4, 1]f64) -> matrix[4, 1]f32 {…}

asfloat_double4x2 #

Source 
@(require_results)
asfloat_double4x2 :: proc "c" (v: matrix[4, 2]f64) -> matrix[4, 2]f32 {…}

asfloat_double4x3 #

Source 
@(require_results)
asfloat_double4x3 :: proc "c" (v: matrix[4, 3]f64) -> matrix[4, 3]f32 {…}

asfloat_double4x4 #

Source 
@(require_results)
asfloat_double4x4 :: proc "c" (v: matrix[4, 4]f64) -> matrix[4, 4]f32 {…}

asfloat_float1x1 #

Source 
@(require_results)
asfloat_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]f32 {…}

asfloat_float1x2 #

Source 
@(require_results)
asfloat_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]f32 {…}

asfloat_float1x3 #

Source 
@(require_results)
asfloat_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]f32 {…}

asfloat_float1x4 #

Source 
@(require_results)
asfloat_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]f32 {…}

asfloat_float2x1 #

Source 
@(require_results)
asfloat_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]f32 {…}

asfloat_float2x2 #

Source 
@(require_results)
asfloat_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]f32 {…}

asfloat_float2x3 #

Source 
@(require_results)
asfloat_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]f32 {…}

asfloat_float2x4 #

Source 
@(require_results)
asfloat_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]f32 {…}

asfloat_float3x1 #

Source 
@(require_results)
asfloat_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]f32 {…}

asfloat_float3x2 #

Source 
@(require_results)
asfloat_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]f32 {…}

asfloat_float3x3 #

Source 
@(require_results)
asfloat_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]f32 {…}

asfloat_float3x4 #

Source 
@(require_results)
asfloat_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]f32 {…}

asfloat_float4x1 #

Source 
@(require_results)
asfloat_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]f32 {…}

asfloat_float4x2 #

Source 
@(require_results)
asfloat_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]f32 {…}

asfloat_float4x3 #

Source 
@(require_results)
asfloat_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]f32 {…}

asfloat_float4x4 #

Source 
@(require_results)
asfloat_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

asfloat_half1x1 #

Source 
@(require_results)
asfloat_half1x1 :: proc "c" (v: matrix[1, 1]f16) -> matrix[1, 1]f32 {…}

asfloat_half1x2 #

Source 
@(require_results)
asfloat_half1x2 :: proc "c" (v: matrix[1, 2]f16) -> matrix[1, 2]f32 {…}

asfloat_half1x3 #

Source 
@(require_results)
asfloat_half1x3 :: proc "c" (v: matrix[1, 3]f16) -> matrix[1, 3]f32 {…}

asfloat_half1x4 #

Source 
@(require_results)
asfloat_half1x4 :: proc "c" (v: matrix[1, 4]f16) -> matrix[1, 4]f32 {…}

asfloat_half2x1 #

Source 
@(require_results)
asfloat_half2x1 :: proc "c" (v: matrix[2, 1]f16) -> matrix[2, 1]f32 {…}

asfloat_half2x2 #

Source 
@(require_results)
asfloat_half2x2 :: proc "c" (v: matrix[2, 2]f16) -> matrix[2, 2]f32 {…}

asfloat_half2x3 #

Source 
@(require_results)
asfloat_half2x3 :: proc "c" (v: matrix[2, 3]f16) -> matrix[2, 3]f32 {…}

asfloat_half2x4 #

Source 
@(require_results)
asfloat_half2x4 :: proc "c" (v: matrix[2, 4]f16) -> matrix[2, 4]f32 {…}

asfloat_half3x1 #

Source 
@(require_results)
asfloat_half3x1 :: proc "c" (v: matrix[3, 1]f16) -> matrix[3, 1]f32 {…}

asfloat_half3x2 #

Source 
@(require_results)
asfloat_half3x2 :: proc "c" (v: matrix[3, 2]f16) -> matrix[3, 2]f32 {…}

asfloat_half3x3 #

Source 
@(require_results)
asfloat_half3x3 :: proc "c" (v: matrix[3, 3]f16) -> matrix[3, 3]f32 {…}

asfloat_half3x4 #

Source 
@(require_results)
asfloat_half3x4 :: proc "c" (v: matrix[3, 4]f16) -> matrix[3, 4]f32 {…}

asfloat_half4x1 #

Source 
@(require_results)
asfloat_half4x1 :: proc "c" (v: matrix[4, 1]f16) -> matrix[4, 1]f32 {…}

asfloat_half4x2 #

Source 
@(require_results)
asfloat_half4x2 :: proc "c" (v: matrix[4, 2]f16) -> matrix[4, 2]f32 {…}

asfloat_half4x3 #

Source 
@(require_results)
asfloat_half4x3 :: proc "c" (v: matrix[4, 3]f16) -> matrix[4, 3]f32 {…}

asfloat_half4x4 #

Source 
@(require_results)
asfloat_half4x4 :: proc "c" (v: matrix[4, 4]f16) -> matrix[4, 4]f32 {…}

ashalf_double1x1 #

Source 
@(require_results)
ashalf_double1x1 :: proc "c" (v: matrix[1, 1]f64) -> matrix[1, 1]f16 {…}

ashalf_double1x2 #

Source 
@(require_results)
ashalf_double1x2 :: proc "c" (v: matrix[1, 2]f64) -> matrix[1, 2]f16 {…}

ashalf_double1x3 #

Source 
@(require_results)
ashalf_double1x3 :: proc "c" (v: matrix[1, 3]f64) -> matrix[1, 3]f16 {…}

ashalf_double1x4 #

Source 
@(require_results)
ashalf_double1x4 :: proc "c" (v: matrix[1, 4]f64) -> matrix[1, 4]f16 {…}

ashalf_double2x1 #

Source 
@(require_results)
ashalf_double2x1 :: proc "c" (v: matrix[2, 1]f64) -> matrix[2, 1]f16 {…}

ashalf_double2x2 #

Source 
@(require_results)
ashalf_double2x2 :: proc "c" (v: matrix[2, 2]f64) -> matrix[2, 2]f16 {…}

ashalf_double2x3 #

Source 
@(require_results)
ashalf_double2x3 :: proc "c" (v: matrix[2, 3]f64) -> matrix[2, 3]f16 {…}

ashalf_double2x4 #

Source 
@(require_results)
ashalf_double2x4 :: proc "c" (v: matrix[2, 4]f64) -> matrix[2, 4]f16 {…}

ashalf_double3x1 #

Source 
@(require_results)
ashalf_double3x1 :: proc "c" (v: matrix[3, 1]f64) -> matrix[3, 1]f16 {…}

ashalf_double3x2 #

Source 
@(require_results)
ashalf_double3x2 :: proc "c" (v: matrix[3, 2]f64) -> matrix[3, 2]f16 {…}

ashalf_double3x3 #

Source 
@(require_results)
ashalf_double3x3 :: proc "c" (v: matrix[3, 3]f64) -> matrix[3, 3]f16 {…}

ashalf_double3x4 #

Source 
@(require_results)
ashalf_double3x4 :: proc "c" (v: matrix[3, 4]f64) -> matrix[3, 4]f16 {…}

ashalf_double4x1 #

Source 
@(require_results)
ashalf_double4x1 :: proc "c" (v: matrix[4, 1]f64) -> matrix[4, 1]f16 {…}

ashalf_double4x2 #

Source 
@(require_results)
ashalf_double4x2 :: proc "c" (v: matrix[4, 2]f64) -> matrix[4, 2]f16 {…}

ashalf_double4x3 #

Source 
@(require_results)
ashalf_double4x3 :: proc "c" (v: matrix[4, 3]f64) -> matrix[4, 3]f16 {…}

ashalf_double4x4 #

Source 
@(require_results)
ashalf_double4x4 :: proc "c" (v: matrix[4, 4]f64) -> matrix[4, 4]f16 {…}

ashalf_float1x1 #

Source 
@(require_results)
ashalf_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]f16 {…}

ashalf_float1x2 #

Source 
@(require_results)
ashalf_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]f16 {…}

ashalf_float1x3 #

Source 
@(require_results)
ashalf_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]f16 {…}

ashalf_float1x4 #

Source 
@(require_results)
ashalf_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]f16 {…}

ashalf_float2x1 #

Source 
@(require_results)
ashalf_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]f16 {…}

ashalf_float2x2 #

Source 
@(require_results)
ashalf_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]f16 {…}

ashalf_float2x3 #

Source 
@(require_results)
ashalf_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]f16 {…}

ashalf_float2x4 #

Source 
@(require_results)
ashalf_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]f16 {…}

ashalf_float3x1 #

Source 
@(require_results)
ashalf_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]f16 {…}

ashalf_float3x2 #

Source 
@(require_results)
ashalf_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]f16 {…}

ashalf_float3x3 #

Source 
@(require_results)
ashalf_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]f16 {…}

ashalf_float3x4 #

Source 
@(require_results)
ashalf_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]f16 {…}

ashalf_float4x1 #

Source 
@(require_results)
ashalf_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]f16 {…}

ashalf_float4x2 #

Source 
@(require_results)
ashalf_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]f16 {…}

ashalf_float4x3 #

Source 
@(require_results)
ashalf_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]f16 {…}

ashalf_float4x4 #

Source 
@(require_results)
ashalf_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]f16 {…}

ashalf_half1x1 #

Source 
@(require_results)
ashalf_half1x1 :: proc "c" (v: matrix[1, 1]f16) -> matrix[1, 1]f16 {…}

ashalf_half1x2 #

Source 
@(require_results)
ashalf_half1x2 :: proc "c" (v: matrix[1, 2]f16) -> matrix[1, 2]f16 {…}

ashalf_half1x3 #

Source 
@(require_results)
ashalf_half1x3 :: proc "c" (v: matrix[1, 3]f16) -> matrix[1, 3]f16 {…}

ashalf_half1x4 #

Source 
@(require_results)
ashalf_half1x4 :: proc "c" (v: matrix[1, 4]f16) -> matrix[1, 4]f16 {…}

ashalf_half2x1 #

Source 
@(require_results)
ashalf_half2x1 :: proc "c" (v: matrix[2, 1]f16) -> matrix[2, 1]f16 {…}

ashalf_half2x2 #

Source 
@(require_results)
ashalf_half2x2 :: proc "c" (v: matrix[2, 2]f16) -> matrix[2, 2]f16 {…}

ashalf_half2x3 #

Source 
@(require_results)
ashalf_half2x3 :: proc "c" (v: matrix[2, 3]f16) -> matrix[2, 3]f16 {…}

ashalf_half2x4 #

Source 
@(require_results)
ashalf_half2x4 :: proc "c" (v: matrix[2, 4]f16) -> matrix[2, 4]f16 {…}

ashalf_half3x1 #

Source 
@(require_results)
ashalf_half3x1 :: proc "c" (v: matrix[3, 1]f16) -> matrix[3, 1]f16 {…}

ashalf_half3x2 #

Source 
@(require_results)
ashalf_half3x2 :: proc "c" (v: matrix[3, 2]f16) -> matrix[3, 2]f16 {…}

ashalf_half3x3 #

Source 
@(require_results)
ashalf_half3x3 :: proc "c" (v: matrix[3, 3]f16) -> matrix[3, 3]f16 {…}

ashalf_half3x4 #

Source 
@(require_results)
ashalf_half3x4 :: proc "c" (v: matrix[3, 4]f16) -> matrix[3, 4]f16 {…}

ashalf_half4x1 #

Source 
@(require_results)
ashalf_half4x1 :: proc "c" (v: matrix[4, 1]f16) -> matrix[4, 1]f16 {…}

ashalf_half4x2 #

Source 
@(require_results)
ashalf_half4x2 :: proc "c" (v: matrix[4, 2]f16) -> matrix[4, 2]f16 {…}

ashalf_half4x3 #

Source 
@(require_results)
ashalf_half4x3 :: proc "c" (v: matrix[4, 3]f16) -> matrix[4, 3]f16 {…}

ashalf_half4x4 #

Source 
@(require_results)
ashalf_half4x4 :: proc "c" (v: matrix[4, 4]f16) -> matrix[4, 4]f16 {…}

asint_double1x1 #

Source 
@(require_results)
asint_double1x1 :: proc "c" (v: matrix[1, 1]f64) -> matrix[1, 1]i32 {…}

asint_double1x2 #

Source 
@(require_results)
asint_double1x2 :: proc "c" (v: matrix[1, 2]f64) -> matrix[1, 2]i32 {…}

asint_double1x3 #

Source 
@(require_results)
asint_double1x3 :: proc "c" (v: matrix[1, 3]f64) -> matrix[1, 3]i32 {…}

asint_double1x4 #

Source 
@(require_results)
asint_double1x4 :: proc "c" (v: matrix[1, 4]f64) -> matrix[1, 4]i32 {…}

asint_double2x1 #

Source 
@(require_results)
asint_double2x1 :: proc "c" (v: matrix[2, 1]f64) -> matrix[2, 1]i32 {…}

asint_double2x2 #

Source 
@(require_results)
asint_double2x2 :: proc "c" (v: matrix[2, 2]f64) -> matrix[2, 2]i32 {…}

asint_double2x3 #

Source 
@(require_results)
asint_double2x3 :: proc "c" (v: matrix[2, 3]f64) -> matrix[2, 3]i32 {…}

asint_double2x4 #

Source 
@(require_results)
asint_double2x4 :: proc "c" (v: matrix[2, 4]f64) -> matrix[2, 4]i32 {…}

asint_double3x1 #

Source 
@(require_results)
asint_double3x1 :: proc "c" (v: matrix[3, 1]f64) -> matrix[3, 1]i32 {…}

asint_double3x2 #

Source 
@(require_results)
asint_double3x2 :: proc "c" (v: matrix[3, 2]f64) -> matrix[3, 2]i32 {…}

asint_double3x3 #

Source 
@(require_results)
asint_double3x3 :: proc "c" (v: matrix[3, 3]f64) -> matrix[3, 3]i32 {…}

asint_double3x4 #

Source 
@(require_results)
asint_double3x4 :: proc "c" (v: matrix[3, 4]f64) -> matrix[3, 4]i32 {…}

asint_double4x1 #

Source 
@(require_results)
asint_double4x1 :: proc "c" (v: matrix[4, 1]f64) -> matrix[4, 1]i32 {…}

asint_double4x2 #

Source 
@(require_results)
asint_double4x2 :: proc "c" (v: matrix[4, 2]f64) -> matrix[4, 2]i32 {…}

asint_double4x3 #

Source 
@(require_results)
asint_double4x3 :: proc "c" (v: matrix[4, 3]f64) -> matrix[4, 3]i32 {…}

asint_double4x4 #

Source 
@(require_results)
asint_double4x4 :: proc "c" (v: matrix[4, 4]f64) -> matrix[4, 4]i32 {…}

asint_float1x1 #

Source 
@(require_results)
asint_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]i32 {…}

asint_float1x2 #

Source 
@(require_results)
asint_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]i32 {…}

asint_float1x3 #

Source 
@(require_results)
asint_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]i32 {…}

asint_float1x4 #

Source 
@(require_results)
asint_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]i32 {…}

asint_float2x1 #

Source 
@(require_results)
asint_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]i32 {…}

asint_float2x2 #

Source 
@(require_results)
asint_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]i32 {…}

asint_float2x3 #

Source 
@(require_results)
asint_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]i32 {…}

asint_float2x4 #

Source 
@(require_results)
asint_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]i32 {…}

asint_float3x1 #

Source 
@(require_results)
asint_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]i32 {…}

asint_float3x2 #

Source 
@(require_results)
asint_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]i32 {…}

asint_float3x3 #

Source 
@(require_results)
asint_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]i32 {…}

asint_float3x4 #

Source 
@(require_results)
asint_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]i32 {…}

asint_float4x1 #

Source 
@(require_results)
asint_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]i32 {…}

asint_float4x2 #

Source 
@(require_results)
asint_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]i32 {…}

asint_float4x3 #

Source 
@(require_results)
asint_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]i32 {…}

asint_float4x4 #

Source 
@(require_results)
asint_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]i32 {…}

asint_half1x1 #

Source 
@(require_results)
asint_half1x1 :: proc "c" (v: matrix[1, 1]f16) -> matrix[1, 1]i32 {…}

asint_half1x2 #

Source 
@(require_results)
asint_half1x2 :: proc "c" (v: matrix[1, 2]f16) -> matrix[1, 2]i32 {…}

asint_half1x3 #

Source 
@(require_results)
asint_half1x3 :: proc "c" (v: matrix[1, 3]f16) -> matrix[1, 3]i32 {…}

asint_half1x4 #

Source 
@(require_results)
asint_half1x4 :: proc "c" (v: matrix[1, 4]f16) -> matrix[1, 4]i32 {…}

asint_half2x1 #

Source 
@(require_results)
asint_half2x1 :: proc "c" (v: matrix[2, 1]f16) -> matrix[2, 1]i32 {…}

asint_half2x2 #

Source 
@(require_results)
asint_half2x2 :: proc "c" (v: matrix[2, 2]f16) -> matrix[2, 2]i32 {…}

asint_half2x3 #

Source 
@(require_results)
asint_half2x3 :: proc "c" (v: matrix[2, 3]f16) -> matrix[2, 3]i32 {…}

asint_half2x4 #

Source 
@(require_results)
asint_half2x4 :: proc "c" (v: matrix[2, 4]f16) -> matrix[2, 4]i32 {…}

asint_half3x1 #

Source 
@(require_results)
asint_half3x1 :: proc "c" (v: matrix[3, 1]f16) -> matrix[3, 1]i32 {…}

asint_half3x2 #

Source 
@(require_results)
asint_half3x2 :: proc "c" (v: matrix[3, 2]f16) -> matrix[3, 2]i32 {…}

asint_half3x3 #

Source 
@(require_results)
asint_half3x3 :: proc "c" (v: matrix[3, 3]f16) -> matrix[3, 3]i32 {…}

asint_half3x4 #

Source 
@(require_results)
asint_half3x4 :: proc "c" (v: matrix[3, 4]f16) -> matrix[3, 4]i32 {…}

asint_half4x1 #

Source 
@(require_results)
asint_half4x1 :: proc "c" (v: matrix[4, 1]f16) -> matrix[4, 1]i32 {…}

asint_half4x2 #

Source 
@(require_results)
asint_half4x2 :: proc "c" (v: matrix[4, 2]f16) -> matrix[4, 2]i32 {…}

asint_half4x3 #

Source 
@(require_results)
asint_half4x3 :: proc "c" (v: matrix[4, 3]f16) -> matrix[4, 3]i32 {…}

asint_half4x4 #

Source 
@(require_results)
asint_half4x4 :: proc "c" (v: matrix[4, 4]f16) -> matrix[4, 4]i32 {…}

clamp_double2 #

Source 
@(require_results)
clamp_double2 :: proc "c" (x, y, z: [2]f64) -> [2]f64 {…}

clamp_double3 #

Source 
@(require_results)
clamp_double3 :: proc "c" (x, y, z: [3]f64) -> [3]f64 {…}

clamp_double4 #

Source 
@(require_results)
clamp_double4 :: proc "c" (x, y, z: [4]f64) -> [4]f64 {…}

clamp_float2 #

Source 
@(require_results)
clamp_float2 :: proc "c" (x, y, z: [2]f32) -> [2]f32 {…}

clamp_float3 #

Source 
@(require_results)
clamp_float3 :: proc "c" (x, y, z: [3]f32) -> [3]f32 {…}

clamp_float4 #

Source 
@(require_results)
clamp_float4 :: proc "c" (x, y, z: [4]f32) -> [4]f32 {…}

cofactor_matrix1x1 #

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

cofactor_matrix2x2 #

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

cofactor_matrix3x3 #

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

cofactor_matrix4x4 #

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

cross_double3 #

Source 
@(require_results)
cross_double3 :: proc "c" (a, b: [3]f64) -> (c: [3]f64) {…}

cross_float3 #

Source 
@(require_results)
cross_float3 :: proc "c" (a, b: [3]f32) -> (c: [3]f32) {…}

cross_half3 #

Source 
@(require_results)
cross_half3 :: proc "c" (a, b: [3]f16) -> (c: [3]f16) {…}

degrees_double2 #

Source 
@(require_results)
degrees_double2 :: proc "c" (radians: [2]f64) -> [2]f64 {…}

degrees_double3 #

Source 
@(require_results)
degrees_double3 :: proc "c" (radians: [3]f64) -> [3]f64 {…}

degrees_double4 #

Source 
@(require_results)
degrees_double4 :: proc "c" (radians: [4]f64) -> [4]f64 {…}

degrees_float2 #

Source 
@(require_results)
degrees_float2 :: proc "c" (radians: [2]f32) -> [2]f32 {…}

degrees_float3 #

Source 
@(require_results)
degrees_float3 :: proc "c" (radians: [3]f32) -> [3]f32 {…}

degrees_float4 #

Source 
@(require_results)
degrees_float4 :: proc "c" (radians: [4]f32) -> [4]f32 {…}

degrees_half2 #

Source 
@(require_results)
degrees_half2 :: proc "c" (radians: [2]f16) -> [2]f16 {…}

degrees_half3 #

Source 
@(require_results)
degrees_half3 :: proc "c" (radians: [3]f16) -> [3]f16 {…}

degrees_half4 #

Source 
@(require_results)
degrees_half4 :: proc "c" (radians: [4]f16) -> [4]f16 {…}

determinant_matrix1x1 #

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

determinant_matrix2x2 #

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

determinant_matrix3x3 #

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

determinant_matrix4x4 #

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

distance_double2 #

Source 
@(require_results)
distance_double2 :: proc "c" (x, y: [2]f64) -> f64 {…}

distance_double3 #

Source 
@(require_results)
distance_double3 :: proc "c" (x, y: [3]f64) -> f64 {…}

distance_double4 #

Source 
@(require_results)
distance_double4 :: proc "c" (x, y: [4]f64) -> f64 {…}

distance_float2 #

Source 
@(require_results)
distance_float2 :: proc "c" (x, y: [2]f32) -> f32 {…}

distance_float3 #

Source 
@(require_results)
distance_float3 :: proc "c" (x, y: [3]f32) -> f32 {…}

distance_float4 #

Source 
@(require_results)
distance_float4 :: proc "c" (x, y: [4]f32) -> f32 {…}

faceforward_double #

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

faceforward_double2 #

Source 
@(require_results)
faceforward_double2 :: proc "c" (N, I, Nref: [2]f64) -> [2]f64 {…}

faceforward_double3 #

Source 
@(require_results)
faceforward_double3 :: proc "c" (N, I, Nref: [3]f64) -> [3]f64 {…}

faceforward_double4 #

Source 
@(require_results)
faceforward_double4 :: proc "c" (N, I, Nref: [4]f64) -> [4]f64 {…}

faceforward_float #

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

faceforward_float2 #

Source 
@(require_results)
faceforward_float2 :: proc "c" (N, I, Nref: [2]f32) -> [2]f32 {…}

faceforward_float3 #

Source 
@(require_results)
faceforward_float3 :: proc "c" (N, I, Nref: [3]f32) -> [3]f32 {…}

faceforward_float4 #

Source 
@(require_results)
faceforward_float4 :: proc "c" (N, I, Nref: [4]f32) -> [4]f32 {…}

faceforward_half #

Source 
@(require_results)
faceforward_half :: proc "c" (N, I, Nref: f16) -> f16 {…}

faceforward_half2 #

Source 
@(require_results)
faceforward_half2 :: proc "c" (N, I, Nref: [2]f16) -> [2]f16 {…}

faceforward_half3 #

Source 
@(require_results)
faceforward_half3 :: proc "c" (N, I, Nref: [3]f16) -> [3]f16 {…}

faceforward_half4 #

Source 
@(require_results)
faceforward_half4 :: proc "c" (N, I, Nref: [4]f16) -> [4]f16 {…}

greaterThan_double2 #

Source 
@(require_results)
greaterThan_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

greaterThan_double3 #

Source 
@(require_results)
greaterThan_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

greaterThan_double4 #

Source 
@(require_results)
greaterThan_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

greaterThan_float2 #

Source 
@(require_results)
greaterThan_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

greaterThan_float3 #

Source 
@(require_results)
greaterThan_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

greaterThan_float4 #

Source 
@(require_results)
greaterThan_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

greaterThan_half2 #

Source 
@(require_results)
greaterThan_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}

greaterThan_half3 #

Source 
@(require_results)
greaterThan_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}

greaterThan_half4 #

Source 
@(require_results)
greaterThan_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}

greaterThan_int2 #

Source 
@(require_results)
greaterThan_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

greaterThan_int3 #

Source 
@(require_results)
greaterThan_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

greaterThan_int4 #

Source 
@(require_results)
greaterThan_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

greaterThan_uint2 #

Source 
@(require_results)
greaterThan_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

greaterThan_uint3 #

Source 
@(require_results)
greaterThan_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

greaterThan_uint4 #

Source 
@(require_results)
greaterThan_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

greaterThanEqual_double #

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

greaterThanEqual_double2 #

Source 
@(require_results)
greaterThanEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

greaterThanEqual_double3 #

Source 
@(require_results)
greaterThanEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

greaterThanEqual_double4 #

Source 
@(require_results)
greaterThanEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

greaterThanEqual_float #

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

greaterThanEqual_float2 #

Source 
@(require_results)
greaterThanEqual_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

greaterThanEqual_float3 #

Source 
@(require_results)
greaterThanEqual_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

greaterThanEqual_float4 #

Source 
@(require_results)
greaterThanEqual_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

greaterThanEqual_half #

Source 
@(require_results)
greaterThanEqual_half :: proc "c" (a, b: f16) -> bool {…}

greaterThanEqual_half2 #

Source 
@(require_results)
greaterThanEqual_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}

greaterThanEqual_half3 #

Source 
@(require_results)
greaterThanEqual_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}

greaterThanEqual_half4 #

Source 
@(require_results)
greaterThanEqual_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}

greaterThanEqual_int #

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

greaterThanEqual_int2 #

Source 
@(require_results)
greaterThanEqual_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

greaterThanEqual_int3 #

Source 
@(require_results)
greaterThanEqual_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

greaterThanEqual_int4 #

Source 
@(require_results)
greaterThanEqual_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

greaterThanEqual_uint #

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

greaterThanEqual_uint2 #

Source 
@(require_results)
greaterThanEqual_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

greaterThanEqual_uint3 #

Source 
@(require_results)
greaterThanEqual_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

greaterThanEqual_uint4 #

Source 
@(require_results)
greaterThanEqual_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

hermitian_adjoint #

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

inverse_double1x1 #

Source 
@(require_results)
inverse_double1x1 :: proc "c" (m: matrix[1, 1]f64) -> matrix[1, 1]f64 {…}

inverse_double2x2 #

Source 
@(require_results)
inverse_double2x2 :: proc "c" (m: matrix[2, 2]f64) -> matrix[2, 2]f64 {…}

inverse_double3x3 #

Source 
@(require_results)
inverse_double3x3 :: proc "c" (m: matrix[3, 3]f64) -> matrix[3, 3]f64 {…}

inverse_double4x4 #

Source 
@(require_results)
inverse_double4x4 :: proc "c" (m: matrix[4, 4]f64) -> matrix[4, 4]f64 {…}

inverse_float1x1 #

Source 
@(require_results)
inverse_float1x1 :: proc "c" (m: matrix[1, 1]f32) -> matrix[1, 1]f32 {…}

inverse_float2x2 #

Source 
@(require_results)
inverse_float2x2 :: proc "c" (m: matrix[2, 2]f32) -> matrix[2, 2]f32 {…}

inverse_float3x3 #

Source 
@(require_results)
inverse_float3x3 :: proc "c" (m: matrix[3, 3]f32) -> matrix[3, 3]f32 {…}

inverse_float4x4 #

Source 
@(require_results)
inverse_float4x4 :: proc "c" (m: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

inverse_half1x1 #

Source 
@(require_results)
inverse_half1x1 :: proc "c" (m: matrix[1, 1]f16) -> matrix[1, 1]f16 {…}

inverse_half2x2 #

Source 
@(require_results)
inverse_half2x2 :: proc "c" (m: matrix[2, 2]f16) -> matrix[2, 2]f16 {…}

inverse_half3x3 #

Source 
@(require_results)
inverse_half3x3 :: proc "c" (m: matrix[3, 3]f16) -> matrix[3, 3]f16 {…}

inverse_half4x4 #

Source 
@(require_results)
inverse_half4x4 :: proc "c" (m: matrix[4, 4]f16) -> matrix[4, 4]f16 {…}

inverse_matrix1x1 #

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

inverse_matrix2x2 #

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

inverse_matrix3x3 #

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

inverse_matrix4x4 #

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

inverse_transpose_matrix1x1 #

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

inverse_transpose_matrix2x2 #

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

inverse_transpose_matrix3x3 #

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

inverse_transpose_matrix4x4 #

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

lerp_double2 #

Source 
@(require_results)
lerp_double2 :: proc "c" (x, y, t: [2]f64) -> [2]f64 {…}

lerp_double3 #

Source 
@(require_results)
lerp_double3 :: proc "c" (x, y, t: [3]f64) -> [3]f64 {…}

lerp_double4 #

Source 
@(require_results)
lerp_double4 :: proc "c" (x, y, t: [4]f64) -> [4]f64 {…}

lessThan_double2 #

Source 
@(require_results)
lessThan_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

lessThan_double3 #

Source 
@(require_results)
lessThan_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

lessThan_double4 #

Source 
@(require_results)
lessThan_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

lessThanEqual_double #

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

lessThanEqual_double2 #

Source 
@(require_results)
lessThanEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

lessThanEqual_double3 #

Source 
@(require_results)
lessThanEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

lessThanEqual_double4 #

Source 
@(require_results)
lessThanEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

lessThanEqual_float #

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

lessThanEqual_float2 #

Source 
@(require_results)
lessThanEqual_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}

lessThanEqual_float3 #

Source 
@(require_results)
lessThanEqual_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}

lessThanEqual_float4 #

Source 
@(require_results)
lessThanEqual_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}

lessThanEqual_half2 #

Source 
@(require_results)
lessThanEqual_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}

lessThanEqual_half3 #

Source 
@(require_results)
lessThanEqual_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}

lessThanEqual_half4 #

Source 
@(require_results)
lessThanEqual_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}

lessThanEqual_int2 #

Source 
@(require_results)
lessThanEqual_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}

lessThanEqual_int3 #

Source 
@(require_results)
lessThanEqual_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}

lessThanEqual_int4 #

Source 
@(require_results)
lessThanEqual_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}

lessThanEqual_uint2 #

Source 
@(require_results)
lessThanEqual_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}

lessThanEqual_uint3 #

Source 
@(require_results)
lessThanEqual_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}

lessThanEqual_uint4 #

Source 
@(require_results)
lessThanEqual_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}

matrix_minor #

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

normalize_double2 #

Source 
@(require_results)
normalize_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}

normalize_double3 #

Source 
@(require_results)
normalize_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}

normalize_double4 #

Source 
@(require_results)
normalize_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}

normalize_float2 #

Source 
@(require_results)
normalize_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}

normalize_float3 #

Source 
@(require_results)
normalize_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}

normalize_float4 #

Source 
@(require_results)
normalize_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}

normalize_half2 #

Source 
@(require_results)
normalize_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}

normalize_half3 #

Source 
@(require_results)
normalize_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}

normalize_half4 #

Source 
@(require_results)
normalize_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}

notEqual_double2 #

Source 
@(require_results)
notEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}

notEqual_double3 #

Source 
@(require_results)
notEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}

notEqual_double4 #

Source 
@(require_results)
notEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}

radians_double2 #

Source 
@(require_results)
radians_double2 :: proc "c" (degrees: [2]f64) -> [2]f64 {…}

radians_double3 #

Source 
@(require_results)
radians_double3 :: proc "c" (degrees: [3]f64) -> [3]f64 {…}

radians_double4 #

Source 
@(require_results)
radians_double4 :: proc "c" (degrees: [4]f64) -> [4]f64 {…}

radians_float2 #

Source 
@(require_results)
radians_float2 :: proc "c" (degrees: [2]f32) -> [2]f32 {…}

radians_float3 #

Source 
@(require_results)
radians_float3 :: proc "c" (degrees: [3]f32) -> [3]f32 {…}

radians_float4 #

Source 
@(require_results)
radians_float4 :: proc "c" (degrees: [4]f32) -> [4]f32 {…}

radians_half2 #

Source 
@(require_results)
radians_half2 :: proc "c" (degrees: [2]f16) -> [2]f16 {…}

radians_half3 #

Source 
@(require_results)
radians_half3 :: proc "c" (degrees: [3]f16) -> [3]f16 {…}

radians_half4 #

Source 
@(require_results)
radians_half4 :: proc "c" (degrees: [4]f16) -> [4]f16 {…}

reflect_double2 #

Source 
@(require_results)
reflect_double2 :: proc "c" (I, N: [2]f64) -> [2]f64 {…}

reflect_double3 #

Source 
@(require_results)
reflect_double3 :: proc "c" (I, N: [3]f64) -> [3]f64 {…}

reflect_double4 #

Source 
@(require_results)
reflect_double4 :: proc "c" (I, N: [4]f64) -> [4]f64 {…}

reflect_float2 #

Source 
@(require_results)
reflect_float2 :: proc "c" (I, N: [2]f32) -> [2]f32 {…}

reflect_float3 #

Source 
@(require_results)
reflect_float3 :: proc "c" (I, N: [3]f32) -> [3]f32 {…}

reflect_float4 #

Source 
@(require_results)
reflect_float4 :: proc "c" (I, N: [4]f32) -> [4]f32 {…}

refract_double #

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

refract_double2 #

Source 
@(require_results)
refract_double2 :: proc "c" (i, n, eta: [2]f64) -> [2]f64 {…}

refract_double3 #

Source 
@(require_results)
refract_double3 :: proc "c" (i, n, eta: [3]f64) -> [3]f64 {…}

refract_double4 #

Source 
@(require_results)
refract_double4 :: proc "c" (i, n, eta: [4]f64) -> [4]f64 {…}

refract_float2 #

Source 
@(require_results)
refract_float2 :: proc "c" (i, n, eta: [2]f32) -> [2]f32 {…}

refract_float3 #

Source 
@(require_results)
refract_float3 :: proc "c" (i, n, eta: [3]f32) -> [3]f32 {…}

refract_float4 #

Source 
@(require_results)
refract_float4 :: proc "c" (i, n, eta: [4]f32) -> [4]f32 {…}

refract_half2 #

Source 
@(require_results)
refract_half2 :: proc "c" (i, n, eta: [2]f16) -> [2]f16 {…}

refract_half3 #

Source 
@(require_results)
refract_half3 :: proc "c" (i, n, eta: [3]f16) -> [3]f16 {…}

refract_half4 #

Source 
@(require_results)
refract_half4 :: proc "c" (i, n, eta: [4]f16) -> [4]f16 {…}

saturate_double2 #

Source 
@(require_results)
saturate_double2 :: proc "c" (v: [2]f64) -> [2]f64 {…}

saturate_double3 #

Source 
@(require_results)
saturate_double3 :: proc "c" (v: [3]f64) -> [3]f64 {…}

saturate_double4 #

Source 
@(require_results)
saturate_double4 :: proc "c" (v: [4]f64) -> [4]f64 {…}

saturate_float2 #

Source 
@(require_results)
saturate_float2 :: proc "c" (v: [2]f32) -> [2]f32 {…}

saturate_float3 #

Source 
@(require_results)
saturate_float3 :: proc "c" (v: [3]f32) -> [3]f32 {…}

saturate_float4 #

Source 
@(require_results)
saturate_float4 :: proc "c" (v: [4]f32) -> [4]f32 {…}

scalarTripleProduct_double3 #

Source 
@(require_results)
scalarTripleProduct_double3 :: proc "c" (a, b, c: [3]f64) -> f64 {…}

scalarTripleProduct_float3 #

Source 
@(require_results)
scalarTripleProduct_float3 :: proc "c" (a, b, c: [3]f32) -> f32 {…}

scalarTripleProduct_half3 #

Source 
@(require_results)
scalarTripleProduct_half3 :: proc "c" (a, b, c: [3]f16) -> f16 {…}

scalarTripleProduct_int3 #

Source 
@(require_results)
scalarTripleProduct_int3 :: proc "c" (a, b, c: [3]i32) -> i32 {…}

smoothstep_double #

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

smoothstep_double2 #

Source 
@(require_results)
smoothstep_double2 :: proc "c" (edge0, edge1, x: [2]f64) -> [2]f64 {…}

smoothstep_double3 #

Source 
@(require_results)
smoothstep_double3 :: proc "c" (edge0, edge1, x: [3]f64) -> [3]f64 {…}

smoothstep_double4 #

Source 
@(require_results)
smoothstep_double4 :: proc "c" (edge0, edge1, x: [4]f64) -> [4]f64 {…}

smoothstep_float #

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

smoothstep_float2 #

Source 
@(require_results)
smoothstep_float2 :: proc "c" (edge0, edge1, x: [2]f32) -> [2]f32 {…}

smoothstep_float3 #

Source 
@(require_results)
smoothstep_float3 :: proc "c" (edge0, edge1, x: [3]f32) -> [3]f32 {…}

smoothstep_float4 #

Source 
@(require_results)
smoothstep_float4 :: proc "c" (edge0, edge1, x: [4]f32) -> [4]f32 {…}

smoothstep_half #

Source 
@(require_results)
smoothstep_half :: proc "c" (edge0, edge1, x: f16) -> f16 {…}

smoothstep_half2 #

Source 
@(require_results)
smoothstep_half2 :: proc "c" (edge0, edge1, x: [2]f16) -> [2]f16 {…}

smoothstep_half3 #

Source 
@(require_results)
smoothstep_half3 :: proc "c" (edge0, edge1, x: [3]f16) -> [3]f16 {…}

smoothstep_half4 #

Source 
@(require_results)
smoothstep_half4 :: proc "c" (edge0, edge1, x: [4]f16) -> [4]f16 {…}

step_double2 #

Source 
@(require_results)
step_double2 :: proc "c" (edge, x: [2]f64) -> [2]f64 {…}

step_double3 #

Source 
@(require_results)
step_double3 :: proc "c" (edge, x: [3]f64) -> [3]f64 {…}

step_double4 #

Source 
@(require_results)
step_double4 :: proc "c" (edge, x: [4]f64) -> [4]f64 {…}

trace #

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

vectorTripleProduct_double3 #

Source 
@(require_results)
vectorTripleProduct_double3 :: proc "c" (a, b, c: [3]f64) -> [3]f64 {…}

vectorTripleProduct_float3 #

Source 
@(require_results)
vectorTripleProduct_float3 :: proc "c" (a, b, c: [3]f32) -> [3]f32 {…}

vectorTripleProduct_half3 #

Source 
@(require_results)
vectorTripleProduct_half3 :: proc "c" (a, b, c: [3]f16) -> [3]f16 {…}

vectorTripleProduct_int3 #

Source 
@(require_results)
vectorTripleProduct_int3 :: proc "c" (a, b, c: [3]i32) -> [3]i32 {…}

Procedure Groups

70

asdouble #

Source 
asdouble :: proc{
	asdouble_half,
	asdouble_float,
	asdouble_double,
	asdouble_int,
	asdouble_uint,
	asdouble_half1x1,
	asdouble_half2x2,
	asdouble_half3x3,
	asdouble_half4x4,
	asdouble_half1x2,
	asdouble_half1x3,
	asdouble_half1x4,
	asdouble_half2x1,
	asdouble_half2x3,
	asdouble_half2x4,
	asdouble_half3x1,
	asdouble_half3x2,
	asdouble_half3x4,
	asdouble_half4x1,
	asdouble_half4x2,
	asdouble_half4x3,
	asdouble_half2,
	asdouble_half3,
	asdouble_half4,
	asdouble_float1x1,
	asdouble_float2x2,
	asdouble_float3x3,
	asdouble_float4x4,
	asdouble_float1x2,
	asdouble_float1x3,
	asdouble_float1x4,
	asdouble_float2x1,
	asdouble_float2x3,
	asdouble_float2x4,
	asdouble_float3x1,
	asdouble_float3x2,
	asdouble_float3x4,
	asdouble_float4x1,
	asdouble_float4x2,
	asdouble_float4x3,
	asdouble_float2,
	asdouble_float3,
	asdouble_float4,
	asdouble_int2,
	asdouble_int3,
	asdouble_int4,
	asdouble_uint2,
	asdouble_uint3,
	asdouble_uint4,
	asdouble_bool2,
	asdouble_bool3,
	asdouble_bool4,
	asdouble_double1x1,
	asdouble_double2x2,
	asdouble_double3x3,
	asdouble_double4x4,
	asdouble_double1x2,
	asdouble_double1x3,
	asdouble_double1x4,
	asdouble_double2x1,
	asdouble_double2x3,
	asdouble_double2x4,
	asdouble_double3x1,
	asdouble_double3x2,
	asdouble_double3x4,
	asdouble_double4x1,
	asdouble_double4x2,
	asdouble_double4x3,
	asdouble_double2,
	asdouble_double3,
	asdouble_double4,
}

asfloat #

Source 
asfloat :: proc{
	asfloat_half,
	asfloat_float,
	asfloat_double,
	asfloat_int,
	asfloat_uint,
	asfloat_half1x1,
	asfloat_half2x2,
	asfloat_half3x3,
	asfloat_half4x4,
	asfloat_half1x2,
	asfloat_half1x3,
	asfloat_half1x4,
	asfloat_half2x1,
	asfloat_half2x3,
	asfloat_half2x4,
	asfloat_half3x1,
	asfloat_half3x2,
	asfloat_half3x4,
	asfloat_half4x1,
	asfloat_half4x2,
	asfloat_half4x3,
	asfloat_half2,
	asfloat_half3,
	asfloat_half4,
	asfloat_float1x1,
	asfloat_float2x2,
	asfloat_float3x3,
	asfloat_float4x4,
	asfloat_float1x2,
	asfloat_float1x3,
	asfloat_float1x4,
	asfloat_float2x1,
	asfloat_float2x3,
	asfloat_float2x4,
	asfloat_float3x1,
	asfloat_float3x2,
	asfloat_float3x4,
	asfloat_float4x1,
	asfloat_float4x2,
	asfloat_float4x3,
	asfloat_float2,
	asfloat_float3,
	asfloat_float4,
	asfloat_int2,
	asfloat_int3,
	asfloat_int4,
	asfloat_uint2,
	asfloat_uint3,
	asfloat_uint4,
	asfloat_bool2,
	asfloat_bool3,
	asfloat_bool4,
	asfloat_double1x1,
	asfloat_double2x2,
	asfloat_double3x3,
	asfloat_double4x4,
	asfloat_double1x2,
	asfloat_double1x3,
	asfloat_double1x4,
	asfloat_double2x1,
	asfloat_double2x3,
	asfloat_double2x4,
	asfloat_double3x1,
	asfloat_double3x2,
	asfloat_double3x4,
	asfloat_double4x1,
	asfloat_double4x2,
	asfloat_double4x3,
	asfloat_double2,
	asfloat_double3,
	asfloat_double4,
}

ashalf #

Source 
ashalf :: proc{
	ashalf_half,
	ashalf_float,
	ashalf_double,
	ashalf_int,
	ashalf_uint,
	ashalf_half1x1,
	ashalf_half2x2,
	ashalf_half3x3,
	ashalf_half4x4,
	ashalf_half1x2,
	ashalf_half1x3,
	ashalf_half1x4,
	ashalf_half2x1,
	ashalf_half2x3,
	ashalf_half2x4,
	ashalf_half3x1,
	ashalf_half3x2,
	ashalf_half3x4,
	ashalf_half4x1,
	ashalf_half4x2,
	ashalf_half4x3,
	ashalf_half2,
	ashalf_half3,
	ashalf_half4,
	ashalf_float1x1,
	ashalf_float2x2,
	ashalf_float3x3,
	ashalf_float4x4,
	ashalf_float1x2,
	ashalf_float1x3,
	ashalf_float1x4,
	ashalf_float2x1,
	ashalf_float2x3,
	ashalf_float2x4,
	ashalf_float3x1,
	ashalf_float3x2,
	ashalf_float3x4,
	ashalf_float4x1,
	ashalf_float4x2,
	ashalf_float4x3,
	ashalf_float2,
	ashalf_float3,
	ashalf_float4,
	ashalf_int2,
	ashalf_int3,
	ashalf_int4,
	ashalf_uint2,
	ashalf_uint3,
	ashalf_uint4,
	ashalf_bool2,
	ashalf_bool3,
	ashalf_bool4,
	ashalf_double1x1,
	ashalf_double2x2,
	ashalf_double3x3,
	ashalf_double4x4,
	ashalf_double1x2,
	ashalf_double1x3,
	ashalf_double1x4,
	ashalf_double2x1,
	ashalf_double2x3,
	ashalf_double2x4,
	ashalf_double3x1,
	ashalf_double3x2,
	ashalf_double3x4,
	ashalf_double4x1,
	ashalf_double4x2,
	ashalf_double4x3,
	ashalf_double2,
	ashalf_double3,
	ashalf_double4,
}

asint #

Source 
asint :: proc{
	asint_half,
	asint_float,
	asint_double,
	asint_int,
	asint_uint,
	asint_half1x1,
	asint_half2x2,
	asint_half3x3,
	asint_half4x4,
	asint_half1x2,
	asint_half1x3,
	asint_half1x4,
	asint_half2x1,
	asint_half2x3,
	asint_half2x4,
	asint_half3x1,
	asint_half3x2,
	asint_half3x4,
	asint_half4x1,
	asint_half4x2,
	asint_half4x3,
	asint_half2,
	asint_half3,
	asint_half4,
	asint_float1x1,
	asint_float2x2,
	asint_float3x3,
	asint_float4x4,
	asint_float1x2,
	asint_float1x3,
	asint_float1x4,
	asint_float2x1,
	asint_float2x3,
	asint_float2x4,
	asint_float3x1,
	asint_float3x2,
	asint_float3x4,
	asint_float4x1,
	asint_float4x2,
	asint_float4x3,
	asint_float2,
	asint_float3,
	asint_float4,
	asint_int2,
	asint_int3,
	asint_int4,
	asint_uint2,
	asint_uint3,
	asint_uint4,
	asint_bool2,
	asint_bool3,
	asint_bool4,
	asint_double1x1,
	asint_double2x2,
	asint_double3x3,
	asint_double4x4,
	asint_double1x2,
	asint_double1x3,
	asint_double1x4,
	asint_double2x1,
	asint_double2x3,
	asint_double2x4,
	asint_double3x1,
	asint_double3x2,
	asint_double3x4,
	asint_double4x1,
	asint_double4x2,
	asint_double4x3,
	asint_double2,
	asint_double3,
	asint_double4,
}

greaterThanEqual #

Source 
greaterThanEqual :: proc{
	greaterThanEqual_half,
	greaterThanEqual_float,
	greaterThanEqual_double,
	greaterThanEqual_int,
	greaterThanEqual_uint,
	greaterThanEqual_half2,
	greaterThanEqual_float2,
	greaterThanEqual_double2,
	greaterThanEqual_int2,
	greaterThanEqual_uint2,
	greaterThanEqual_half3,
	greaterThanEqual_float3,
	greaterThanEqual_double3,
	greaterThanEqual_int3,
	greaterThanEqual_uint3,
	greaterThanEqual_half4,
	greaterThanEqual_float4,
	greaterThanEqual_double4,
	greaterThanEqual_int4,
	greaterThanEqual_uint4,
}