diff --git a/core/math/linalg/hlsl/linalg_hlsl.odin b/core/math/linalg/hlsl/linalg_hlsl.odin index 5c78bd8b1..8666f6f60 100644 --- a/core/math/linalg/hlsl/linalg_hlsl.odin +++ b/core/math/linalg/hlsl/linalg_hlsl.odin @@ -22,6 +22,7 @@ FLOAT_EPSILON :: 1e-7 DOUBLE_EPSILON :: 1e-15 // Aliases (not distict) of types +half :: f16 float :: f32 double :: f64 int :: builtin.i32 @@ -46,6 +47,30 @@ float4x1 :: matrix[4, 1]float float4x2 :: matrix[4, 2]float float4x3 :: matrix[4, 3]float +// Half Precision (half) Floating Point Types + +half2 :: [2]half +half3 :: [3]half +half4 :: [4]half + +half1x1 :: matrix[1, 1]half +half2x2 :: matrix[2, 2]half +half3x3 :: matrix[3, 3]half +half4x4 :: matrix[4, 4]half + +half1x2 :: matrix[1, 2]half +half1x3 :: matrix[1, 3]half +half1x4 :: matrix[1, 4]half +half2x1 :: matrix[2, 1]half +half2x3 :: matrix[2, 3]half +half2x4 :: matrix[2, 4]half +half3x1 :: matrix[3, 1]half +half3x2 :: matrix[3, 2]half +half3x4 :: matrix[3, 4]half +half4x1 :: matrix[4, 1]half +half4x2 :: matrix[4, 2]half +half4x3 :: matrix[4, 3]half + float2 :: [2]float float3 :: [3]float float4 :: [4]float @@ -106,8 +131,12 @@ int4x2 :: matrix[4, 2]int int4x3 :: matrix[4, 3]int cos :: proc{ + cos_half, cos_float, cos_double, + cos_half2, + cos_half3, + cos_half4, cos_float2, cos_float3, cos_float4, @@ -115,6 +144,9 @@ cos :: proc{ cos_double3, cos_double4, } +@(require_results) cos_half2 :: proc "c" (x: half2) -> half2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_half3 :: proc "c" (x: half3) -> half3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_half4 :: proc "c" (x: half4) -> half4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } @(require_results) cos_float2 :: proc "c" (x: float2) -> float2 { return {cos(x.x), cos(x.y)} } @(require_results) cos_float3 :: proc "c" (x: float3) -> float3 { return {cos(x.x), cos(x.y), cos(x.z)} } @(require_results) cos_float4 :: proc "c" (x: float4) -> float4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } @@ -123,8 +155,12 @@ cos :: proc{ @(require_results) cos_double4 :: proc "c" (x: double4) -> double4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } sin :: proc{ + sin_half, sin_float, sin_double, + sin_half2, + sin_half3, + sin_half4, sin_float2, sin_float3, sin_float4, @@ -132,6 +168,9 @@ sin :: proc{ sin_double3, sin_double4, } +@(require_results) sin_half2 :: proc "c" (x: half2) -> half2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_half3 :: proc "c" (x: half3) -> half3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_half4 :: proc "c" (x: half4) -> half4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } @(require_results) sin_float2 :: proc "c" (x: float2) -> float2 { return {sin(x.x), sin(x.y)} } @(require_results) sin_float3 :: proc "c" (x: float3) -> float3 { return {sin(x.x), sin(x.y), sin(x.z)} } @(require_results) sin_float4 :: proc "c" (x: float4) -> float4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } @@ -140,8 +179,12 @@ sin :: proc{ @(require_results) sin_double4 :: proc "c" (x: double4) -> double4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } tan :: proc{ + tan_half, tan_float, tan_double, + tan_half2, + tan_half3, + tan_half4, tan_float2, tan_float3, tan_float4, @@ -149,6 +192,9 @@ tan :: proc{ tan_double3, tan_double4, } +@(require_results) tan_half2 :: proc "c" (x: half2) -> half2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_half3 :: proc "c" (x: half3) -> half3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_half4 :: proc "c" (x: half4) -> half4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } @(require_results) tan_float2 :: proc "c" (x: float2) -> float2 { return {tan(x.x), tan(x.y)} } @(require_results) tan_float3 :: proc "c" (x: float3) -> float3 { return {tan(x.x), tan(x.y), tan(x.z)} } @(require_results) tan_float4 :: proc "c" (x: float4) -> float4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } @@ -157,8 +203,12 @@ tan :: proc{ @(require_results) tan_double4 :: proc "c" (x: double4) -> double4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } acos :: proc{ + acos_half, acos_float, acos_double, + acos_half2, + acos_half3, + acos_half4, acos_float2, acos_float3, acos_float4, @@ -166,6 +216,9 @@ acos :: proc{ acos_double3, acos_double4, } +@(require_results) acos_half2 :: proc "c" (x: half2) -> half2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_half3 :: proc "c" (x: half3) -> half3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_half4 :: proc "c" (x: half4) -> half4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } @(require_results) acos_float2 :: proc "c" (x: float2) -> float2 { return {acos(x.x), acos(x.y)} } @(require_results) acos_float3 :: proc "c" (x: float3) -> float3 { return {acos(x.x), acos(x.y), acos(x.z)} } @(require_results) acos_float4 :: proc "c" (x: float4) -> float4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } @@ -174,8 +227,12 @@ acos :: proc{ @(require_results) acos_double4 :: proc "c" (x: double4) -> double4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } asin :: proc{ + asin_half, asin_float, asin_double, + asin_half2, + asin_half3, + asin_half4, asin_float2, asin_float3, asin_float4, @@ -183,6 +240,9 @@ asin :: proc{ asin_double3, asin_double4, } +@(require_results) asin_half2 :: proc "c" (x: half2) -> half2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_half3 :: proc "c" (x: half3) -> half3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_half4 :: proc "c" (x: half4) -> half4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } @(require_results) asin_float2 :: proc "c" (x: float2) -> float2 { return {asin(x.x), asin(x.y)} } @(require_results) asin_float3 :: proc "c" (x: float3) -> float3 { return {asin(x.x), asin(x.y), asin(x.z)} } @(require_results) asin_float4 :: proc "c" (x: float4) -> float4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } @@ -191,8 +251,12 @@ asin :: proc{ @(require_results) asin_double4 :: proc "c" (x: double4) -> double4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } atan :: proc{ + atan_half, atan_float, atan_double, + atan_half2, + atan_half3, + atan_half4, atan_float2, atan_float3, atan_float4, @@ -208,6 +272,9 @@ atan :: proc{ atan2_double3, atan2_double4, } +@(require_results) atan_half2 :: proc "c" (x: half2) -> half2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_half3 :: proc "c" (x: half3) -> half3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_half4 :: proc "c" (x: half4) -> half4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } @(require_results) atan_float2 :: proc "c" (x: float2) -> float2 { return {atan(x.x), atan(x.y)} } @(require_results) atan_float3 :: proc "c" (x: float3) -> float3 { return {atan(x.x), atan(x.y), atan(x.z)} } @(require_results) atan_float4 :: proc "c" (x: float4) -> float4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } @@ -216,8 +283,12 @@ atan :: proc{ @(require_results) atan_double4 :: proc "c" (x: double4) -> double4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } atan2 :: proc{ + atan2_half, atan2_float, atan2_double, + atan2_half2, + atan2_half3, + atan2_half4, atan2_float2, atan2_float3, atan2_float4, @@ -225,6 +296,9 @@ atan2 :: proc{ atan2_double3, atan2_double4, } +@(require_results) atan2_half2 :: proc "c" (y, x: half2) -> half2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_half3 :: proc "c" (y, x: half3) -> half3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_half4 :: proc "c" (y, x: half4) -> half4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @(require_results) atan2_float2 :: proc "c" (y, x: float2) -> float2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } @(require_results) atan2_float3 :: proc "c" (y, x: float3) -> float3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } @(require_results) atan2_float4 :: proc "c" (y, x: float4) -> float4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @@ -235,8 +309,12 @@ atan2 :: proc{ cosh :: proc{ + cosh_half, cosh_float, cosh_double, + cosh_half2, + cosh_half3, + cosh_half4, cosh_float2, cosh_float3, cosh_float4, @@ -244,6 +322,9 @@ cosh :: proc{ cosh_double3, cosh_double4, } +@(require_results) cosh_half2 :: proc "c" (x: half2) -> half2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_half3 :: proc "c" (x: half3) -> half3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_half4 :: proc "c" (x: half4) -> half4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } @(require_results) cosh_float2 :: proc "c" (x: float2) -> float2 { return {cosh(x.x), cosh(x.y)} } @(require_results) cosh_float3 :: proc "c" (x: float3) -> float3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } @(require_results) cosh_float4 :: proc "c" (x: float4) -> float4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } @@ -253,8 +334,12 @@ cosh :: proc{ sinh :: proc{ + sinh_half, sinh_float, sinh_double, + sinh_half2, + sinh_half3, + sinh_half4, sinh_float2, sinh_float3, sinh_float4, @@ -262,6 +347,9 @@ sinh :: proc{ sinh_double3, sinh_double4, } +@(require_results) sinh_half2 :: proc "c" (x: half2) -> half2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_half3 :: proc "c" (x: half3) -> half3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_half4 :: proc "c" (x: half4) -> half4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } @(require_results) sinh_float2 :: proc "c" (x: float2) -> float2 { return {sinh(x.x), sinh(x.y)} } @(require_results) sinh_float3 :: proc "c" (x: float3) -> float3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } @(require_results) sinh_float4 :: proc "c" (x: float4) -> float4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } @@ -270,8 +358,12 @@ sinh :: proc{ @(require_results) sinh_double4 :: proc "c" (x: double4) -> double4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } tanh :: proc{ + tanh_half, tanh_float, tanh_double, + tanh_half2, + tanh_half3, + tanh_half4, tanh_float2, tanh_float3, tanh_float4, @@ -279,6 +371,9 @@ tanh :: proc{ tanh_double3, tanh_double4, } +@(require_results) tanh_half2 :: proc "c" (x: half2) -> half2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_half3 :: proc "c" (x: half3) -> half3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_half4 :: proc "c" (x: half4) -> half4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } @(require_results) tanh_float2 :: proc "c" (x: float2) -> float2 { return {tanh(x.x), tanh(x.y)} } @(require_results) tanh_float3 :: proc "c" (x: float3) -> float3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } @(require_results) tanh_float4 :: proc "c" (x: float4) -> float4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } @@ -287,8 +382,12 @@ tanh :: proc{ @(require_results) tanh_double4 :: proc "c" (x: double4) -> double4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } acosh :: proc{ + acosh_half, acosh_float, acosh_double, + acosh_half2, + acosh_half3, + acosh_half4, acosh_float2, acosh_float3, acosh_float4, @@ -296,6 +395,9 @@ acosh :: proc{ acosh_double3, acosh_double4, } +@(require_results) acosh_half2 :: proc "c" (x: half2) -> half2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_half3 :: proc "c" (x: half3) -> half3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_half4 :: proc "c" (x: half4) -> half4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } @(require_results) acosh_float2 :: proc "c" (x: float2) -> float2 { return {acosh(x.x), acosh(x.y)} } @(require_results) acosh_float3 :: proc "c" (x: float3) -> float3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } @(require_results) acosh_float4 :: proc "c" (x: float4) -> float4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } @@ -304,8 +406,12 @@ acosh :: proc{ @(require_results) acosh_double4 :: proc "c" (x: double4) -> double4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } asinh :: proc{ + asinh_half, asinh_float, asinh_double, + asinh_half2, + asinh_half3, + asinh_half4, asinh_float2, asinh_float3, asinh_float4, @@ -313,6 +419,9 @@ asinh :: proc{ asinh_double3, asinh_double4, } +@(require_results) asinh_half2 :: proc "c" (x: half2) -> half2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_half3 :: proc "c" (x: half3) -> half3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_half4 :: proc "c" (x: half4) -> half4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } @(require_results) asinh_float2 :: proc "c" (x: float2) -> float2 { return {asinh(x.x), asinh(x.y)} } @(require_results) asinh_float3 :: proc "c" (x: float3) -> float3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } @(require_results) asinh_float4 :: proc "c" (x: float4) -> float4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } @@ -321,8 +430,12 @@ asinh :: proc{ @(require_results) asinh_double4 :: proc "c" (x: double4) -> double4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } atanh :: proc{ + atanh_half, atanh_float, atanh_double, + atanh_half2, + atanh_half3, + atanh_half4, atanh_float2, atanh_float3, atanh_float4, @@ -330,6 +443,9 @@ atanh :: proc{ atanh_double3, atanh_double4, } +@(require_results) atanh_half2 :: proc "c" (x: half2) -> half2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_half3 :: proc "c" (x: half3) -> half3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_half4 :: proc "c" (x: half4) -> half4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } @(require_results) atanh_float2 :: proc "c" (x: float2) -> float2 { return {atanh(x.x), atanh(x.y)} } @(require_results) atanh_float3 :: proc "c" (x: float3) -> float3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } @(require_results) atanh_float4 :: proc "c" (x: float4) -> float4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } @@ -338,8 +454,12 @@ atanh :: proc{ @(require_results) atanh_double4 :: proc "c" (x: double4) -> double4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } sqrt :: proc{ + sqrt_half, sqrt_float, sqrt_double, + sqrt_half2, + sqrt_half3, + sqrt_half4, sqrt_float2, sqrt_float3, sqrt_float4, @@ -347,6 +467,9 @@ sqrt :: proc{ sqrt_double3, sqrt_double4, } +@(require_results) sqrt_half2 :: proc "c" (x: half2) -> half2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_half3 :: proc "c" (x: half3) -> half3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_half4 :: proc "c" (x: half4) -> half4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } @(require_results) sqrt_float2 :: proc "c" (x: float2) -> float2 { return {sqrt(x.x), sqrt(x.y)} } @(require_results) sqrt_float3 :: proc "c" (x: float3) -> float3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } @(require_results) sqrt_float4 :: proc "c" (x: float4) -> float4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } @@ -355,8 +478,12 @@ sqrt :: proc{ @(require_results) sqrt_double4 :: proc "c" (x: double4) -> double4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } rsqrt :: proc{ + rsqrt_half, rsqrt_float, rsqrt_double, + rsqrt_half2, + rsqrt_half3, + rsqrt_half4, rsqrt_float2, rsqrt_float3, rsqrt_float4, @@ -364,6 +491,9 @@ rsqrt :: proc{ rsqrt_double3, rsqrt_double4, } +@(require_results) rsqrt_half2 :: proc "c" (x: half2) -> half2 { return {rsqrt(x.x), rsqrt(x.y)} } +@(require_results) rsqrt_half3 :: proc "c" (x: half3) -> half3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } +@(require_results) rsqrt_half4 :: proc "c" (x: half4) -> half4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } @(require_results) rsqrt_float2 :: proc "c" (x: float2) -> float2 { return {rsqrt(x.x), rsqrt(x.y)} } @(require_results) rsqrt_float3 :: proc "c" (x: float3) -> float3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } @(require_results) rsqrt_float4 :: proc "c" (x: float4) -> float4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } @@ -372,8 +502,12 @@ rsqrt :: proc{ @(require_results) rsqrt_double4 :: proc "c" (x: double4) -> double4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } rcp :: proc{ + rcp_half, rcp_float, rcp_double, + rcp_half2, + rcp_half3, + rcp_half4, rcp_float2, rcp_float3, rcp_float4, @@ -381,6 +515,9 @@ rcp :: proc{ rcp_double3, rcp_double4, } +@(require_results) rcp_half2 :: proc "c" (x: half2) -> half2 { return {rcp(x.x), rcp(x.y)} } +@(require_results) rcp_half3 :: proc "c" (x: half3) -> half3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } +@(require_results) rcp_half4 :: proc "c" (x: half4) -> half4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } @(require_results) rcp_float2 :: proc "c" (x: float2) -> float2 { return {rcp(x.x), rcp(x.y)} } @(require_results) rcp_float3 :: proc "c" (x: float3) -> float3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } @(require_results) rcp_float4 :: proc "c" (x: float4) -> float4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } @@ -390,8 +527,12 @@ rcp :: proc{ pow :: proc{ + pow_half, pow_float, pow_double, + pow_half2, + pow_half3, + pow_half4, pow_float2, pow_float3, pow_float4, @@ -399,6 +540,9 @@ pow :: proc{ pow_double3, pow_double4, } +@(require_results) pow_half2 :: proc "c" (x, y: half2) -> half2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_half3 :: proc "c" (x, y: half3) -> half3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_half4 :: proc "c" (x, y: half4) -> half4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @(require_results) pow_float2 :: proc "c" (x, y: float2) -> float2 { return {pow(x.x, y.x), pow(x.y, y.y)} } @(require_results) pow_float3 :: proc "c" (x, y: float3) -> float3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } @(require_results) pow_float4 :: proc "c" (x, y: float4) -> float4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @@ -409,8 +553,12 @@ pow :: proc{ exp :: proc{ + exp_half, exp_float, exp_double, + exp_half2, + exp_half3, + exp_half4, exp_float2, exp_float3, exp_float4, @@ -418,6 +566,9 @@ exp :: proc{ exp_double3, exp_double4, } +@(require_results) exp_half2 :: proc "c" (x: half2) -> half2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_half3 :: proc "c" (x: half3) -> half3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_half4 :: proc "c" (x: half4) -> half4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @(require_results) exp_float2 :: proc "c" (x: float2) -> float2 { return {exp(x.x), exp(x.y)} } @(require_results) exp_float3 :: proc "c" (x: float3) -> float3 { return {exp(x.x), exp(x.y), exp(x.z)} } @(require_results) exp_float4 :: proc "c" (x: float4) -> float4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @@ -428,8 +579,12 @@ exp :: proc{ log :: proc{ + log_half, log_float, log_double, + log_half2, + log_half3, + log_half4, log_float2, log_float3, log_float4, @@ -437,6 +592,9 @@ log :: proc{ log_double3, log_double4, } +@(require_results) log_half2 :: proc "c" (x: half2) -> half2 { return {log(x.x), log(x.y)} } +@(require_results) log_half3 :: proc "c" (x: half3) -> half3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_half4 :: proc "c" (x: half4) -> half4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } @(require_results) log_float2 :: proc "c" (x: float2) -> float2 { return {log(x.x), log(x.y)} } @(require_results) log_float3 :: proc "c" (x: float3) -> float3 { return {log(x.x), log(x.y), log(x.z)} } @(require_results) log_float4 :: proc "c" (x: float4) -> float4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } @@ -446,8 +604,12 @@ log :: proc{ log2 :: proc{ + log2_half, log2_float, log2_double, + log2_half2, + log2_half3, + log2_half4, log2_float2, log2_float3, log2_float4, @@ -455,6 +617,9 @@ log2 :: proc{ log2_double3, log2_double4, } +@(require_results) log2_half2 :: proc "c" (x: half2) -> half2 { return {log2(x.x), log2(x.y)} } +@(require_results) log2_half3 :: proc "c" (x: half3) -> half3 { return {log2(x.x), log2(x.y), log2(x.z)} } +@(require_results) log2_half4 :: proc "c" (x: half4) -> half4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } @(require_results) log2_float2 :: proc "c" (x: float2) -> float2 { return {log2(x.x), log2(x.y)} } @(require_results) log2_float3 :: proc "c" (x: float3) -> float3 { return {log2(x.x), log2(x.y), log2(x.z)} } @(require_results) log2_float4 :: proc "c" (x: float4) -> float4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } @@ -465,8 +630,12 @@ log2 :: proc{ log10 :: proc{ + log10_half, log10_float, log10_double, + log10_half2, + log10_half3, + log10_half4, log10_float2, log10_float3, log10_float4, @@ -474,6 +643,9 @@ log10 :: proc{ log10_double3, log10_double4, } +@(require_results) log10_half2 :: proc "c" (x: half2) -> half2 { return {log10(x.x), log10(x.y)} } +@(require_results) log10_half3 :: proc "c" (x: half3) -> half3 { return {log10(x.x), log10(x.y), log10(x.z)} } +@(require_results) log10_half4 :: proc "c" (x: half4) -> half4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } @(require_results) log10_float2 :: proc "c" (x: float2) -> float2 { return {log10(x.x), log10(x.y)} } @(require_results) log10_float3 :: proc "c" (x: float3) -> float3 { return {log10(x.x), log10(x.y), log10(x.z)} } @(require_results) log10_float4 :: proc "c" (x: float4) -> float4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } @@ -485,8 +657,12 @@ log10 :: proc{ exp2 :: proc{ + exp2_half, exp2_float, exp2_double, + exp2_half2, + exp2_half3, + exp2_half4, exp2_float2, exp2_float3, exp2_float4, @@ -494,6 +670,9 @@ exp2 :: proc{ exp2_double3, exp2_double4, } +@(require_results) exp2_half2 :: proc "c" (x: half2) -> half2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_half3 :: proc "c" (x: half3) -> half3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_half4 :: proc "c" (x: half4) -> half4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } @(require_results) exp2_float2 :: proc "c" (x: float2) -> float2 { return {exp2(x.x), exp2(x.y)} } @(require_results) exp2_float3 :: proc "c" (x: float3) -> float3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } @(require_results) exp2_float4 :: proc "c" (x: float4) -> float4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } @@ -503,10 +682,14 @@ exp2 :: proc{ sign :: proc{ + sign_half, sign_int, sign_uint, sign_float, sign_double, + sign_half2, + sign_half3, + sign_half4, sign_float2, sign_float3, sign_float4, @@ -522,6 +705,9 @@ sign :: proc{ } @(require_results) sign_int :: proc "c" (x: int) -> int { return -1 if x < 0 else +1 if x > 0 else 0 } @(require_results) sign_uint :: proc "c" (x: uint) -> uint { return +1 if x > 0 else 0 } +@(require_results) sign_half2 :: proc "c" (x: half2) -> half2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_half3 :: proc "c" (x: half3) -> half3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_half4 :: proc "c" (x: half4) -> half4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } @(require_results) sign_float2 :: proc "c" (x: float2) -> float2 { return {sign(x.x), sign(x.y)} } @(require_results) sign_float3 :: proc "c" (x: float3) -> float3 { return {sign(x.x), sign(x.y), sign(x.z)} } @(require_results) sign_float4 :: proc "c" (x: float4) -> float4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } @@ -536,8 +722,12 @@ sign :: proc{ @(require_results) sign_uint4 :: proc "c" (x: uint4) -> uint4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } floor :: proc{ + floor_half, floor_float, floor_double, + floor_half2, + floor_half3, + floor_half4, floor_float2, floor_float3, floor_float4, @@ -545,6 +735,9 @@ floor :: proc{ floor_double3, floor_double4, } +@(require_results) floor_half2 :: proc "c" (x: half2) -> half2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_half3 :: proc "c" (x: half3) -> half3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_half4 :: proc "c" (x: half4) -> half4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } @(require_results) floor_float2 :: proc "c" (x: float2) -> float2 { return {floor(x.x), floor(x.y)} } @(require_results) floor_float3 :: proc "c" (x: float3) -> float3 { return {floor(x.x), floor(x.y), floor(x.z)} } @(require_results) floor_float4 :: proc "c" (x: float4) -> float4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } @@ -553,8 +746,12 @@ floor :: proc{ @(require_results) floor_double4 :: proc "c" (x: double4) -> double4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } round :: proc{ + round_half, round_float, round_double, + round_half2, + round_half3, + round_half4, round_float2, round_float3, round_float4, @@ -562,6 +759,9 @@ round :: proc{ round_double3, round_double4, } +@(require_results) round_half2 :: proc "c" (x: half2) -> half2 { return {round(x.x), round(x.y)} } +@(require_results) round_half3 :: proc "c" (x: half3) -> half3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_half4 :: proc "c" (x: half4) -> half4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } @(require_results) round_float2 :: proc "c" (x: float2) -> float2 { return {round(x.x), round(x.y)} } @(require_results) round_float3 :: proc "c" (x: float3) -> float3 { return {round(x.x), round(x.y), round(x.z)} } @(require_results) round_float4 :: proc "c" (x: float4) -> float4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } @@ -571,8 +771,12 @@ round :: proc{ ceil :: proc{ + ceil_half, ceil_float, ceil_double, + ceil_half2, + ceil_half3, + ceil_half4, ceil_float2, ceil_float3, ceil_float4, @@ -580,6 +784,9 @@ ceil :: proc{ ceil_double3, ceil_double4, } +@(require_results) ceil_half2 :: proc "c" (x: half2) -> half2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_half3 :: proc "c" (x: half3) -> half3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_half4 :: proc "c" (x: half4) -> half4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } @(require_results) ceil_float2 :: proc "c" (x: float2) -> float2 { return {ceil(x.x), ceil(x.y)} } @(require_results) ceil_float3 :: proc "c" (x: float3) -> float3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } @(require_results) ceil_float4 :: proc "c" (x: float4) -> float4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } @@ -588,6 +795,10 @@ ceil :: proc{ @(require_results) ceil_double4 :: proc "c" (x: double4) -> double4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) isfinite_half :: proc "c" (x: half) -> bool { return !isinf_half(x) } +@(require_results) isfinite_half2 :: proc "c" (x: half2) -> bool2 { return {isfinite_half(x.x), isfinite_half(x.y)} } +@(require_results) isfinite_half3 :: proc "c" (x: half3) -> bool3 { return {isfinite_half(x.x), isfinite_half(x.y), isfinite_half(x.z)} } +@(require_results) isfinite_half4 :: proc "c" (x: half4) -> bool4 { return {isfinite_half(x.x), isfinite_half(x.y), isfinite_half(x.z), isfinite_half(x.w)} } @(require_results) isfinite_float :: proc "c" (x: float) -> bool { return !isinf_float(x) } @(require_results) isfinite_float2 :: proc "c" (x: float2) -> bool2 { return {isfinite_float(x.x), isfinite_float(x.y)} } @(require_results) isfinite_float3 :: proc "c" (x: float3) -> bool3 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z)} } @@ -599,6 +810,10 @@ ceil :: proc{ // isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite isfinite :: proc{ + isfinite_half, + isfinite_half2, + isfinite_half3, + isfinite_half4, isfinite_float, isfinite_float2, isfinite_float3, @@ -610,6 +825,10 @@ isfinite :: proc{ } +@(require_results) isinf_half :: proc "c" (x: half) -> bool { return x * 0.5 == x } +@(require_results) isinf_half2 :: proc "c" (x: half2) -> bool2 { return {isinf_half(x.x), isinf_half(x.y)} } +@(require_results) isinf_half3 :: proc "c" (x: half3) -> bool3 { return {isinf_half(x.x), isinf_half(x.y), isinf_half(x.z)} } +@(require_results) isinf_half4 :: proc "c" (x: half4) -> bool4 { return {isinf_half(x.x), isinf_half(x.y), isinf_half(x.z), isinf_half(x.w)} } @(require_results) isinf_float :: proc "c" (x: float) -> bool { return x * 0.5 == x } @(require_results) isinf_float2 :: proc "c" (x: float2) -> bool2 { return {isinf_float(x.x), isinf_float(x.y)} } @(require_results) isinf_float3 :: proc "c" (x: float3) -> bool3 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z)} } @@ -621,6 +840,10 @@ isfinite :: proc{ // isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite isinf :: proc{ + isinf_half, + isinf_half2, + isinf_half3, + isinf_half4, isinf_float, isinf_float2, isinf_float3, @@ -632,6 +855,9 @@ isinf :: proc{ } +@(require_results) isnan_half2 :: proc "c" (x: half2) -> bool2 { return {isnan_half(x.x), isnan_half(x.y)} } +@(require_results) isnan_half3 :: proc "c" (x: half3) -> bool3 { return {isnan_half(x.x), isnan_half(x.y), isnan_half(x.z)} } +@(require_results) isnan_half4 :: proc "c" (x: half4) -> bool4 { return {isnan_half(x.x), isnan_half(x.y), isnan_half(x.z), isnan_half(x.w)} } @(require_results) isnan_float2 :: proc "c" (x: float2) -> bool2 { return {isnan_float(x.x), isnan_float(x.y)} } @(require_results) isnan_float3 :: proc "c" (x: float3) -> bool3 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z)} } @(require_results) isnan_float4 :: proc "c" (x: float4) -> bool4 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z), isnan_float(x.w)} } @@ -641,6 +867,10 @@ isinf :: proc{ // isnan returns true if the input value is the special case of Not-A-Number isnan :: proc{ + isnan_half, + isnan_half2, + isnan_half3, + isnan_half4, isnan_float, isnan_float2, isnan_float3, @@ -652,8 +882,12 @@ isnan :: proc{ } fmod :: proc{ + fmod_half, fmod_float, fmod_double, + fmod_half2, + fmod_half3, + fmod_half4, fmod_float2, fmod_float3, fmod_float4, @@ -661,6 +895,9 @@ fmod :: proc{ fmod_double3, fmod_double4, } +@(require_results) fmod_half2 :: proc "c" (x, y: half2) -> half2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } +@(require_results) fmod_half3 :: proc "c" (x, y: half3) -> half3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } +@(require_results) fmod_half4 :: proc "c" (x, y: half4) -> half4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } @(require_results) fmod_float2 :: proc "c" (x, y: float2) -> float2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } @(require_results) fmod_float3 :: proc "c" (x, y: float3) -> float3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } @(require_results) fmod_float4 :: proc "c" (x, y: float4) -> float4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } @@ -670,8 +907,12 @@ fmod :: proc{ frac :: proc{ + frac_half, frac_float, frac_double, + frac_half2, + frac_half3, + frac_half4, frac_float2, frac_float3, frac_float4, @@ -679,6 +920,9 @@ frac :: proc{ frac_double3, frac_double4, } +@(require_results) frac_half2 :: proc "c" (x: half2) -> half2 { return {frac(x.x), frac(x.y)} } +@(require_results) frac_half3 :: proc "c" (x: half3) -> half3 { return {frac(x.x), frac(x.y), frac(x.z)} } +@(require_results) frac_half4 :: proc "c" (x: half4) -> half4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } @(require_results) frac_float2 :: proc "c" (x: float2) -> float2 { return {frac(x.x), frac(x.y)} } @(require_results) frac_float3 :: proc "c" (x: float3) -> float3 { return {frac(x.x), frac(x.y), frac(x.z)} } @(require_results) frac_float4 :: proc "c" (x: float4) -> float4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } @@ -689,8 +933,12 @@ frac :: proc{ radians :: proc{ + radians_half, radians_float, radians_double, + radians_half2, + radians_half3, + radians_half4, radians_float2, radians_float3, radians_float4, @@ -698,8 +946,12 @@ radians :: proc{ radians_double3, radians_double4, } +@(require_results) radians_half :: proc "c" (degrees: half) -> half { return degrees * TAU / 360.0 } @(require_results) radians_float :: proc "c" (degrees: float) -> float { return degrees * TAU / 360.0 } @(require_results) radians_double :: proc "c" (degrees: double) -> double { return degrees * TAU / 360.0 } +@(require_results) radians_half2 :: proc "c" (degrees: half2) -> half2 { return degrees * TAU / 360.0 } +@(require_results) radians_half3 :: proc "c" (degrees: half3) -> half3 { return degrees * TAU / 360.0 } +@(require_results) radians_half4 :: proc "c" (degrees: half4) -> half4 { return degrees * TAU / 360.0 } @(require_results) radians_float2 :: proc "c" (degrees: float2) -> float2 { return degrees * TAU / 360.0 } @(require_results) radians_float3 :: proc "c" (degrees: float3) -> float3 { return degrees * TAU / 360.0 } @(require_results) radians_float4 :: proc "c" (degrees: float4) -> float4 { return degrees * TAU / 360.0 } @@ -709,8 +961,12 @@ radians :: proc{ degrees :: proc{ + degrees_half, degrees_float, degrees_double, + degrees_half2, + degrees_half3, + degrees_half4, degrees_float2, degrees_float3, degrees_float4, @@ -718,8 +974,12 @@ degrees :: proc{ degrees_double3, degrees_double4, } +@(require_results) degrees_half :: proc "c" (radians: half) -> half { return radians * 360.0 / TAU } @(require_results) degrees_float :: proc "c" (radians: float) -> float { return radians * 360.0 / TAU } @(require_results) degrees_double :: proc "c" (radians: double) -> double { return radians * 360.0 / TAU } +@(require_results) degrees_half2 :: proc "c" (radians: half2) -> half2 { return radians * 360.0 / TAU } +@(require_results) degrees_half3 :: proc "c" (radians: half3) -> half3 { return radians * 360.0 / TAU } +@(require_results) degrees_half4 :: proc "c" (radians: half4) -> half4 { return radians * 360.0 / TAU } @(require_results) degrees_float2 :: proc "c" (radians: float2) -> float2 { return radians * 360.0 / TAU } @(require_results) degrees_float3 :: proc "c" (radians: float3) -> float3 { return radians * 360.0 / TAU } @(require_results) degrees_float4 :: proc "c" (radians: float4) -> float4 { return radians * 360.0 / TAU } @@ -728,10 +988,14 @@ degrees :: proc{ @(require_results) degrees_double4 :: proc "c" (radians: double4) -> double4 { return radians * 360.0 / TAU } min :: proc{ + min_half, min_int, min_uint, min_float, min_double, + min_half2, + min_half3, + min_half4, min_float2, min_float3, min_float4, @@ -747,8 +1011,12 @@ min :: proc{ } @(require_results) min_int :: proc "c" (x, y: int) -> int { return builtin.min(x, y) } @(require_results) min_uint :: proc "c" (x, y: uint) -> uint { return builtin.min(x, y) } +@(require_results) min_half :: proc "c" (x, y: half) -> half { return builtin.min(x, y) } @(require_results) min_float :: proc "c" (x, y: float) -> float { return builtin.min(x, y) } @(require_results) min_double :: proc "c" (x, y: double) -> double { return builtin.min(x, y) } +@(require_results) min_half2 :: proc "c" (x, y: half2) -> half2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_half3 :: proc "c" (x, y: half3) -> half3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_half4 :: proc "c" (x, y: half4) -> half4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } @(require_results) min_float2 :: proc "c" (x, y: float2) -> float2 { return {min(x.x, y.x), min(x.y, y.y)} } @(require_results) min_float3 :: proc "c" (x, y: float3) -> float3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } @(require_results) min_float4 :: proc "c" (x, y: float4) -> float4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } @@ -765,9 +1033,13 @@ min :: proc{ max :: proc{ max_int, - max_uint, + max_uint, + max_half, max_float, max_double, + max_half2, + max_half3, + max_half4, max_float2, max_float3, max_float4, @@ -784,7 +1056,11 @@ max :: proc{ @(require_results) max_int :: proc "c" (x, y: int) -> int { return builtin.max(x, y) } @(require_results) max_uint :: proc "c" (x, y: uint) -> uint { return builtin.max(x, y) } @(require_results) max_float :: proc "c" (x, y: float) -> float { return builtin.max(x, y) } +@(require_results) max_half :: proc "c" (x, y: half) -> half { return builtin.max(x, y) } @(require_results) max_double :: proc "c" (x, y: double) -> double { return builtin.max(x, y) } +@(require_results) max_half2 :: proc "c" (x, y: half2) -> half2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_half3 :: proc "c" (x, y: half3) -> half3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_half4 :: proc "c" (x, y: half4) -> half4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @(require_results) max_float2 :: proc "c" (x, y: float2) -> float2 { return {max(x.x, y.x), max(x.y, y.y)} } @(require_results) max_float3 :: proc "c" (x, y: float3) -> float3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } @(require_results) max_float4 :: proc "c" (x, y: float4) -> float4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @@ -803,8 +1079,12 @@ max :: proc{ clamp :: proc{ clamp_int, clamp_uint, - clamp_float, + clamp_half, + clamp_float, clamp_double, + clamp_half2, + clamp_half3, + clamp_half4, clamp_float2, clamp_float3, clamp_float4, @@ -820,8 +1100,12 @@ clamp :: proc{ } @(require_results) clamp_int :: proc "c" (x, y, z: int) -> int { return builtin.clamp(x, y, z) } @(require_results) clamp_uint :: proc "c" (x, y, z: uint) -> uint { return builtin.clamp(x, y, z) } +@(require_results) clamp_half :: proc "c" (x, y, z: half) -> half { return builtin.clamp(x, y, z) } @(require_results) clamp_float :: proc "c" (x, y, z: float) -> float { return builtin.clamp(x, y, z) } @(require_results) clamp_double :: proc "c" (x, y, z: double) -> double { return builtin.clamp(x, y, z) } +@(require_results) clamp_half2 :: proc "c" (x, y, z: half2) -> half2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_half3 :: proc "c" (x, y, z: half3) -> half3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_half4 :: proc "c" (x, y, z: half4) -> half4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } @(require_results) clamp_float2 :: proc "c" (x, y, z: float2) -> float2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } @(require_results) clamp_float3 :: proc "c" (x, y, z: float3) -> float3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } @(require_results) clamp_float4 :: proc "c" (x, y, z: float4) -> float4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } @@ -838,8 +1122,12 @@ clamp :: proc{ saturate :: proc{ saturate_int, saturate_uint, + saturate_half, saturate_float, saturate_double, + saturate_half2, + saturate_half3, + saturate_half4, saturate_float2, saturate_float3, saturate_float4, @@ -855,8 +1143,12 @@ saturate :: proc{ } @(require_results) saturate_int :: proc "c" (v: int) -> int { return builtin.clamp(v, 0, 1) } @(require_results) saturate_uint :: proc "c" (v: uint) -> uint { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_half :: proc "c" (v: half) -> half { return builtin.clamp(v, 0, 1) } @(require_results) saturate_float :: proc "c" (v: float) -> float { return builtin.clamp(v, 0, 1) } @(require_results) saturate_double :: proc "c" (v: double) -> double { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_half2 :: proc "c" (v: half2) -> half2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_half3 :: proc "c" (v: half3) -> half3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_half4 :: proc "c" (v: half4) -> half4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } @(require_results) saturate_float2 :: proc "c" (v: float2) -> float2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } @(require_results) saturate_float3 :: proc "c" (v: float3) -> float3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } @(require_results) saturate_float4 :: proc "c" (v: float4) -> float4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } @@ -872,8 +1164,12 @@ saturate :: proc{ lerp :: proc{ + lerp_half, lerp_float, lerp_double, + lerp_half2, + lerp_half3, + lerp_half4, lerp_float2, lerp_float3, lerp_float4, @@ -881,8 +1177,12 @@ lerp :: proc{ lerp_double3, lerp_double4, } +@(require_results) lerp_half :: proc "c" (x, y, t: half) -> half { return x*(1-t) + y*t } @(require_results) lerp_float :: proc "c" (x, y, t: float) -> float { return x*(1-t) + y*t } @(require_results) lerp_double :: proc "c" (x, y, t: double) -> double { return x*(1-t) + y*t } +@(require_results) lerp_half2 :: proc "c" (x, y, t: half2) -> half2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_half3 :: proc "c" (x, y, t: half3) -> half3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } +@(require_results) lerp_half4 :: proc "c" (x, y, t: half4) -> half4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } @(require_results) lerp_float2 :: proc "c" (x, y, t: float2) -> float2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } @(require_results) lerp_float3 :: proc "c" (x, y, t: float3) -> float3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } @(require_results) lerp_float4 :: proc "c" (x, y, t: float4) -> float4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } @@ -892,8 +1192,12 @@ lerp :: proc{ step :: proc{ + step_half, step_float, step_double, + step_half2, + step_half3, + step_half4, step_float2, step_float3, step_float4, @@ -901,8 +1205,12 @@ step :: proc{ step_double3, step_double4, } +@(require_results) step_half :: proc "c" (edge, x: half) -> half { return 0 if x < edge else 1 } @(require_results) step_float :: proc "c" (edge, x: float) -> float { return 0 if x < edge else 1 } @(require_results) step_double :: proc "c" (edge, x: double) -> double { return 0 if x < edge else 1 } +@(require_results) step_half2 :: proc "c" (edge, x: half2) -> half2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_half3 :: proc "c" (edge, x: half3) -> half3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_half4 :: proc "c" (edge, x: half4) -> half4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } @(require_results) step_float2 :: proc "c" (edge, x: float2) -> float2 { return {step(edge.x, x.x), step(edge.y, x.y)} } @(require_results) step_float3 :: proc "c" (edge, x: float3) -> float3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } @(require_results) step_float4 :: proc "c" (edge, x: float4) -> float4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } @@ -911,8 +1219,12 @@ step :: proc{ @(require_results) step_double4 :: proc "c" (edge, x: double4) -> double4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } smoothstep :: proc{ + smoothstep_half, smoothstep_float, smoothstep_double, + smoothstep_half2, + smoothstep_half3, + smoothstep_half4, smoothstep_float2, smoothstep_float3, smoothstep_float4, @@ -920,6 +1232,10 @@ smoothstep :: proc{ smoothstep_double3, smoothstep_double4, } +@(require_results) smoothstep_half :: proc "c" (edge0, edge1, x: half) -> half { + y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) + return y * y * (3 - 2*y) +} @(require_results) smoothstep_float :: proc "c" (edge0, edge1, x: float) -> float { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) @@ -928,6 +1244,9 @@ smoothstep :: proc{ y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } +@(require_results) smoothstep_half2 :: proc "c" (edge0, edge1, x: half2) -> half2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_half3 :: proc "c" (edge0, edge1, x: half3) -> half3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } +@(require_results) smoothstep_half4 :: proc "c" (edge0, edge1, x: half4) -> half4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } @(require_results) smoothstep_float2 :: proc "c" (edge0, edge1, x: float2) -> float2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } @(require_results) smoothstep_float3 :: proc "c" (edge0, edge1, x: float3) -> float3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } @(require_results) smoothstep_float4 :: proc "c" (edge0, edge1, x: float4) -> float4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } @@ -939,8 +1258,12 @@ smoothstep :: proc{ abs :: proc{ abs_int, abs_uint, + abs_half, abs_float, abs_double, + abs_half2, + abs_half3, + abs_half4, abs_float2, abs_float3, abs_float4, @@ -956,8 +1279,12 @@ abs :: proc{ } @(require_results) abs_int :: proc "c" (x: int) -> int { return builtin.abs(x) } @(require_results) abs_uint :: proc "c" (x: uint) -> uint { return x } +@(require_results) abs_half :: proc "c" (x: half) -> half { return builtin.abs(x) } @(require_results) abs_float :: proc "c" (x: float) -> float { return builtin.abs(x) } @(require_results) abs_double :: proc "c" (x: double) -> double { return builtin.abs(x) } +@(require_results) abs_half2 :: proc "c" (x: half2) -> half2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_half3 :: proc "c" (x: half3) -> half3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_half4 :: proc "c" (x: half4) -> half4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } @(require_results) abs_float2 :: proc "c" (x: float2) -> float2 { return {abs(x.x), abs(x.y)} } @(require_results) abs_float3 :: proc "c" (x: float3) -> float3 { return {abs(x.x), abs(x.y), abs(x.z)} } @(require_results) abs_float4 :: proc "c" (x: float4) -> float4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } @@ -974,8 +1301,12 @@ abs :: proc{ dot :: proc{ dot_int, dot_uint, + dot_half, dot_float, dot_double, + dot_half2, + dot_half3, + dot_half4, dot_float2, dot_float3, dot_float4, @@ -991,8 +1322,12 @@ dot :: proc{ } @(require_results) dot_int :: proc "c" (a, b: int) -> int { return a*b } @(require_results) dot_uint :: proc "c" (a, b: uint) -> uint { return a*b } +@(require_results) dot_half :: proc "c" (a, b: half) -> half { return a*b } @(require_results) dot_float :: proc "c" (a, b: float) -> float { return a*b } @(require_results) dot_double :: proc "c" (a, b: double) -> double { return a*b } +@(require_results) dot_half2 :: proc "c" (a, b: half2) -> half { return a.x*b.x + a.y*b.y } +@(require_results) dot_half3 :: proc "c" (a, b: half3) -> half { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_half4 :: proc "c" (a, b: half4) -> half { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } @(require_results) dot_float2 :: proc "c" (a, b: float2) -> float { return a.x*b.x + a.y*b.y } @(require_results) dot_float3 :: proc "c" (a, b: float3) -> float { return a.x*b.x + a.y*b.y + a.z*b.z } @(require_results) dot_float4 :: proc "c" (a, b: float4) -> float { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } @@ -1007,8 +1342,12 @@ dot :: proc{ @(require_results) dot_uint4 :: proc "c" (a, b: uint4) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } length :: proc{ + length_half, length_float, length_double, + length_half2, + length_half3, + length_half4, length_float2, length_float3, length_float4, @@ -1016,8 +1355,12 @@ length :: proc{ length_double3, length_double4, } +@(require_results) length_half :: proc "c" (x: half) -> half { return builtin.abs(x) } @(require_results) length_float :: proc "c" (x: float) -> float { return builtin.abs(x) } @(require_results) length_double :: proc "c" (x: double) -> double { return builtin.abs(x) } +@(require_results) length_half2 :: proc "c" (x: half2) -> half { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_half3 :: proc "c" (x: half3) -> half { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_half4 :: proc "c" (x: half4) -> half { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } @(require_results) length_float2 :: proc "c" (x: float2) -> float { return sqrt(x.x*x.x + x.y*x.y) } @(require_results) length_float3 :: proc "c" (x: float3) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } @(require_results) length_float4 :: proc "c" (x: float4) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } @@ -1027,8 +1370,12 @@ length :: proc{ distance :: proc{ + distance_half, distance_float, distance_double, + distance_half2, + distance_half3, + distance_half4, distance_float2, distance_float3, distance_float4, @@ -1036,8 +1383,12 @@ distance :: proc{ distance_double3, distance_double4, } +@(require_results) distance_half :: proc "c" (x, y: half) -> half { return length(y-x) } @(require_results) distance_float :: proc "c" (x, y: float) -> float { return length(y-x) } @(require_results) distance_double :: proc "c" (x, y: double) -> double { return length(y-x) } +@(require_results) distance_half2 :: proc "c" (x, y: half2) -> half { return length(y-x) } +@(require_results) distance_half3 :: proc "c" (x, y: half3) -> half { return length(y-x) } +@(require_results) distance_half4 :: proc "c" (x, y: half4) -> half { return length(y-x) } @(require_results) distance_float2 :: proc "c" (x, y: float2) -> float { return length(y-x) } @(require_results) distance_float3 :: proc "c" (x, y: float3) -> float { return length(y-x) } @(require_results) distance_float4 :: proc "c" (x, y: float4) -> float { return length(y-x) } @@ -1047,11 +1398,18 @@ distance :: proc{ cross :: proc{ + cross_half3, cross_float3, cross_double3, cross_int3, } +@(require_results) cross_half3 :: proc "c" (a, b: half3) -> (c: half3) { + c.x = a.y*b.z - b.y*a.z + c.y = a.z*b.x - b.z*a.x + c.z = a.x*b.y - b.x*a.y + return +} @(require_results) cross_float3 :: proc "c" (a, b: float3) -> (c: float3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x @@ -1072,8 +1430,12 @@ cross :: proc{ } normalize :: proc{ + normalize_half, normalize_float, normalize_double, + normalize_half2, + normalize_half3, + normalize_half4, normalize_float2, normalize_float3, normalize_float4, @@ -1081,8 +1443,12 @@ normalize :: proc{ normalize_double3, normalize_double4, } +@(require_results) normalize_half :: proc "c" (x: half) -> half { return 1.0 } @(require_results) normalize_float :: proc "c" (x: float) -> float { return 1.0 } @(require_results) normalize_double :: proc "c" (x: double) -> double { return 1.0 } +@(require_results) normalize_half2 :: proc "c" (x: half2) -> half2 { return x / length(x) } +@(require_results) normalize_half3 :: proc "c" (x: half3) -> half3 { return x / length(x) } +@(require_results) normalize_half4 :: proc "c" (x: half4) -> half4 { return x / length(x) } @(require_results) normalize_float2 :: proc "c" (x: float2) -> float2 { return x / length(x) } @(require_results) normalize_float3 :: proc "c" (x: float3) -> float3 { return x / length(x) } @(require_results) normalize_float4 :: proc "c" (x: float4) -> float4 { return x / length(x) } @@ -1092,8 +1458,12 @@ normalize :: proc{ faceforward :: proc{ + faceforward_half, faceforward_float, faceforward_double, + faceforward_half2, + faceforward_half3, + faceforward_half4, faceforward_float2, faceforward_float3, faceforward_float4, @@ -1101,8 +1471,12 @@ faceforward :: proc{ faceforward_double3, faceforward_double4, } +@(require_results) faceforward_half :: proc "c" (N, I, Nref: half) -> half { return N if dot(I, Nref) < 0 else -N } @(require_results) faceforward_float :: proc "c" (N, I, Nref: float) -> float { return N if dot(I, Nref) < 0 else -N } @(require_results) faceforward_double :: proc "c" (N, I, Nref: double) -> double { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_half2 :: proc "c" (N, I, Nref: half2) -> half2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_half3 :: proc "c" (N, I, Nref: half3) -> half3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_half4 :: proc "c" (N, I, Nref: half4) -> half4 { return N if dot(I, Nref) < 0 else -N } @(require_results) faceforward_float2 :: proc "c" (N, I, Nref: float2) -> float2 { return N if dot(I, Nref) < 0 else -N } @(require_results) faceforward_float3 :: proc "c" (N, I, Nref: float3) -> float3 { return N if dot(I, Nref) < 0 else -N } @(require_results) faceforward_float4 :: proc "c" (N, I, Nref: float4) -> float4 { return N if dot(I, Nref) < 0 else -N } @@ -1112,8 +1486,12 @@ faceforward :: proc{ reflect :: proc{ + reflect_half, reflect_float, reflect_double, + reflect_half2, + reflect_half3, + reflect_half4, reflect_float2, reflect_float3, reflect_float4, @@ -1121,8 +1499,12 @@ reflect :: proc{ reflect_double3, reflect_double4, } +@(require_results) reflect_half :: proc "c" (I, N: half) -> half { return I - 2*N*dot(N, I) } @(require_results) reflect_float :: proc "c" (I, N: float) -> float { return I - 2*N*dot(N, I) } @(require_results) reflect_double :: proc "c" (I, N: double) -> double { return I - 2*N*dot(N, I) } +@(require_results) reflect_half2 :: proc "c" (I, N: half2) -> half2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_half3 :: proc "c" (I, N: half3) -> half3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_half4 :: proc "c" (I, N: half4) -> half4 { return I - 2*N*dot(N, I) } @(require_results) reflect_float2 :: proc "c" (I, N: float2) -> float2 { return I - 2*N*dot(N, I) } @(require_results) reflect_float3 :: proc "c" (I, N: float3) -> float3 { return I - 2*N*dot(N, I) } @(require_results) reflect_float4 :: proc "c" (I, N: float4) -> float4 { return I - 2*N*dot(N, I) } @@ -1134,8 +1516,12 @@ reflect :: proc{ refract :: proc{ + refract_half, refract_float, refract_double, + refract_half2, + refract_half3, + refract_half4, refract_float2, refract_float3, refract_float4, @@ -1144,6 +1530,13 @@ refract :: proc{ refract_double4, } @(require_results) +refract_half :: proc "c" (i, n, eta: half) -> half { + cosi := dot(-i, n) + cost2 := 1 - eta*eta*(1 - cosi*cosi) + t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) + return t * half(int(cost2 > 0)) +} +@(require_results) refract_float :: proc "c" (i, n, eta: float) -> float { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) @@ -1158,6 +1551,27 @@ refract_double :: proc "c" (i, n, eta: double) -> double { return t * double(int(cost2 > 0)) } @(require_results) +refract_half2 :: proc "c" (i, n, eta: half2) -> half2 { + cosi := dot(-i, n) + cost2 := 1 - eta*eta*(1 - cosi*cosi) + t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) + return t * half2{half(int(cost2.x > 0)), half(int(cost2.y > 0))} +} +@(require_results) +refract_half3 :: proc "c" (i, n, eta: half3) -> half3 { + cosi := dot(-i, n) + cost2 := 1 - eta*eta*(1 - cosi*cosi) + t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) + return t * half3{half(int(cost2.x > 0)), half(int(cost2.y > 0)), half(int(cost2.z > 0))} +} +@(require_results) +refract_half4 :: proc "c" (i, n, eta: half4) -> half4 { + cosi := dot(-i, n) + cost2 := 1 - eta*eta*(1 - cosi*cosi) + t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) + return t * half4{half(int(cost2.x > 0)), half(int(cost2.y > 0)), half(int(cost2.z > 0)), half(int(cost2.w > 0))} +} +@(require_results) refract_float2 :: proc "c" (i, n, eta: float2) -> float2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) @@ -1201,19 +1615,23 @@ refract_double4 :: proc "c" (i, n, eta: double4) -> double4 { } scalarTripleProduct :: proc{ + scalarTripleProduct_half3, scalarTripleProduct_float3, scalarTripleProduct_double3, scalarTripleProduct_int3, } +@(require_results) scalarTripleProduct_half3 :: proc "c" (a, b, c: half3) -> half { return dot(a, cross(b, c)) } @(require_results) scalarTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float { return dot(a, cross(b, c)) } @(require_results) scalarTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double { return dot(a, cross(b, c)) } @(require_results) scalarTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int { return dot(a, cross(b, c)) } vectorTripleProduct :: proc { + vectorTripleProduct_half3, vectorTripleProduct_float3, vectorTripleProduct_double3, vectorTripleProduct_int3, } +@(require_results) vectorTripleProduct_half3 :: proc "c" (a, b, c: half3) -> half3 { return cross(a, cross(b, c)) } @(require_results) vectorTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float3 { return cross(a, cross(b, c)) } @(require_results) vectorTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double3 { return cross(a, cross(b, c)) } @(require_results) vectorTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int3 { return cross(a, cross(b, c)) } @@ -1222,35 +1640,43 @@ vectorTripleProduct :: proc { // Vector Relational Procedures lessThan :: proc{ + lessThan_half, lessThan_float, lessThan_double, lessThan_int, lessThan_uint, + lessThan_half2, lessThan_float2, lessThan_double2, lessThan_int2, lessThan_uint2, + lessThan_half3, lessThan_float3, lessThan_double3, lessThan_int3, lessThan_uint3, + lessThan_half4, lessThan_float4, lessThan_double4, lessThan_int4, lessThan_uint4, } +@(require_results) lessThan_half :: proc "c" (a, b: half) -> bool { return a < b } @(require_results) lessThan_float :: proc "c" (a, b: float) -> bool { return a < b } @(require_results) lessThan_double :: proc "c" (a, b: double) -> bool { return a < b } @(require_results) lessThan_int :: proc "c" (a, b: int) -> bool { return a < b } @(require_results) lessThan_uint :: proc "c" (a, b: uint) -> bool { return a < b } +@(require_results) lessThan_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x < b.x, a.y < b.y} } @(require_results) lessThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x < b.x, a.y < b.y} } @(require_results) lessThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x < b.x, a.y < b.y} } @(require_results) lessThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x < b.x, a.y < b.y} } @(require_results) lessThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } @(require_results) lessThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } @(require_results) lessThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } @(require_results) lessThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } @(require_results) lessThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } @(require_results) lessThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } @(require_results) lessThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } @(require_results) lessThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } @@ -1258,35 +1684,43 @@ lessThan :: proc{ lessThanEqual :: proc{ + lessThanEqual_half, lessThanEqual_float, lessThanEqual_double, lessThanEqual_int, lessThanEqual_uint, + lessThanEqual_half2, lessThanEqual_float2, lessThanEqual_double2, lessThanEqual_int2, lessThanEqual_uint2, + lessThanEqual_half3, lessThanEqual_float3, lessThanEqual_double3, lessThanEqual_int3, lessThanEqual_uint3, + lessThanEqual_half4, lessThanEqual_float4, lessThanEqual_double4, lessThanEqual_int4, lessThanEqual_uint4, } +@(require_results) lessThanEqual_half :: proc "c" (a, b: half) -> bool { return a <= b } @(require_results) lessThanEqual_float :: proc "c" (a, b: float) -> bool { return a <= b } @(require_results) lessThanEqual_double :: proc "c" (a, b: double) -> bool { return a <= b } @(require_results) lessThanEqual_int :: proc "c" (a, b: int) -> bool { return a <= b } @(require_results) lessThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a <= b } +@(require_results) lessThanEqual_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } @(require_results) lessThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } @(require_results) lessThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } @(require_results) lessThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } @(require_results) lessThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } @(require_results) lessThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } @(require_results) lessThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } @(require_results) lessThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } @(require_results) lessThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } @(require_results) lessThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } @(require_results) lessThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } @(require_results) lessThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } @@ -1294,35 +1728,43 @@ lessThanEqual :: proc{ greaterThan :: proc{ + greaterThan_half, greaterThan_float, greaterThan_double, greaterThan_int, greaterThan_uint, + greaterThan_half2, greaterThan_float2, greaterThan_double2, greaterThan_int2, greaterThan_uint2, + greaterThan_half3, greaterThan_float3, greaterThan_double3, greaterThan_int3, greaterThan_uint3, + greaterThan_half4, greaterThan_float4, greaterThan_double4, greaterThan_int4, greaterThan_uint4, } +@(require_results) greaterThan_half :: proc "c" (a, b: half) -> bool { return a > b } @(require_results) greaterThan_float :: proc "c" (a, b: float) -> bool { return a > b } @(require_results) greaterThan_double :: proc "c" (a, b: double) -> bool { return a > b } @(require_results) greaterThan_int :: proc "c" (a, b: int) -> bool { return a > b } @(require_results) greaterThan_uint :: proc "c" (a, b: uint) -> bool { return a > b } +@(require_results) greaterThan_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x > b.x, a.y > b.y} } @(require_results) greaterThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x > b.x, a.y > b.y} } @(require_results) greaterThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x > b.x, a.y > b.y} } @(require_results) greaterThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x > b.x, a.y > b.y} } @(require_results) greaterThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } @(require_results) greaterThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } @(require_results) greaterThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } @(require_results) greaterThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } @(require_results) greaterThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } @(require_results) greaterThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } @(require_results) greaterThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } @(require_results) greaterThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } @@ -1330,35 +1772,43 @@ greaterThan :: proc{ 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, } +@(require_results) greaterThanEqual_half :: proc "c" (a, b: half) -> bool { return a >= b } @(require_results) greaterThanEqual_float :: proc "c" (a, b: float) -> bool { return a >= b } @(require_results) greaterThanEqual_double :: proc "c" (a, b: double) -> bool { return a >= b } @(require_results) greaterThanEqual_int :: proc "c" (a, b: int) -> bool { return a >= b } @(require_results) greaterThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a >= b } +@(require_results) greaterThanEqual_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } @(require_results) greaterThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } @(require_results) greaterThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } @(require_results) greaterThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } @(require_results) greaterThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } @(require_results) greaterThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } @(require_results) greaterThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } @(require_results) greaterThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } @(require_results) greaterThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } @(require_results) greaterThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } @(require_results) greaterThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } @(require_results) greaterThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } @@ -1366,70 +1816,86 @@ greaterThanEqual :: proc{ equal :: proc{ + equal_half, equal_float, equal_double, equal_int, equal_uint, + equal_half2, equal_float2, equal_double2, equal_int2, equal_uint2, + equal_half3, equal_float3, equal_double3, equal_int3, equal_uint3, + equal_half4, equal_float4, equal_double4, equal_int4, equal_uint4, } +@(require_results) equal_half :: proc "c" (a, b: half) -> bool { return a == b } @(require_results) equal_float :: proc "c" (a, b: float) -> bool { return a == b } @(require_results) equal_double :: proc "c" (a, b: double) -> bool { return a == b } @(require_results) equal_int :: proc "c" (a, b: int) -> bool { return a == b } @(require_results) equal_uint :: proc "c" (a, b: uint) -> bool { return a == b } +@(require_results) equal_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x == b.x, a.y == b.y} } @(require_results) equal_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x == b.x, a.y == b.y} } @(require_results) equal_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x == b.x, a.y == b.y} } @(require_results) equal_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x == b.x, a.y == b.y} } @(require_results) equal_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } @(require_results) equal_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } @(require_results) equal_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } @(require_results) equal_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } @(require_results) equal_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } @(require_results) equal_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } @(require_results) equal_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } @(require_results) equal_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } @(require_results) equal_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } notEqual :: proc{ + notEqual_half, notEqual_float, notEqual_double, notEqual_int, notEqual_uint, + notEqual_half2, notEqual_float2, notEqual_double2, notEqual_int2, notEqual_uint2, + notEqual_half3, notEqual_float3, notEqual_double3, notEqual_int3, notEqual_uint3, + notEqual_half4, notEqual_float4, notEqual_double4, notEqual_int4, notEqual_uint4, } +@(require_results) notEqual_half :: proc "c" (a, b: half) -> bool { return a != b } @(require_results) notEqual_float :: proc "c" (a, b: float) -> bool { return a != b } @(require_results) notEqual_double :: proc "c" (a, b: double) -> bool { return a != b } @(require_results) notEqual_int :: proc "c" (a, b: int) -> bool { return a != b } @(require_results) notEqual_uint :: proc "c" (a, b: uint) -> bool { return a != b } +@(require_results) notEqual_half2 :: proc "c" (a, b: half2) -> bool2 { return {a.x != b.x, a.y != b.y} } @(require_results) notEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x != b.x, a.y != b.y} } @(require_results) notEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x != b.x, a.y != b.y} } @(require_results) notEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x != b.x, a.y != b.y} } @(require_results) notEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_half3 :: proc "c" (a, b: half3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } @(require_results) notEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } @(require_results) notEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } @(require_results) notEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } @(require_results) notEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_half4 :: proc "c" (a, b: half4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } @(require_results) notEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } @(require_results) notEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } @(require_results) notEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } @@ -1472,6 +1938,10 @@ not :: proc{ +@(require_results) inverse_half1x1 :: proc "c" (m: half1x1) -> half1x1 { return inverse_matrix1x1(m) } +@(require_results) inverse_half2x2 :: proc "c" (m: half2x2) -> half2x2 { return inverse_matrix2x2(m) } +@(require_results) inverse_half3x3 :: proc "c" (m: half3x3) -> half3x3 { return inverse_matrix3x3(m) } +@(require_results) inverse_half4x4 :: proc "c" (m: half4x4) -> half4x4 { return inverse_matrix4x4(m) } @(require_results) inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return inverse_matrix1x1(m) } @(require_results) inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return inverse_matrix2x2(m) } @(require_results) inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return inverse_matrix3x3(m) } @@ -1482,6 +1952,10 @@ not :: proc{ @(require_results) inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return inverse_matrix4x4(m) } inverse :: proc{ + inverse_half1x1, + inverse_half2x2, + inverse_half3x3, + inverse_half4x4, inverse_float1x1, inverse_float2x2, inverse_float3x3, @@ -1807,12 +2281,176 @@ inverse_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bou +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, +} +@(require_results) ashalf_half :: proc "c" (v: half) -> half { return half(v) } +@(require_results) ashalf_float :: proc "c" (v: float) -> half { return half(v) } +@(require_results) ashalf_double :: proc "c" (v: double) -> half { return half(v) } +@(require_results) ashalf_int :: proc "c" (v: int) -> half { return half(v) } +@(require_results) ashalf_uint :: proc "c" (v: uint) -> half { return half(v) } +@(require_results) ashalf_half1x1 :: proc "c" (v: half1x1) -> half1x1 { return half1x1(v) } +@(require_results) ashalf_half2x2 :: proc "c" (v: half2x2) -> half2x2 { return half2x2(v) } +@(require_results) ashalf_half3x3 :: proc "c" (v: half3x3) -> half3x3 { return half3x3(v) } +@(require_results) ashalf_half4x4 :: proc "c" (v: half4x4) -> half4x4 { return half4x4(v) } +@(require_results) ashalf_half1x2 :: proc "c" (v: half1x2) -> half1x2 { return half1x2(v) } +@(require_results) ashalf_half1x3 :: proc "c" (v: half1x3) -> half1x3 { return half1x3(v) } +@(require_results) ashalf_half1x4 :: proc "c" (v: half1x4) -> half1x4 { return half1x4(v) } +@(require_results) ashalf_half2x1 :: proc "c" (v: half2x1) -> half2x1 { return half2x1(v) } +@(require_results) ashalf_half2x3 :: proc "c" (v: half2x3) -> half2x3 { return half2x3(v) } +@(require_results) ashalf_half2x4 :: proc "c" (v: half2x4) -> half2x4 { return half2x4(v) } +@(require_results) ashalf_half3x1 :: proc "c" (v: half3x1) -> half3x1 { return half3x1(v) } +@(require_results) ashalf_half3x2 :: proc "c" (v: half3x2) -> half3x2 { return half3x2(v) } +@(require_results) ashalf_half3x4 :: proc "c" (v: half3x4) -> half3x4 { return half3x4(v) } +@(require_results) ashalf_half4x1 :: proc "c" (v: half4x1) -> half4x1 { return half4x1(v) } +@(require_results) ashalf_half4x2 :: proc "c" (v: half4x2) -> half4x2 { return half4x2(v) } +@(require_results) ashalf_half4x3 :: proc "c" (v: half4x3) -> half4x3 { return half4x3(v) } +@(require_results) ashalf_half2 :: proc "c" (v: half2) -> half2 { return half2(v) } +@(require_results) ashalf_half3 :: proc "c" (v: half3) -> half3 { return half3(v) } +@(require_results) ashalf_half4 :: proc "c" (v: half4) -> half4 { return half4(v) } +@(require_results) ashalf_float1x1 :: proc "c" (v: float1x1) -> half1x1 { return half1x1(v) } +@(require_results) ashalf_float2x2 :: proc "c" (v: float2x2) -> half2x2 { return half2x2(v) } +@(require_results) ashalf_float3x3 :: proc "c" (v: float3x3) -> half3x3 { return half3x3(v) } +@(require_results) ashalf_float4x4 :: proc "c" (v: float4x4) -> half4x4 { return half4x4(v) } +@(require_results) ashalf_float1x2 :: proc "c" (v: float1x2) -> half1x2 { return half1x2(v) } +@(require_results) ashalf_float1x3 :: proc "c" (v: float1x3) -> half1x3 { return half1x3(v) } +@(require_results) ashalf_float1x4 :: proc "c" (v: float1x4) -> half1x4 { return half1x4(v) } +@(require_results) ashalf_float2x1 :: proc "c" (v: float2x1) -> half2x1 { return half2x1(v) } +@(require_results) ashalf_float2x3 :: proc "c" (v: float2x3) -> half2x3 { return half2x3(v) } +@(require_results) ashalf_float2x4 :: proc "c" (v: float2x4) -> half2x4 { return half2x4(v) } +@(require_results) ashalf_float3x1 :: proc "c" (v: float3x1) -> half3x1 { return half3x1(v) } +@(require_results) ashalf_float3x2 :: proc "c" (v: float3x2) -> half3x2 { return half3x2(v) } +@(require_results) ashalf_float3x4 :: proc "c" (v: float3x4) -> half3x4 { return half3x4(v) } +@(require_results) ashalf_float4x1 :: proc "c" (v: float4x1) -> half4x1 { return half4x1(v) } +@(require_results) ashalf_float4x2 :: proc "c" (v: float4x2) -> half4x2 { return half4x2(v) } +@(require_results) ashalf_float4x3 :: proc "c" (v: float4x3) -> half4x3 { return half4x3(v) } +@(require_results) ashalf_float2 :: proc "c" (v: float2) -> half2 { return half2{half(v.x), half(v.y)} } +@(require_results) ashalf_float3 :: proc "c" (v: float3) -> half3 { return half3{half(v.x), half(v.y), half(v.z)} } +@(require_results) ashalf_float4 :: proc "c" (v: float4) -> half4 { return half4{half(v.x), half(v.y), half(v.z), half(v.w)} } +@(require_results) ashalf_int2 :: proc "c" (v: int2) -> half2 { return half2{half(v.x), half(v.y)} } +@(require_results) ashalf_int3 :: proc "c" (v: int3) -> half3 { return half3{half(v.x), half(v.y), half(v.z)} } +@(require_results) ashalf_int4 :: proc "c" (v: int4) -> half4 { return half4{half(v.x), half(v.y), half(v.z), half(v.w)} } +@(require_results) ashalf_uint2 :: proc "c" (v: uint2) -> half2 { return half2{half(v.x), half(v.y)} } +@(require_results) ashalf_uint3 :: proc "c" (v: uint3) -> half3 { return half3{half(v.x), half(v.y), half(v.z)} } +@(require_results) ashalf_uint4 :: proc "c" (v: uint4) -> half4 { return half4{half(v.x), half(v.y), half(v.z), half(v.w)} } +@(require_results) ashalf_bool2 :: proc "c" (v: bool2) -> half2 { return half2{half(int(v.x)), half(int(v.y))} } +@(require_results) ashalf_bool3 :: proc "c" (v: bool3) -> half3 { return half3{half(int(v.x)), half(int(v.y)), half(int(v.z))} } +@(require_results) ashalf_bool4 :: proc "c" (v: bool4) -> half4 { return half4{half(int(v.x)), half(int(v.y)), half(int(v.z)), half(int(v.w))} } +@(require_results) ashalf_double1x1 :: proc "c" (v: double1x1) -> half1x1 { return half1x1(v) } +@(require_results) ashalf_double2x2 :: proc "c" (v: double2x2) -> half2x2 { return half2x2(v) } +@(require_results) ashalf_double3x3 :: proc "c" (v: double3x3) -> half3x3 { return half3x3(v) } +@(require_results) ashalf_double4x4 :: proc "c" (v: double4x4) -> half4x4 { return half4x4(v) } +@(require_results) ashalf_double1x2 :: proc "c" (v: double1x2) -> half1x2 { return half1x2(v) } +@(require_results) ashalf_double1x3 :: proc "c" (v: double1x3) -> half1x3 { return half1x3(v) } +@(require_results) ashalf_double1x4 :: proc "c" (v: double1x4) -> half1x4 { return half1x4(v) } +@(require_results) ashalf_double2x1 :: proc "c" (v: double2x1) -> half2x1 { return half2x1(v) } +@(require_results) ashalf_double2x3 :: proc "c" (v: double2x3) -> half2x3 { return half2x3(v) } +@(require_results) ashalf_double2x4 :: proc "c" (v: double2x4) -> half2x4 { return half2x4(v) } +@(require_results) ashalf_double3x1 :: proc "c" (v: double3x1) -> half3x1 { return half3x1(v) } +@(require_results) ashalf_double3x2 :: proc "c" (v: double3x2) -> half3x2 { return half3x2(v) } +@(require_results) ashalf_double3x4 :: proc "c" (v: double3x4) -> half3x4 { return half3x4(v) } +@(require_results) ashalf_double4x1 :: proc "c" (v: double4x1) -> half4x1 { return half4x1(v) } +@(require_results) ashalf_double4x2 :: proc "c" (v: double4x2) -> half4x2 { return half4x2(v) } +@(require_results) ashalf_double4x3 :: proc "c" (v: double4x3) -> half4x3 { return half4x3(v) } +@(require_results) ashalf_double2 :: proc "c" (v: double2) -> half2 { return half2{half(v.x), half(v.y)} } +@(require_results) ashalf_double3 :: proc "c" (v: double3) -> half3 { return half3{half(v.x), half(v.y), half(v.z)} } +@(require_results) ashalf_double4 :: proc "c" (v: double4) -> half4 { return half4{half(v.x), half(v.y), half(v.z), half(v.w)} } 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, @@ -1861,10 +2499,30 @@ asfloat :: proc{ asfloat_double3, asfloat_double4, } +@(require_results) asfloat_half :: proc "c" (v: half) -> float { return float(v) } @(require_results) asfloat_float :: proc "c" (v: float) -> float { return float(v) } @(require_results) asfloat_double :: proc "c" (v: double) -> float { return float(v) } @(require_results) asfloat_int :: proc "c" (v: int) -> float { return float(v) } @(require_results) asfloat_uint :: proc "c" (v: uint) -> float { return float(v) } +@(require_results) asfloat_half1x1 :: proc "c" (v: half1x1) -> float1x1 { return float1x1(v) } +@(require_results) asfloat_half2x2 :: proc "c" (v: half2x2) -> float2x2 { return float2x2(v) } +@(require_results) asfloat_half3x3 :: proc "c" (v: half3x3) -> float3x3 { return float3x3(v) } +@(require_results) asfloat_half4x4 :: proc "c" (v: half4x4) -> float4x4 { return float4x4(v) } +@(require_results) asfloat_half1x2 :: proc "c" (v: half1x2) -> float1x2 { return float1x2(v) } +@(require_results) asfloat_half1x3 :: proc "c" (v: half1x3) -> float1x3 { return float1x3(v) } +@(require_results) asfloat_half1x4 :: proc "c" (v: half1x4) -> float1x4 { return float1x4(v) } +@(require_results) asfloat_half2x1 :: proc "c" (v: half2x1) -> float2x1 { return float2x1(v) } +@(require_results) asfloat_half2x3 :: proc "c" (v: half2x3) -> float2x3 { return float2x3(v) } +@(require_results) asfloat_half2x4 :: proc "c" (v: half2x4) -> float2x4 { return float2x4(v) } +@(require_results) asfloat_half3x1 :: proc "c" (v: half3x1) -> float3x1 { return float3x1(v) } +@(require_results) asfloat_half3x2 :: proc "c" (v: half3x2) -> float3x2 { return float3x2(v) } +@(require_results) asfloat_half3x4 :: proc "c" (v: half3x4) -> float3x4 { return float3x4(v) } +@(require_results) asfloat_half4x1 :: proc "c" (v: half4x1) -> float4x1 { return float4x1(v) } +@(require_results) asfloat_half4x2 :: proc "c" (v: half4x2) -> float4x2 { return float4x2(v) } +@(require_results) asfloat_half4x3 :: proc "c" (v: half4x3) -> float4x3 { return float4x3(v) } +@(require_results) asfloat_half2 :: proc "c" (v: half2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_half3 :: proc "c" (v: half3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_half4 :: proc "c" (v: half4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } @(require_results) asfloat_float1x1 :: proc "c" (v: float1x1) -> float1x1 { return float1x1(v) } @(require_results) asfloat_float2x2 :: proc "c" (v: float2x2) -> float2x2 { return float2x2(v) } @(require_results) asfloat_float3x3 :: proc "c" (v: float3x3) -> float3x3 { return float3x3(v) } @@ -1914,10 +2572,30 @@ asfloat :: proc{ @(require_results) asfloat_double4 :: proc "c" (v: double4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } 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, @@ -1966,10 +2644,30 @@ asdouble :: proc{ asdouble_double3, asdouble_double4, } +@(require_results) asdouble_half :: proc "c" (v: half) -> double { return double(v) } @(require_results) asdouble_float :: proc "c" (v: float) -> double { return double(v) } @(require_results) asdouble_double :: proc "c" (v: double) -> double { return double(v) } @(require_results) asdouble_int :: proc "c" (v: int) -> double { return double(v) } @(require_results) asdouble_uint :: proc "c" (v: uint) -> double { return double(v) } +@(require_results) asdouble_half1x1 :: proc "c" (v: half1x1) -> double1x1 { return double1x1(v) } +@(require_results) asdouble_half2x2 :: proc "c" (v: half2x2) -> double2x2 { return double2x2(v) } +@(require_results) asdouble_half3x3 :: proc "c" (v: half3x3) -> double3x3 { return double3x3(v) } +@(require_results) asdouble_half4x4 :: proc "c" (v: half4x4) -> double4x4 { return double4x4(v) } +@(require_results) asdouble_half1x2 :: proc "c" (v: half1x2) -> double1x2 { return double1x2(v) } +@(require_results) asdouble_half1x3 :: proc "c" (v: half1x3) -> double1x3 { return double1x3(v) } +@(require_results) asdouble_half1x4 :: proc "c" (v: half1x4) -> double1x4 { return double1x4(v) } +@(require_results) asdouble_half2x1 :: proc "c" (v: half2x1) -> double2x1 { return double2x1(v) } +@(require_results) asdouble_half2x3 :: proc "c" (v: half2x3) -> double2x3 { return double2x3(v) } +@(require_results) asdouble_half2x4 :: proc "c" (v: half2x4) -> double2x4 { return double2x4(v) } +@(require_results) asdouble_half3x1 :: proc "c" (v: half3x1) -> double3x1 { return double3x1(v) } +@(require_results) asdouble_half3x2 :: proc "c" (v: half3x2) -> double3x2 { return double3x2(v) } +@(require_results) asdouble_half3x4 :: proc "c" (v: half3x4) -> double3x4 { return double3x4(v) } +@(require_results) asdouble_half4x1 :: proc "c" (v: half4x1) -> double4x1 { return double4x1(v) } +@(require_results) asdouble_half4x2 :: proc "c" (v: half4x2) -> double4x2 { return double4x2(v) } +@(require_results) asdouble_half4x3 :: proc "c" (v: half4x3) -> double4x3 { return double4x3(v) } +@(require_results) asdouble_half2 :: proc "c" (v: half2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_half3 :: proc "c" (v: half3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_half4 :: proc "c" (v: half4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } @(require_results) asdouble_float1x1 :: proc "c" (v: float1x1) -> double1x1 { return double1x1(v) } @(require_results) asdouble_float2x2 :: proc "c" (v: float2x2) -> double2x2 { return double2x2(v) } @(require_results) asdouble_float3x3 :: proc "c" (v: float3x3) -> double3x3 { return double3x3(v) } @@ -2019,10 +2717,30 @@ asdouble :: proc{ @(require_results) asdouble_double4 :: proc "c" (v: double4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } 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, @@ -2071,10 +2789,30 @@ asint :: proc{ asint_double3, asint_double4, } +@(require_results) asint_half :: proc "c" (v: half) -> int { return int(v) } @(require_results) asint_float :: proc "c" (v: float) -> int { return int(v) } @(require_results) asint_double :: proc "c" (v: double) -> int { return int(v) } @(require_results) asint_int :: proc "c" (v: int) -> int { return int(v) } @(require_results) asint_uint :: proc "c" (v: uint) -> int { return int(v) } +@(require_results) asint_half1x1 :: proc "c" (v: half1x1) -> int1x1 { return int1x1(v) } +@(require_results) asint_half2x2 :: proc "c" (v: half2x2) -> int2x2 { return int2x2(v) } +@(require_results) asint_half3x3 :: proc "c" (v: half3x3) -> int3x3 { return int3x3(v) } +@(require_results) asint_half4x4 :: proc "c" (v: half4x4) -> int4x4 { return int4x4(v) } +@(require_results) asint_half1x2 :: proc "c" (v: half1x2) -> int1x2 { return int1x2(v) } +@(require_results) asint_half1x3 :: proc "c" (v: half1x3) -> int1x3 { return int1x3(v) } +@(require_results) asint_half1x4 :: proc "c" (v: half1x4) -> int1x4 { return int1x4(v) } +@(require_results) asint_half2x1 :: proc "c" (v: half2x1) -> int2x1 { return int2x1(v) } +@(require_results) asint_half2x3 :: proc "c" (v: half2x3) -> int2x3 { return int2x3(v) } +@(require_results) asint_half2x4 :: proc "c" (v: half2x4) -> int2x4 { return int2x4(v) } +@(require_results) asint_half3x1 :: proc "c" (v: half3x1) -> int3x1 { return int3x1(v) } +@(require_results) asint_half3x2 :: proc "c" (v: half3x2) -> int3x2 { return int3x2(v) } +@(require_results) asint_half3x4 :: proc "c" (v: half3x4) -> int3x4 { return int3x4(v) } +@(require_results) asint_half4x1 :: proc "c" (v: half4x1) -> int4x1 { return int4x1(v) } +@(require_results) asint_half4x2 :: proc "c" (v: half4x2) -> int4x2 { return int4x2(v) } +@(require_results) asint_half4x3 :: proc "c" (v: half4x3) -> int4x3 { return int4x3(v) } +@(require_results) asint_half2 :: proc "c" (v: half2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_half3 :: proc "c" (v: half3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_half4 :: proc "c" (v: half4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } @(require_results) asint_float1x1 :: proc "c" (v: float1x1) -> int1x1 { return int1x1(v) } @(require_results) asint_float2x2 :: proc "c" (v: float2x2) -> int2x2 { return int2x2(v) } @(require_results) asint_float3x3 :: proc "c" (v: float3x3) -> int3x3 { return int3x3(v) } @@ -2125,10 +2863,14 @@ asint :: proc{ asuint :: proc{ + asuint_half, asuint_float, asuint_double, asuint_int, asuint_uint, + asuint_half2, + asuint_half3, + asuint_half4, asuint_float2, asuint_float3, asuint_float4, @@ -2145,10 +2887,14 @@ asuint :: proc{ asuint_double3, asuint_double4, } +@(require_results) asuint_half :: proc "c" (v: half) -> uint { return uint(v) } @(require_results) asuint_float :: proc "c" (v: float) -> uint { return uint(v) } @(require_results) asuint_double :: proc "c" (v: double) -> uint { return uint(v) } @(require_results) asuint_int :: proc "c" (v: int) -> uint { return uint(v) } @(require_results) asuint_uint :: proc "c" (v: uint) -> uint { return uint(v) } +@(require_results) asuint_half2 :: proc "c" (v: half2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_half3 :: proc "c" (v: half3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_half4 :: proc "c" (v: half4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } @(require_results) asuint_float2 :: proc "c" (v: float2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } @(require_results) asuint_float3 :: proc "c" (v: float3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } @(require_results) asuint_float4 :: proc "c" (v: float4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } diff --git a/core/math/linalg/hlsl/linalg_hlsl_math.odin b/core/math/linalg/hlsl/linalg_hlsl_math.odin index 5b8004342..92c741f03 100644 --- a/core/math/linalg/hlsl/linalg_hlsl_math.odin +++ b/core/math/linalg/hlsl/linalg_hlsl_math.odin @@ -2,6 +2,42 @@ package math_linalg_hlsl import "core:math" +@(require_results) cos_half :: proc "c" (x: half) -> half { return math.cos(x) } +@(require_results) sin_half :: proc "c" (x: half) -> half { return math.sin(x) } +@(require_results) tan_half :: proc "c" (x: half) -> half { return math.tan(x) } +@(require_results) acos_half :: proc "c" (x: half) -> half { return math.acos(x) } +@(require_results) asin_half :: proc "c" (x: half) -> half { return math.asin(x) } +@(require_results) atan_half :: proc "c" (x: half) -> half { return math.atan(x) } +@(require_results) atan2_half :: proc "c" (y, x: half) -> half { return math.atan2(y, x) } +@(require_results) cosh_half :: proc "c" (x: half) -> half { return math.cosh(x) } +@(require_results) sinh_half :: proc "c" (x: half) -> half { return math.sinh(x) } +@(require_results) tanh_half :: proc "c" (x: half) -> half { return math.tanh(x) } +@(require_results) acosh_half :: proc "c" (x: half) -> half { return math.acosh(x) } +@(require_results) asinh_half :: proc "c" (x: half) -> half { return math.asinh(x) } +@(require_results) atanh_half :: proc "c" (x: half) -> half { return math.atanh(x) } +@(require_results) sqrt_half :: proc "c" (x: half) -> half { return math.sqrt(x) } +@(require_results) rsqrt_half :: proc "c" (x: half) -> half { return 1.0/math.sqrt(x) } +@(require_results) rcp_half :: proc "c" (x: half) -> half { return 1.0/x } +@(require_results) pow_half :: proc "c" (x, y: half) -> half { return math.pow(x, y) } +@(require_results) exp_half :: proc "c" (x: half) -> half { return math.exp(x) } +@(require_results) log_half :: proc "c" (x: half) -> half { return math.ln(x) } +@(require_results) log2_half :: proc "c" (x: half) -> half { return math.log(x, 2) } +@(require_results) log10_half :: proc "c" (x: half) -> half { return math.log(x, 10) } +@(require_results) exp2_half :: proc "c" (x: half) -> half { return math.pow(half(2), x) } +@(require_results) sign_half :: proc "c" (x: half) -> half { return math.sign(x) } +@(require_results) floor_half :: proc "c" (x: half) -> half { return math.floor(x) } +@(require_results) round_half :: proc "c" (x: half) -> half { return math.round(x) } +@(require_results) ceil_half :: proc "c" (x: half) -> half { return math.ceil(x) } +@(require_results) isnan_half :: proc "c" (x: half) -> bool { return math.classify(x) == .NaN} +@(require_results) fmod_half :: proc "c" (x, y: half) -> half { return math.mod(x, y) } +@(require_results) +frac_half :: proc "c" (x: half) -> half { + if x >= 0 { + return x - math.trunc(x) + } + return math.trunc(-x) + x +} + @(require_results) cos_float :: proc "c" (x: float) -> float { return math.cos(x) } @(require_results) sin_float :: proc "c" (x: float) -> float { return math.sin(x) } @(require_results) tan_float :: proc "c" (x: float) -> float { return math.tan(x) }