From 396debb9cb2c3aea3ed447cbd2d02cd162e9466e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:11:18 +0100 Subject: [PATCH] Add `@(require_results)` to `core:math/linalg`'s `glsl` and `hlsl` packages --- core/math/linalg/glsl/linalg_glsl.odin | 994 +++++++------- core/math/linalg/glsl/linalg_glsl_math.odin | 98 +- core/math/linalg/hlsl/linalg_hlsl.odin | 1366 ++++++++++--------- core/math/linalg/hlsl/linalg_hlsl_math.odin | 114 +- 4 files changed, 1307 insertions(+), 1265 deletions(-) diff --git a/core/math/linalg/glsl/linalg_glsl.odin b/core/math/linalg/glsl/linalg_glsl.odin index 0c3f56636..0d91ad4a3 100644 --- a/core/math/linalg/glsl/linalg_glsl.odin +++ b/core/math/linalg/glsl/linalg_glsl.odin @@ -89,12 +89,12 @@ cos :: proc{ cos_dvec3, cos_dvec4, } -cos_vec2 :: proc "c" (x: vec2) -> vec2 { return {cos(x.x), cos(x.y)} } -cos_vec3 :: proc "c" (x: vec3) -> vec3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_vec4 :: proc "c" (x: vec4) -> vec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } -cos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cos(x.x), cos(x.y)} } -cos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_vec2 :: proc "c" (x: vec2) -> vec2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_vec3 :: proc "c" (x: vec3) -> vec3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_vec4 :: proc "c" (x: vec4) -> vec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } sin :: proc{ sin_f32, @@ -106,12 +106,12 @@ sin :: proc{ sin_dvec3, sin_dvec4, } -sin_vec2 :: proc "c" (x: vec2) -> vec2 { return {sin(x.x), sin(x.y)} } -sin_vec3 :: proc "c" (x: vec3) -> vec3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_vec4 :: proc "c" (x: vec4) -> vec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } -sin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sin(x.x), sin(x.y)} } -sin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_vec2 :: proc "c" (x: vec2) -> vec2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_vec3 :: proc "c" (x: vec3) -> vec3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_vec4 :: proc "c" (x: vec4) -> vec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } tan :: proc{ tan_f32, @@ -123,12 +123,12 @@ tan :: proc{ tan_dvec3, tan_dvec4, } -tan_vec2 :: proc "c" (x: vec2) -> vec2 { return {tan(x.x), tan(x.y)} } -tan_vec3 :: proc "c" (x: vec3) -> vec3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_vec4 :: proc "c" (x: vec4) -> vec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } -tan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tan(x.x), tan(x.y)} } -tan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_vec2 :: proc "c" (x: vec2) -> vec2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_vec3 :: proc "c" (x: vec3) -> vec3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_vec4 :: proc "c" (x: vec4) -> vec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } acos :: proc{ acos_f32, @@ -140,12 +140,12 @@ acos :: proc{ acos_dvec3, acos_dvec4, } -acos_vec2 :: proc "c" (x: vec2) -> vec2 { return {acos(x.x), acos(x.y)} } -acos_vec3 :: proc "c" (x: vec3) -> vec3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_vec4 :: proc "c" (x: vec4) -> vec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } -acos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acos(x.x), acos(x.y)} } -acos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_vec2 :: proc "c" (x: vec2) -> vec2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_vec3 :: proc "c" (x: vec3) -> vec3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_vec4 :: proc "c" (x: vec4) -> vec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } asin :: proc{ asin_f32, @@ -157,12 +157,12 @@ asin :: proc{ asin_dvec3, asin_dvec4, } -asin_vec2 :: proc "c" (x: vec2) -> vec2 { return {asin(x.x), asin(x.y)} } -asin_vec3 :: proc "c" (x: vec3) -> vec3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_vec4 :: proc "c" (x: vec4) -> vec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } -asin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asin(x.x), asin(x.y)} } -asin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_vec2 :: proc "c" (x: vec2) -> vec2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_vec3 :: proc "c" (x: vec3) -> vec3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_vec4 :: proc "c" (x: vec4) -> vec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } atan :: proc{ atan_f32, @@ -182,12 +182,12 @@ atan :: proc{ atan2_dvec3, atan2_dvec4, } -atan_vec2 :: proc "c" (x: vec2) -> vec2 { return {atan(x.x), atan(x.y)} } -atan_vec3 :: proc "c" (x: vec3) -> vec3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_vec4 :: proc "c" (x: vec4) -> vec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } -atan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atan(x.x), atan(x.y)} } -atan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_vec2 :: proc "c" (x: vec2) -> vec2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_vec3 :: proc "c" (x: vec3) -> vec3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_vec4 :: proc "c" (x: vec4) -> vec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } atan2 :: proc{ atan2_f32, @@ -199,12 +199,12 @@ atan2 :: proc{ atan2_dvec3, atan2_dvec4, } -atan2_vec2 :: proc "c" (y, x: vec2) -> vec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_vec3 :: proc "c" (y, x: vec3) -> vec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_vec4 :: proc "c" (y, x: vec4) -> vec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } -atan2_dvec2 :: proc "c" (y, x: dvec2) -> dvec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_dvec3 :: proc "c" (y, x: dvec3) -> dvec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_dvec4 :: proc "c" (y, x: dvec4) -> dvec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_vec2 :: proc "c" (y, x: vec2) -> vec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_vec3 :: proc "c" (y, x: vec3) -> vec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_vec4 :: proc "c" (y, x: vec4) -> vec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_dvec2 :: proc "c" (y, x: dvec2) -> dvec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_dvec3 :: proc "c" (y, x: dvec3) -> dvec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_dvec4 :: proc "c" (y, x: dvec4) -> dvec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @@ -218,12 +218,12 @@ cosh :: proc{ cosh_dvec3, cosh_dvec4, } -cosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {cosh(x.x), cosh(x.y)} } -cosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } -cosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cosh(x.x), cosh(x.y)} } -cosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } sinh :: proc{ @@ -236,12 +236,12 @@ sinh :: proc{ sinh_dvec3, sinh_dvec4, } -sinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {sinh(x.x), sinh(x.y)} } -sinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } -sinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sinh(x.x), sinh(x.y)} } -sinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } tanh :: proc{ tanh_f32, @@ -253,12 +253,12 @@ tanh :: proc{ tanh_dvec3, tanh_dvec4, } -tanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {tanh(x.x), tanh(x.y)} } -tanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } -tanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tanh(x.x), tanh(x.y)} } -tanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } acosh :: proc{ acosh_f32, @@ -270,12 +270,12 @@ acosh :: proc{ acosh_dvec3, acosh_dvec4, } -acosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {acosh(x.x), acosh(x.y)} } -acosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } -acosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acosh(x.x), acosh(x.y)} } -acosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } asinh :: proc{ asinh_f32, @@ -287,12 +287,12 @@ asinh :: proc{ asinh_dvec3, asinh_dvec4, } -asinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {asinh(x.x), asinh(x.y)} } -asinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } -asinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asinh(x.x), asinh(x.y)} } -asinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } atanh :: proc{ atanh_f32, @@ -304,12 +304,12 @@ atanh :: proc{ atanh_dvec3, atanh_dvec4, } -atanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {atanh(x.x), atanh(x.y)} } -atanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } -atanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atanh(x.x), atanh(x.y)} } -atanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } sqrt :: proc{ sqrt_f32, @@ -321,12 +321,12 @@ sqrt :: proc{ sqrt_dvec3, sqrt_dvec4, } -sqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } -sqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } rsqrt :: inversesqrt inversesqrt :: proc{ @@ -339,12 +339,12 @@ inversesqrt :: proc{ inversesqrt_dvec3, inversesqrt_dvec4, } -inversesqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } -inversesqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } -inversesqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } -inversesqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } -inversesqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } -inversesqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } +@(require_results) inversesqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } +@(require_results) inversesqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } +@(require_results) inversesqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } +@(require_results) inversesqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } +@(require_results) inversesqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } +@(require_results) inversesqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } pow :: proc{ @@ -357,12 +357,12 @@ pow :: proc{ pow_dvec3, pow_dvec4, } -pow_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } -pow_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @@ -376,12 +376,12 @@ exp :: proc{ exp_dvec3, exp_dvec4, } -exp_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp(x.x), exp(x.y)} } -exp_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } -exp_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp(x.x), exp(x.y)} } -exp_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @@ -395,12 +395,12 @@ log :: proc{ log_dvec3, log_dvec4, } -log_vec2 :: proc "c" (x: vec2) -> vec2 { return {log(x.x), log(x.y)} } -log_vec3 :: proc "c" (x: vec3) -> vec3 { return {log(x.x), log(x.y), log(x.z)} } -log_vec4 :: proc "c" (x: vec4) -> vec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } -log_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {log(x.x), log(x.y)} } -log_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {log(x.x), log(x.y), log(x.z)} } -log_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_vec2 :: proc "c" (x: vec2) -> vec2 { return {log(x.x), log(x.y)} } +@(require_results) log_vec3 :: proc "c" (x: vec3) -> vec3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_vec4 :: proc "c" (x: vec4) -> vec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {log(x.x), log(x.y)} } +@(require_results) log_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } @@ -414,12 +414,12 @@ exp2 :: proc{ exp2_dvec3, exp2_dvec4, } -exp2_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp2(x.x), exp2(x.y)} } -exp2_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } -exp2_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp2(x.x), exp2(x.y)} } -exp2_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } sign :: proc{ @@ -440,20 +440,20 @@ sign :: proc{ sign_uvec3, sign_uvec4, } -sign_i32 :: proc "c" (x: i32) -> i32 { return -1 if x < 0 else +1 if x > 0 else 0 } -sign_u32 :: proc "c" (x: u32) -> u32 { return +1 if x > 0 else 0 } -sign_vec2 :: proc "c" (x: vec2) -> vec2 { return {sign(x.x), sign(x.y)} } -sign_vec3 :: proc "c" (x: vec3) -> vec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_vec4 :: proc "c" (x: vec4) -> vec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sign(x.x), sign(x.y)} } -sign_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {sign(x.x), sign(x.y)} } -sign_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return {sign(x.x), sign(x.y)} } -sign_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_i32 :: proc "c" (x: i32) -> i32 { return -1 if x < 0 else +1 if x > 0 else 0 } +@(require_results) sign_u32 :: proc "c" (x: u32) -> u32 { return +1 if x > 0 else 0 } +@(require_results) sign_vec2 :: proc "c" (x: vec2) -> vec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_vec3 :: proc "c" (x: vec3) -> vec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_vec4 :: proc "c" (x: vec4) -> vec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } floor :: proc{ floor_f32, @@ -465,12 +465,12 @@ floor :: proc{ floor_dvec3, floor_dvec4, } -floor_vec2 :: proc "c" (x: vec2) -> vec2 { return {floor(x.x), floor(x.y)} } -floor_vec3 :: proc "c" (x: vec3) -> vec3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_vec4 :: proc "c" (x: vec4) -> vec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } -floor_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {floor(x.x), floor(x.y)} } -floor_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_vec2 :: proc "c" (x: vec2) -> vec2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_vec3 :: proc "c" (x: vec3) -> vec3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_vec4 :: proc "c" (x: vec4) -> vec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } @@ -484,12 +484,12 @@ round :: proc{ round_dvec3, round_dvec4, } -round_vec2 :: proc "c" (x: vec2) -> vec2 { return {round(x.x), round(x.y)} } -round_vec3 :: proc "c" (x: vec3) -> vec3 { return {round(x.x), round(x.y), round(x.z)} } -round_vec4 :: proc "c" (x: vec4) -> vec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } -round_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {round(x.x), round(x.y)} } -round_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {round(x.x), round(x.y), round(x.z)} } -round_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_vec2 :: proc "c" (x: vec2) -> vec2 { return {round(x.x), round(x.y)} } +@(require_results) round_vec3 :: proc "c" (x: vec3) -> vec3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_vec4 :: proc "c" (x: vec4) -> vec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {round(x.x), round(x.y)} } +@(require_results) round_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } ceil :: proc{ @@ -502,12 +502,12 @@ ceil :: proc{ ceil_dvec3, ceil_dvec4, } -ceil_vec2 :: proc "c" (x: vec2) -> vec2 { return {ceil(x.x), ceil(x.y)} } -ceil_vec3 :: proc "c" (x: vec3) -> vec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_vec4 :: proc "c" (x: vec4) -> vec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -ceil_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {ceil(x.x), ceil(x.y)} } -ceil_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_vec2 :: proc "c" (x: vec2) -> vec2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_vec3 :: proc "c" (x: vec3) -> vec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_vec4 :: proc "c" (x: vec4) -> vec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } mod :: proc{ @@ -520,12 +520,12 @@ mod :: proc{ mod_dvec3, mod_dvec4, } -mod_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } -mod_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } -mod_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } -mod_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } -mod_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } -mod_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } +@(require_results) mod_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } +@(require_results) mod_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } +@(require_results) mod_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } +@(require_results) mod_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } +@(require_results) mod_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } +@(require_results) mod_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } fract :: proc{ @@ -538,12 +538,12 @@ fract :: proc{ fract_dvec3, fract_dvec4, } -fract_vec2 :: proc "c" (x: vec2) -> vec2 { return {fract(x.x), fract(x.y)} } -fract_vec3 :: proc "c" (x: vec3) -> vec3 { return {fract(x.x), fract(x.y), fract(x.z)} } -fract_vec4 :: proc "c" (x: vec4) -> vec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } -fract_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {fract(x.x), fract(x.y)} } -fract_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {fract(x.x), fract(x.y), fract(x.z)} } -fract_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } +@(require_results) fract_vec2 :: proc "c" (x: vec2) -> vec2 { return {fract(x.x), fract(x.y)} } +@(require_results) fract_vec3 :: proc "c" (x: vec3) -> vec3 { return {fract(x.x), fract(x.y), fract(x.z)} } +@(require_results) fract_vec4 :: proc "c" (x: vec4) -> vec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } +@(require_results) fract_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {fract(x.x), fract(x.y)} } +@(require_results) fract_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {fract(x.x), fract(x.y), fract(x.z)} } +@(require_results) fract_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } @@ -557,14 +557,14 @@ radians :: proc{ radians_dvec3, radians_dvec4, } -radians_f32 :: proc "c" (degrees: f32) -> f32 { return degrees * TAU / 360.0 } -radians_f64 :: proc "c" (degrees: f64) -> f64 { return degrees * TAU / 360.0 } -radians_vec2 :: proc "c" (degrees: vec2) -> vec2 { return degrees * TAU / 360.0 } -radians_vec3 :: proc "c" (degrees: vec3) -> vec3 { return degrees * TAU / 360.0 } -radians_vec4 :: proc "c" (degrees: vec4) -> vec4 { return degrees * TAU / 360.0 } -radians_dvec2 :: proc "c" (degrees: dvec2) -> dvec2 { return degrees * TAU / 360.0 } -radians_dvec3 :: proc "c" (degrees: dvec3) -> dvec3 { return degrees * TAU / 360.0 } -radians_dvec4 :: proc "c" (degrees: dvec4) -> dvec4 { return degrees * TAU / 360.0 } +@(require_results) radians_f32 :: proc "c" (degrees: f32) -> f32 { return degrees * TAU / 360.0 } +@(require_results) radians_f64 :: proc "c" (degrees: f64) -> f64 { return degrees * TAU / 360.0 } +@(require_results) radians_vec2 :: proc "c" (degrees: vec2) -> vec2 { return degrees * TAU / 360.0 } +@(require_results) radians_vec3 :: proc "c" (degrees: vec3) -> vec3 { return degrees * TAU / 360.0 } +@(require_results) radians_vec4 :: proc "c" (degrees: vec4) -> vec4 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec2 :: proc "c" (degrees: dvec2) -> dvec2 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec3 :: proc "c" (degrees: dvec3) -> dvec3 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec4 :: proc "c" (degrees: dvec4) -> dvec4 { return degrees * TAU / 360.0 } degrees :: proc{ @@ -577,14 +577,14 @@ degrees :: proc{ degrees_dvec3, degrees_dvec4, } -degrees_f32 :: proc "c" (radians: f32) -> f32 { return radians * 360.0 / TAU } -degrees_f64 :: proc "c" (radians: f64) -> f64 { return radians * 360.0 / TAU } -degrees_vec2 :: proc "c" (radians: vec2) -> vec2 { return radians * 360.0 / TAU } -degrees_vec3 :: proc "c" (radians: vec3) -> vec3 { return radians * 360.0 / TAU } -degrees_vec4 :: proc "c" (radians: vec4) -> vec4 { return radians * 360.0 / TAU } -degrees_dvec2 :: proc "c" (radians: dvec2) -> dvec2 { return radians * 360.0 / TAU } -degrees_dvec3 :: proc "c" (radians: dvec3) -> dvec3 { return radians * 360.0 / TAU } -degrees_dvec4 :: proc "c" (radians: dvec4) -> dvec4 { return radians * 360.0 / TAU } +@(require_results) degrees_f32 :: proc "c" (radians: f32) -> f32 { return radians * 360.0 / TAU } +@(require_results) degrees_f64 :: proc "c" (radians: f64) -> f64 { return radians * 360.0 / TAU } +@(require_results) degrees_vec2 :: proc "c" (radians: vec2) -> vec2 { return radians * 360.0 / TAU } +@(require_results) degrees_vec3 :: proc "c" (radians: vec3) -> vec3 { return radians * 360.0 / TAU } +@(require_results) degrees_vec4 :: proc "c" (radians: vec4) -> vec4 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec2 :: proc "c" (radians: dvec2) -> dvec2 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec3 :: proc "c" (radians: dvec3) -> dvec3 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec4 :: proc "c" (radians: dvec4) -> dvec4 { return radians * 360.0 / TAU } min :: proc{ min_i32, @@ -604,22 +604,22 @@ min :: proc{ min_uvec3, min_uvec4, } -min_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.min(x, y) } -min_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.min(x, y) } -min_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.min(x, y) } -min_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.min(x, y) } -min_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.min(x, y) } +@(require_results) min_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.min(x, y) } +@(require_results) min_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.min(x, y) } +@(require_results) min_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.min(x, y) } +@(require_results) min_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } max :: proc{ @@ -640,22 +640,22 @@ max :: proc{ max_uvec3, max_uvec4, } -max_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.max(x, y) } -max_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.max(x, y) } -max_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.max(x, y) } -max_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.max(x, y) } -max_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.max(x, y) } +@(require_results) max_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.max(x, y) } +@(require_results) max_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.max(x, y) } +@(require_results) max_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.max(x, y) } +@(require_results) max_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @@ -677,22 +677,22 @@ clamp :: proc{ clamp_uvec3, clamp_uvec4, } -clamp_i32 :: proc "c" (x, y, z: i32) -> i32 { return builtin.clamp(x, y, z) } -clamp_u32 :: proc "c" (x, y, z: u32) -> u32 { return builtin.clamp(x, y, z) } -clamp_f32 :: proc "c" (x, y, z: f32) -> f32 { return builtin.clamp(x, y, z) } -clamp_f64 :: proc "c" (x, y, z: f64) -> f64 { return builtin.clamp(x, y, z) } -clamp_vec2 :: proc "c" (x, y, z: vec2) -> vec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_vec3 :: proc "c" (x, y, z: vec3) -> vec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_vec4 :: proc "c" (x, y, z: vec4) -> vec4 { 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)} } -clamp_dvec2 :: proc "c" (x, y, z: dvec2) -> dvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_dvec3 :: proc "c" (x, y, z: dvec3) -> dvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_dvec4 :: proc "c" (x, y, z: dvec4) -> dvec4 { 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)} } -clamp_ivec2 :: proc "c" (x, y, z: ivec2) -> ivec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_ivec3 :: proc "c" (x, y, z: ivec3) -> ivec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_ivec4 :: proc "c" (x, y, z: ivec4) -> ivec4 { 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)} } -clamp_uvec2 :: proc "c" (x, y, z: uvec2) -> uvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_uvec3 :: proc "c" (x, y, z: uvec3) -> uvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_uvec4 :: proc "c" (x, y, z: uvec4) -> uvec4 { 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_i32 :: proc "c" (x, y, z: i32) -> i32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_u32 :: proc "c" (x, y, z: u32) -> u32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_f32 :: proc "c" (x, y, z: f32) -> f32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_f64 :: proc "c" (x, y, z: f64) -> f64 { return builtin.clamp(x, y, z) } +@(require_results) clamp_vec2 :: proc "c" (x, y, z: vec2) -> vec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_vec3 :: proc "c" (x, y, z: vec3) -> vec3 { 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_vec4 :: proc "c" (x, y, z: vec4) -> vec4 { 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_dvec2 :: proc "c" (x, y, z: dvec2) -> dvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_dvec3 :: proc "c" (x, y, z: dvec3) -> dvec3 { 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_dvec4 :: proc "c" (x, y, z: dvec4) -> dvec4 { 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_ivec2 :: proc "c" (x, y, z: ivec2) -> ivec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_ivec3 :: proc "c" (x, y, z: ivec3) -> ivec3 { 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_ivec4 :: proc "c" (x, y, z: ivec4) -> ivec4 { 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_uvec2 :: proc "c" (x, y, z: uvec2) -> uvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_uvec3 :: proc "c" (x, y, z: uvec3) -> uvec3 { 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_uvec4 :: proc "c" (x, y, z: uvec4) -> uvec4 { 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)} } saturate :: proc{ saturate_i32, @@ -712,22 +712,22 @@ saturate :: proc{ saturate_uvec3, saturate_uvec4, } -saturate_i32 :: proc "c" (v: i32) -> i32 { return builtin.clamp(v, 0, 1) } -saturate_u32 :: proc "c" (v: u32) -> u32 { return builtin.clamp(v, 0, 1) } -saturate_f32 :: proc "c" (v: f32) -> f32 { return builtin.clamp(v, 0, 1) } -saturate_f64 :: proc "c" (v: f64) -> f64 { return builtin.clamp(v, 0, 1) } -saturate_vec2 :: proc "c" (v: vec2) -> vec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_vec3 :: proc "c" (v: vec3) -> vec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_vec4 :: proc "c" (v: vec4) -> vec4 { 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)} } -saturate_dvec2 :: proc "c" (v: dvec2) -> dvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_dvec3 :: proc "c" (v: dvec3) -> dvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_dvec4 :: proc "c" (v: dvec4) -> dvec4 { 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)} } -saturate_ivec2 :: proc "c" (v: ivec2) -> ivec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_ivec3 :: proc "c" (v: ivec3) -> ivec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_ivec4 :: proc "c" (v: ivec4) -> ivec4 { 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)} } -saturate_uvec2 :: proc "c" (v: uvec2) -> uvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_uvec3 :: proc "c" (v: uvec3) -> uvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_uvec4 :: proc "c" (v: uvec4) -> uvec4 { 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_i32 :: proc "c" (v: i32) -> i32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_u32 :: proc "c" (v: u32) -> u32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_f32 :: proc "c" (v: f32) -> f32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_f64 :: proc "c" (v: f64) -> f64 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_vec2 :: proc "c" (v: vec2) -> vec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_vec3 :: proc "c" (v: vec3) -> vec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_vec4 :: proc "c" (v: vec4) -> vec4 { 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_dvec2 :: proc "c" (v: dvec2) -> dvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_dvec3 :: proc "c" (v: dvec3) -> dvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_dvec4 :: proc "c" (v: dvec4) -> dvec4 { 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_ivec2 :: proc "c" (v: ivec2) -> ivec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_ivec3 :: proc "c" (v: ivec3) -> ivec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_ivec4 :: proc "c" (v: ivec4) -> ivec4 { 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_uvec2 :: proc "c" (v: uvec2) -> uvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_uvec3 :: proc "c" (v: uvec3) -> uvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_uvec4 :: proc "c" (v: uvec4) -> uvec4 { 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)} } mix :: proc{ mix_f32, @@ -739,14 +739,14 @@ mix :: proc{ mix_dvec3, mix_dvec4, } -mix_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } -mix_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } -mix_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } -mix_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } -mix_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } -mix_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } -mix_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } -mix_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } +@(require_results) mix_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } +@(require_results) mix_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } +@(require_results) mix_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } +@(require_results) mix_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } +@(require_results) mix_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } +@(require_results) mix_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } +@(require_results) mix_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } +@(require_results) mix_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } lerp :: proc{ lerp_f32, @@ -758,14 +758,14 @@ lerp :: proc{ lerp_dvec3, lerp_dvec4, } -lerp_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } -lerp_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } -lerp_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } -lerp_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } +@(require_results) lerp_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } +@(require_results) lerp_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { 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_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { 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_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } step :: proc{ @@ -778,14 +778,14 @@ step :: proc{ step_dvec3, step_dvec4, } -step_f32 :: proc "c" (edge, x: f32) -> f32 { return 0 if x < edge else 1 } -step_f64 :: proc "c" (edge, x: f64) -> f64 { return 0 if x < edge else 1 } -step_vec2 :: proc "c" (edge, x: vec2) -> vec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_vec3 :: proc "c" (edge, x: vec3) -> vec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_vec4 :: proc "c" (edge, x: vec4) -> vec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } -step_dvec2 :: proc "c" (edge, x: dvec2) -> dvec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_dvec3 :: proc "c" (edge, x: dvec3) -> dvec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_dvec4 :: proc "c" (edge, x: dvec4) -> dvec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_f32 :: proc "c" (edge, x: f32) -> f32 { return 0 if x < edge else 1 } +@(require_results) step_f64 :: proc "c" (edge, x: f64) -> f64 { return 0 if x < edge else 1 } +@(require_results) step_vec2 :: proc "c" (edge, x: vec2) -> vec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_vec3 :: proc "c" (edge, x: vec3) -> vec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_vec4 :: proc "c" (edge, x: vec4) -> vec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_dvec2 :: proc "c" (edge, x: dvec2) -> dvec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_dvec3 :: proc "c" (edge, x: dvec3) -> dvec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_dvec4 :: proc "c" (edge, x: dvec4) -> dvec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } smoothstep :: proc{ smoothstep_f32, @@ -797,20 +797,20 @@ smoothstep :: proc{ smoothstep_dvec3, smoothstep_dvec4, } -smoothstep_f32 :: proc "c" (edge0, edge1, x: f32) -> f32 { +@(require_results) smoothstep_f32 :: proc "c" (edge0, edge1, x: f32) -> f32 { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_f64 :: proc "c" (edge0, edge1, x: f64) -> f64 { +@(require_results) smoothstep_f64 :: proc "c" (edge0, edge1, x: f64) -> f64 { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_vec2 :: proc "c" (edge0, edge1, x: vec2) -> vec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_vec3 :: proc "c" (edge0, edge1, x: vec3) -> vec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_vec4 :: proc "c" (edge0, edge1, x: vec4) -> vec4 { 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)} } -smoothstep_dvec2 :: proc "c" (edge0, edge1, x: dvec2) -> dvec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_dvec3 :: proc "c" (edge0, edge1, x: dvec3) -> dvec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_dvec4 :: proc "c" (edge0, edge1, x: dvec4) -> dvec4 { 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_vec2 :: proc "c" (edge0, edge1, x: vec2) -> vec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_vec3 :: proc "c" (edge0, edge1, x: vec3) -> vec3 { 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_vec4 :: proc "c" (edge0, edge1, x: vec4) -> vec4 { 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_dvec2 :: proc "c" (edge0, edge1, x: dvec2) -> dvec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_dvec3 :: proc "c" (edge0, edge1, x: dvec3) -> dvec3 { 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_dvec4 :: proc "c" (edge0, edge1, x: dvec4) -> dvec4 { 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)} } abs :: proc{ @@ -831,22 +831,22 @@ abs :: proc{ abs_uvec3, abs_uvec4, } -abs_i32 :: proc "c" (x: i32) -> i32 { return builtin.abs(x) } -abs_u32 :: proc "c" (x: u32) -> u32 { return x } -abs_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } -abs_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } -abs_vec2 :: proc "c" (x: vec2) -> vec2 { return {abs(x.x), abs(x.y)} } -abs_vec3 :: proc "c" (x: vec3) -> vec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_vec4 :: proc "c" (x: vec4) -> vec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {abs(x.x), abs(x.y)} } -abs_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {abs(x.x), abs(x.y)} } -abs_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return x } -abs_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return x } -abs_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return x } +@(require_results) abs_i32 :: proc "c" (x: i32) -> i32 { return builtin.abs(x) } +@(require_results) abs_u32 :: proc "c" (x: u32) -> u32 { return x } +@(require_results) abs_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } +@(require_results) abs_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } +@(require_results) abs_vec2 :: proc "c" (x: vec2) -> vec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_vec3 :: proc "c" (x: vec3) -> vec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_vec4 :: proc "c" (x: vec4) -> vec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return x } +@(require_results) abs_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return x } +@(require_results) abs_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return x } dot :: proc{ dot_i32, @@ -868,24 +868,24 @@ dot :: proc{ dot_quat, dot_dquat, } -dot_i32 :: proc "c" (a, b: i32) -> i32 { return a*b } -dot_u32 :: proc "c" (a, b: u32) -> u32 { return a*b } -dot_f32 :: proc "c" (a, b: f32) -> f32 { return a*b } -dot_f64 :: proc "c" (a, b: f64) -> f64 { return a*b } -dot_vec2 :: proc "c" (a, b: vec2) -> f32 { return a.x*b.x + a.y*b.y } -dot_vec3 :: proc "c" (a, b: vec3) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_vec4 :: proc "c" (a, b: vec4) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_dvec2 :: proc "c" (a, b: dvec2) -> f64 { return a.x*b.x + a.y*b.y } -dot_dvec3 :: proc "c" (a, b: dvec3) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_dvec4 :: proc "c" (a, b: dvec4) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_ivec2 :: proc "c" (a, b: ivec2) -> i32 { return a.x*b.x + a.y*b.y } -dot_ivec3 :: proc "c" (a, b: ivec3) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_ivec4 :: proc "c" (a, b: ivec4) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_uvec2 :: proc "c" (a, b: uvec2) -> u32 { return a.x*b.x + a.y*b.y } -dot_uvec3 :: proc "c" (a, b: uvec3) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_uvec4 :: proc "c" (a, b: uvec4) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_quat :: proc "c" (a, b: quat) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_dquat :: proc "c" (a, b: dquat) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_i32 :: proc "c" (a, b: i32) -> i32 { return a*b } +@(require_results) dot_u32 :: proc "c" (a, b: u32) -> u32 { return a*b } +@(require_results) dot_f32 :: proc "c" (a, b: f32) -> f32 { return a*b } +@(require_results) dot_f64 :: proc "c" (a, b: f64) -> f64 { return a*b } +@(require_results) dot_vec2 :: proc "c" (a, b: vec2) -> f32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_vec3 :: proc "c" (a, b: vec3) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_vec4 :: proc "c" (a, b: vec4) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_dvec2 :: proc "c" (a, b: dvec2) -> f64 { return a.x*b.x + a.y*b.y } +@(require_results) dot_dvec3 :: proc "c" (a, b: dvec3) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_dvec4 :: proc "c" (a, b: dvec4) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_ivec2 :: proc "c" (a, b: ivec2) -> i32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_ivec3 :: proc "c" (a, b: ivec3) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_ivec4 :: proc "c" (a, b: ivec4) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_uvec2 :: proc "c" (a, b: uvec2) -> u32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_uvec3 :: proc "c" (a, b: uvec3) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_uvec4 :: proc "c" (a, b: uvec4) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_quat :: proc "c" (a, b: quat) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_dquat :: proc "c" (a, b: dquat) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } length :: proc{ length_f32, @@ -899,16 +899,16 @@ length :: proc{ length_quat, length_dquat, } -length_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } -length_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } -length_vec2 :: proc "c" (x: vec2) -> f32 { return sqrt(x.x*x.x + x.y*x.y) } -length_vec3 :: proc "c" (x: vec3) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_vec4 :: proc "c" (x: vec4) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_dvec2 :: proc "c" (x: dvec2) -> f64 { return sqrt(x.x*x.x + x.y*x.y) } -length_dvec3 :: proc "c" (x: dvec3) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_dvec4 :: proc "c" (x: dvec4) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_quat :: proc "c" (x: quat) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_dquat :: proc "c" (x: dquat) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } +@(require_results) length_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } +@(require_results) length_vec2 :: proc "c" (x: vec2) -> f32 { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_vec3 :: proc "c" (x: vec3) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_vec4 :: proc "c" (x: vec4) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_dvec2 :: proc "c" (x: dvec2) -> f64 { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_dvec3 :: proc "c" (x: dvec3) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_dvec4 :: proc "c" (x: dvec4) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_quat :: proc "c" (x: quat) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_dquat :: proc "c" (x: dquat) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } distance :: proc{ @@ -921,14 +921,14 @@ distance :: proc{ distance_dvec3, distance_dvec4, } -distance_f32 :: proc "c" (x, y: f32) -> f32 { return length(y-x) } -distance_f64 :: proc "c" (x, y: f64) -> f64 { return length(y-x) } -distance_vec2 :: proc "c" (x, y: vec2) -> f32 { return length(y-x) } -distance_vec3 :: proc "c" (x, y: vec3) -> f32 { return length(y-x) } -distance_vec4 :: proc "c" (x, y: vec4) -> f32 { return length(y-x) } -distance_dvec2 :: proc "c" (x, y: dvec2) -> f64 { return length(y-x) } -distance_dvec3 :: proc "c" (x, y: dvec3) -> f64 { return length(y-x) } -distance_dvec4 :: proc "c" (x, y: dvec4) -> f64 { return length(y-x) } +@(require_results) distance_f32 :: proc "c" (x, y: f32) -> f32 { return length(y-x) } +@(require_results) distance_f64 :: proc "c" (x, y: f64) -> f64 { return length(y-x) } +@(require_results) distance_vec2 :: proc "c" (x, y: vec2) -> f32 { return length(y-x) } +@(require_results) distance_vec3 :: proc "c" (x, y: vec3) -> f32 { return length(y-x) } +@(require_results) distance_vec4 :: proc "c" (x, y: vec4) -> f32 { return length(y-x) } +@(require_results) distance_dvec2 :: proc "c" (x, y: dvec2) -> f64 { return length(y-x) } +@(require_results) distance_dvec3 :: proc "c" (x, y: dvec3) -> f64 { return length(y-x) } +@(require_results) distance_dvec4 :: proc "c" (x, y: dvec4) -> f64 { return length(y-x) } cross :: proc{ @@ -937,19 +937,19 @@ cross :: proc{ cross_ivec3, } -cross_vec3 :: proc "c" (a, b: vec3) -> (c: vec3) { +@(require_results) cross_vec3 :: proc "c" (a, b: vec3) -> (c: vec3) { 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 } -cross_dvec3 :: proc "c" (a, b: dvec3) -> (c: dvec3) { +@(require_results) cross_dvec3 :: proc "c" (a, b: dvec3) -> (c: dvec3) { 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 } -cross_ivec3 :: proc "c" (a, b: ivec3) -> (c: ivec3) { +@(require_results) cross_ivec3 :: proc "c" (a, b: ivec3) -> (c: ivec3) { 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 @@ -968,16 +968,16 @@ normalize :: proc{ normalize_quat, normalize_dquat, } -normalize_f32 :: proc "c" (x: f32) -> f32 { return 1.0 } -normalize_f64 :: proc "c" (x: f64) -> f64 { return 1.0 } -normalize_vec2 :: proc "c" (x: vec2) -> vec2 { return x / length(x) } -normalize_vec3 :: proc "c" (x: vec3) -> vec3 { return x / length(x) } -normalize_vec4 :: proc "c" (x: vec4) -> vec4 { return x / length(x) } -normalize_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return x / length(x) } -normalize_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return x / length(x) } -normalize_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return x / length(x) } -normalize_quat :: proc "c" (x: quat) -> quat { return x / quat(length(x)) } -normalize_dquat :: proc "c" (x: dquat) -> dquat { return x / dquat(length(x)) } +@(require_results) normalize_f32 :: proc "c" (x: f32) -> f32 { return 1.0 } +@(require_results) normalize_f64 :: proc "c" (x: f64) -> f64 { return 1.0 } +@(require_results) normalize_vec2 :: proc "c" (x: vec2) -> vec2 { return x / length(x) } +@(require_results) normalize_vec3 :: proc "c" (x: vec3) -> vec3 { return x / length(x) } +@(require_results) normalize_vec4 :: proc "c" (x: vec4) -> vec4 { return x / length(x) } +@(require_results) normalize_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return x / length(x) } +@(require_results) normalize_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return x / length(x) } +@(require_results) normalize_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return x / length(x) } +@(require_results) normalize_quat :: proc "c" (x: quat) -> quat { return x / quat(length(x)) } +@(require_results) normalize_dquat :: proc "c" (x: dquat) -> dquat { return x / dquat(length(x)) } faceForward :: proc{ @@ -990,14 +990,14 @@ faceForward :: proc{ faceForward_dvec3, faceForward_dvec4, } -faceForward_f32 :: proc "c" (N, I, Nref: f32) -> f32 { return N if dot(I, Nref) < 0 else -N } -faceForward_f64 :: proc "c" (N, I, Nref: f64) -> f64 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec2 :: proc "c" (N, I, Nref: vec2) -> vec2 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec3 :: proc "c" (N, I, Nref: vec3) -> vec3 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec4 :: proc "c" (N, I, Nref: vec4) -> vec4 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec2 :: proc "c" (N, I, Nref: dvec2) -> dvec2 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec3 :: proc "c" (N, I, Nref: dvec3) -> dvec3 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec4 :: proc "c" (N, I, Nref: dvec4) -> dvec4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_f32 :: proc "c" (N, I, Nref: f32) -> f32 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_f64 :: proc "c" (N, I, Nref: f64) -> f64 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec2 :: proc "c" (N, I, Nref: vec2) -> vec2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec3 :: proc "c" (N, I, Nref: vec3) -> vec3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec4 :: proc "c" (N, I, Nref: vec4) -> vec4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec2 :: proc "c" (N, I, Nref: dvec2) -> dvec2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec3 :: proc "c" (N, I, Nref: dvec3) -> dvec3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec4 :: proc "c" (N, I, Nref: dvec4) -> dvec4 { return N if dot(I, Nref) < 0 else -N } reflect :: proc{ @@ -1010,14 +1010,14 @@ reflect :: proc{ reflect_dvec3, reflect_dvec4, } -reflect_f32 :: proc "c" (I, N: f32) -> f32 { return I - 2*N*dot(N, I) } -reflect_f64 :: proc "c" (I, N: f64) -> f64 { return I - 2*N*dot(N, I) } -reflect_vec2 :: proc "c" (I, N: vec2) -> vec2 { return I - 2*N*dot(N, I) } -reflect_vec3 :: proc "c" (I, N: vec3) -> vec3 { return I - 2*N*dot(N, I) } -reflect_vec4 :: proc "c" (I, N: vec4) -> vec4 { return I - 2*N*dot(N, I) } -reflect_dvec2 :: proc "c" (I, N: dvec2) -> dvec2 { return I - 2*N*dot(N, I) } -reflect_dvec3 :: proc "c" (I, N: dvec3) -> dvec3 { return I - 2*N*dot(N, I) } -reflect_dvec4 :: proc "c" (I, N: dvec4) -> dvec4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_f32 :: proc "c" (I, N: f32) -> f32 { return I - 2*N*dot(N, I) } +@(require_results) reflect_f64 :: proc "c" (I, N: f64) -> f64 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec2 :: proc "c" (I, N: vec2) -> vec2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec3 :: proc "c" (I, N: vec3) -> vec3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec4 :: proc "c" (I, N: vec4) -> vec4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec2 :: proc "c" (I, N: dvec2) -> dvec2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec3 :: proc "c" (I, N: dvec3) -> dvec3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec4 :: proc "c" (I, N: dvec4) -> dvec4 { return I - 2*N*dot(N, I) } @@ -1032,49 +1032,49 @@ refract :: proc{ refract_dvec3, refract_dvec4, } -refract_f32 :: proc "c" (i, n, eta: f32) -> f32 { +@(require_results) refract_f32 :: proc "c" (i, n, eta: f32) -> f32 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * f32(i32(cost2 > 0)) } -refract_f64 :: proc "c" (i, n, eta: f64) -> f64 { +@(require_results) refract_f64 :: proc "c" (i, n, eta: f64) -> f64 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * f64(i32(cost2 > 0)) } -refract_vec2 :: proc "c" (i, n, eta: vec2) -> vec2 { +@(require_results) refract_vec2 :: proc "c" (i, n, eta: vec2) -> vec2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec2{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0))} } -refract_vec3 :: proc "c" (i, n, eta: vec3) -> vec3 { +@(require_results) refract_vec3 :: proc "c" (i, n, eta: vec3) -> vec3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec3{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0)), f32(i32(cost2.z > 0))} } -refract_vec4 :: proc "c" (i, n, eta: vec4) -> vec4 { +@(require_results) refract_vec4 :: proc "c" (i, n, eta: vec4) -> vec4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec4{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0)), f32(i32(cost2.z > 0)), f32(i32(cost2.w > 0))} } -refract_dvec2 :: proc "c" (i, n, eta: dvec2) -> dvec2 { +@(require_results) refract_dvec2 :: proc "c" (i, n, eta: dvec2) -> dvec2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * dvec2{f64(i32(cost2.x > 0)), f64(i32(cost2.y > 0))} } -refract_dvec3 :: proc "c" (i, n, eta: dvec3) -> dvec3 { +@(require_results) refract_dvec3 :: proc "c" (i, n, eta: dvec3) -> dvec3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * dvec3{f64(i32(cost2.x > 0)), f64(i32(cost2.y > 0)), f64(i32(cost2.z > 0))} } -refract_dvec4 :: proc "c" (i, n, eta: dvec4) -> dvec4 { +@(require_results) refract_dvec4 :: proc "c" (i, n, eta: dvec4) -> dvec4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) @@ -1086,18 +1086,18 @@ scalarTripleProduct :: proc{ scalarTripleProduct_dvec3, scalarTripleProduct_ivec3, } -scalarTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> f32 { return dot(a, cross(b, c)) } -scalarTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> f64 { return dot(a, cross(b, c)) } -scalarTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> i32 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> f32 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> f64 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> i32 { return dot(a, cross(b, c)) } vectorTripleProduct :: proc { vectorTripleProduct_vec3, vectorTripleProduct_dvec3, vectorTripleProduct_ivec3, } -vectorTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> vec3 { return cross(a, cross(b, c)) } -vectorTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> dvec3 { return cross(a, cross(b, c)) } -vectorTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> ivec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> vec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> dvec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> ivec3 { return cross(a, cross(b, c)) } // Vector Relational Procedures @@ -1120,22 +1120,22 @@ lessThan :: proc{ lessThan_ivec4, lessThan_uvec4, } -lessThan_f32 :: proc "c" (a, b: f32) -> bool { return a < b } -lessThan_f64 :: proc "c" (a, b: f64) -> bool { return a < b } -lessThan_i32 :: proc "c" (a, b: i32) -> bool { return a < b } -lessThan_u32 :: proc "c" (a, b: u32) -> bool { return a < b } -lessThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_f32 :: proc "c" (a, b: f32) -> bool { return a < b } +@(require_results) lessThan_f64 :: proc "c" (a, b: f64) -> bool { return a < b } +@(require_results) lessThan_i32 :: proc "c" (a, b: i32) -> bool { return a < b } +@(require_results) lessThan_u32 :: proc "c" (a, b: u32) -> bool { return a < b } +@(require_results) lessThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } lessThanEqual :: proc{ @@ -1156,22 +1156,22 @@ lessThanEqual :: proc{ lessThanEqual_ivec4, lessThanEqual_uvec4, } -lessThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a <= b } -lessThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a <= b } -lessThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a <= b } -lessThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a <= b } -lessThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a <= b } +@(require_results) lessThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a <= b } +@(require_results) lessThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a <= b } +@(require_results) lessThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a <= b } +@(require_results) lessThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } greaterThan :: proc{ @@ -1192,22 +1192,22 @@ greaterThan :: proc{ greaterThan_ivec4, greaterThan_uvec4, } -greaterThan_f32 :: proc "c" (a, b: f32) -> bool { return a > b } -greaterThan_f64 :: proc "c" (a, b: f64) -> bool { return a > b } -greaterThan_i32 :: proc "c" (a, b: i32) -> bool { return a > b } -greaterThan_u32 :: proc "c" (a, b: u32) -> bool { return a > b } -greaterThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_f32 :: proc "c" (a, b: f32) -> bool { return a > b } +@(require_results) greaterThan_f64 :: proc "c" (a, b: f64) -> bool { return a > b } +@(require_results) greaterThan_i32 :: proc "c" (a, b: i32) -> bool { return a > b } +@(require_results) greaterThan_u32 :: proc "c" (a, b: u32) -> bool { return a > b } +@(require_results) greaterThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } greaterThanEqual :: proc{ @@ -1228,22 +1228,22 @@ greaterThanEqual :: proc{ greaterThanEqual_ivec4, greaterThanEqual_uvec4, } -greaterThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a >= b } -greaterThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a >= b } -greaterThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a >= b } -greaterThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a >= b } -greaterThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a >= b } +@(require_results) greaterThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a >= b } +@(require_results) greaterThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a >= b } +@(require_results) greaterThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a >= b } +@(require_results) greaterThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } equal :: proc{ @@ -1264,22 +1264,22 @@ equal :: proc{ equal_ivec4, equal_uvec4, } -equal_f32 :: proc "c" (a, b: f32) -> bool { return a == b } -equal_f64 :: proc "c" (a, b: f64) -> bool { return a == b } -equal_i32 :: proc "c" (a, b: i32) -> bool { return a == b } -equal_u32 :: proc "c" (a, b: u32) -> bool { return a == b } -equal_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_f32 :: proc "c" (a, b: f32) -> bool { return a == b } +@(require_results) equal_f64 :: proc "c" (a, b: f64) -> bool { return a == b } +@(require_results) equal_i32 :: proc "c" (a, b: i32) -> bool { return a == b } +@(require_results) equal_u32 :: proc "c" (a, b: u32) -> bool { return a == b } +@(require_results) equal_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } notEqual :: proc{ notEqual_f32, @@ -1299,22 +1299,22 @@ notEqual :: proc{ notEqual_ivec4, notEqual_uvec4, } -notEqual_f32 :: proc "c" (a, b: f32) -> bool { return a != b } -notEqual_f64 :: proc "c" (a, b: f64) -> bool { return a != b } -notEqual_i32 :: proc "c" (a, b: i32) -> bool { return a != b } -notEqual_u32 :: proc "c" (a, b: u32) -> bool { return a != b } -notEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_f32 :: proc "c" (a, b: f32) -> bool { return a != b } +@(require_results) notEqual_f64 :: proc "c" (a, b: f64) -> bool { return a != b } +@(require_results) notEqual_i32 :: proc "c" (a, b: i32) -> bool { return a != b } +@(require_results) notEqual_u32 :: proc "c" (a, b: u32) -> bool { return a != b } +@(require_results) notEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } any :: proc{ @@ -1323,10 +1323,10 @@ any :: proc{ any_bvec3, any_bvec4, } -any_bool :: proc "c" (v: bool) -> bool { return v } -any_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x || v.y } -any_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x || v.y || v.z } -any_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x || v.y || v.z || v.w } +@(require_results) any_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) any_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x || v.y } +@(require_results) any_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x || v.y || v.z } +@(require_results) any_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x || v.y || v.z || v.w } all :: proc{ all_bool, @@ -1334,10 +1334,10 @@ all :: proc{ all_bvec3, all_bvec4, } -all_bool :: proc "c" (v: bool) -> bool { return v } -all_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x && v.y } -all_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x && v.y && v.z } -all_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x && v.y && v.z && v.w } +@(require_results) all_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) all_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x && v.y } +@(require_results) all_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x && v.y && v.z } +@(require_results) all_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x && v.y && v.z && v.w } not :: proc{ not_bool, @@ -1345,17 +1345,18 @@ not :: proc{ not_bvec3, not_bvec4, } -not_bool :: proc "c" (v: bool) -> bool { return !v } -not_bvec2 :: proc "c" (v: bvec2) -> bvec2 { return {!v.x, !v.y} } -not_bvec3 :: proc "c" (v: bvec3) -> bvec3 { return {!v.x, !v.y, !v.z} } -not_bvec4 :: proc "c" (v: bvec4) -> bvec4 { return {!v.x, !v.y, !v.z, !v.w} } +@(require_results) not_bool :: proc "c" (v: bool) -> bool { return !v } +@(require_results) not_bvec2 :: proc "c" (v: bvec2) -> bvec2 { return {!v.x, !v.y} } +@(require_results) not_bvec3 :: proc "c" (v: bvec3) -> bvec3 { return {!v.x, !v.y, !v.z} } +@(require_results) not_bvec4 :: proc "c" (v: bvec4) -> bvec4 { return {!v.x, !v.y, !v.z, !v.w} } /// Matrix Utilities -identity :: proc "c" ($M: typeid/matrix[$N, N]$T) -> M { return 1 } +@(require_results) identity :: proc "c" ($M: typeid/matrix[$N, N]$T) -> M { return 1 } +@(require_results) mat4Perspective :: proc "c" (fovy, aspect, near, far: f32) -> (m: mat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1365,6 +1366,7 @@ mat4Perspective :: proc "c" (fovy, aspect, near, far: f32) -> (m: mat4) { m[2, 3] = -2*far*near / (far - near) return } +@(require_results) mat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f32) -> (m: mat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1374,6 +1376,7 @@ mat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f32) -> (m: mat4) { m[2, 3] = -2*near return } +@(require_results) mat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f32) -> (m: mat4) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -1384,6 +1387,7 @@ mat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f32) -> (m: mat4) m[3, 3] = 1 return m } +@(require_results) mat4LookAt :: proc "c" (eye, centre, up: vec3) -> (m: mat4) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1397,6 +1401,7 @@ mat4LookAt :: proc "c" (eye, centre, up: vec3) -> (m: mat4) { m[3] = {-dot(s, eye), -dot(u, eye), +fe, 1} return } +@(require_results) mat4Rotate :: proc "c" (v: vec3, radians: f32) -> (rot: mat4) { c := cos(radians) s := sin(radians) @@ -1423,11 +1428,13 @@ mat4Rotate :: proc "c" (v: vec3, radians: f32) -> (rot: mat4) { return rot } +@(require_results) mat4Translate :: proc "c" (v: vec3) -> (m: mat4) { m = 1 m[3].xyz = v.xyz return } +@(require_results) mat4Scale :: proc "c" (v: vec3) -> (m: mat4) { m[0, 0] = v[0] m[1, 1] = v[1] @@ -1435,6 +1442,7 @@ mat4Scale :: proc "c" (v: vec3) -> (m: mat4) { m[3, 3] = 1 return } +@(require_results) mat4Orientation :: proc "c" (normal, up: vec3) -> mat4 { if normal == up { return 1 @@ -1445,6 +1453,7 @@ mat4Orientation :: proc "c" (normal, up: vec3) -> mat4 { return mat4Rotate(rotation_axis, angle) } +@(require_results) mat4FromQuat :: proc "c" (q: quat) -> (m: mat4) { qxx := q.x * q.x qyy := q.y * q.y @@ -1474,6 +1483,7 @@ mat4FromQuat :: proc "c" (q: quat) -> (m: mat4) { } +@(require_results) dmat4Perspective :: proc "c" (fovy, aspect, near, far: f64) -> (m: dmat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1483,6 +1493,7 @@ dmat4Perspective :: proc "c" (fovy, aspect, near, far: f64) -> (m: dmat4) { m[2, 3] = -2*far*near / (far - near) return } +@(require_results) dmat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f64) -> (m: dmat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1492,6 +1503,7 @@ dmat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f64) -> (m: dmat4) { m[2, 3] = -2*near return } +@(require_results) dmat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f64) -> (m: dmat4) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -1502,6 +1514,7 @@ dmat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f64) -> (m: dmat4 m[3, 3] = 1 return m } +@(require_results) dmat4LookAt :: proc "c" (eye, centre, up: dvec3) -> (m: dmat4) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1515,6 +1528,7 @@ dmat4LookAt :: proc "c" (eye, centre, up: dvec3) -> (m: dmat4) { m[3] = {-dot(s, eye), -dot(u, eye), +fe, 1} return } +@(require_results) dmat4Rotate :: proc "c" (v: dvec3, radians: f64) -> (rot: dmat4) { c := cos(radians) s := sin(radians) @@ -1541,11 +1555,13 @@ dmat4Rotate :: proc "c" (v: dvec3, radians: f64) -> (rot: dmat4) { return rot } +@(require_results) dmat4Translate :: proc "c" (v: dvec3) -> (m: dmat4) { m = 1 m[3].xyz = v.xyz return } +@(require_results) dmat4Scale :: proc "c" (v: dvec3) -> (m: dmat4) { m[0, 0] = v[0] m[1, 1] = v[1] @@ -1553,6 +1569,7 @@ dmat4Scale :: proc "c" (v: dvec3) -> (m: dmat4) { m[3, 3] = 1 return } +@(require_results) dmat4Orientation :: proc "c" (normal, up: dvec3) -> dmat4 { if normal == up { return 1 @@ -1563,6 +1580,7 @@ dmat4Orientation :: proc "c" (normal, up: dvec3) -> dmat4 { return dmat4Rotate(rotation_axis, angle) } +@(require_results) dmat4FromDquat :: proc "c" (q: dquat) -> (m: dmat4) { qxx := q.x * q.x qyy := q.y * q.y @@ -1601,6 +1619,7 @@ slerp :: proc{ } +@(require_results) quatAxisAngle :: proc "c" (axis: vec3, radians: f32) -> (q: quat) { t := radians*0.5 v := normalize(axis) * sin(t) @@ -1610,6 +1629,7 @@ quatAxisAngle :: proc "c" (axis: vec3, radians: f32) -> (q: quat) { q.w = cos(t) return } +@(require_results) quatNlerp :: proc "c" (a, b: quat, t: f32) -> (c: quat) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -1618,6 +1638,7 @@ quatNlerp :: proc "c" (a, b: quat, t: f32) -> (c: quat) { return c/quat(builtin.abs(c)) } +@(require_results) quatSlerp :: proc "c" (x, y: quat, t: f32) -> (q: quat) { a, b := x, y cos_angle := dot(a, b) @@ -1644,6 +1665,7 @@ quatSlerp :: proc "c" (x, y: quat, t: f32) -> (q: quat) { q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quatFromMat3 :: proc "c" (m: mat3) -> (q: quat) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1693,16 +1715,19 @@ quatFromMat3 :: proc "c" (m: mat3) -> (q: quat) { } return } +@(require_results) quatFromMat4 :: proc "c" (m: mat4) -> (q: quat) { return quatFromMat3(mat3(m)) } +@(require_results) quatMulVec3 :: proc "c" (q: quat, v: vec3) -> vec3 { xyz := vec3{q.x, q.y, q.z} t := cross(xyz, v) return v + q.w*t + cross(xyz, t) } +@(require_results) dquatAxisAngle :: proc "c" (axis: dvec3, radians: f64) -> (q: dquat) { t := radians*0.5 v := normalize(axis) * sin(t) @@ -1712,6 +1737,7 @@ dquatAxisAngle :: proc "c" (axis: dvec3, radians: f64) -> (q: dquat) { q.w = cos(t) return } +@(require_results) dquatNlerp :: proc "c" (a, b: dquat, t: f64) -> (c: dquat) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -1720,6 +1746,7 @@ dquatNlerp :: proc "c" (a, b: dquat, t: f64) -> (c: dquat) { return c/dquat(builtin.abs(c)) } +@(require_results) dquatSlerp :: proc "c" (x, y: dquat, t: f64) -> (q: dquat) { a, b := x, y cos_angle := dot(a, b) @@ -1746,6 +1773,7 @@ dquatSlerp :: proc "c" (x, y: dquat, t: f64) -> (q: dquat) { q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) dquatFromdMat3 :: proc "c" (m: dmat3) -> (q: dquat) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1795,10 +1823,12 @@ dquatFromdMat3 :: proc "c" (m: dmat3) -> (q: dquat) { } return } +@(require_results) dquatFromDmat4 :: proc "c" (m: dmat4) -> (q: dquat) { return dquatFromdMat3(dmat3(m)) } +@(require_results) dquatMulDvec3 :: proc "c" (q: dquat, v: dvec3) -> dvec3 { xyz := dvec3{q.x, q.y, q.z} t := cross(xyz, v) @@ -1808,14 +1838,14 @@ dquatMulDvec3 :: proc "c" (q: dquat, v: dvec3) -> dvec3 { -inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return builtin.inverse(m) } -inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return builtin.inverse(m) } -inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return builtin.inverse(m) } -inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return builtin.inverse(m) } -inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return builtin.inverse(m) } -inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return builtin.inverse(m) } -inverse_quat :: proc "c" (q: quat) -> quat { return 1/q } -inverse_dquat :: proc "c" (q: dquat) -> dquat { return 1/q } +@(require_results) inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return builtin.inverse(m) } +@(require_results) inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return builtin.inverse(m) } +@(require_results) inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return builtin.inverse(m) } +@(require_results) inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return builtin.inverse(m) } +@(require_results) inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return builtin.inverse(m) } +@(require_results) inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return builtin.inverse(m) } +@(require_results) inverse_quat :: proc "c" (q: quat) -> quat { return 1/q } +@(require_results) inverse_dquat :: proc "c" (q: dquat) -> dquat { return 1/q } inverse :: proc{ inverse_mat2, diff --git a/core/math/linalg/glsl/linalg_glsl_math.odin b/core/math/linalg/glsl/linalg_glsl_math.odin index 968a3fa5e..82b1857ab 100644 --- a/core/math/linalg/glsl/linalg_glsl_math.odin +++ b/core/math/linalg/glsl/linalg_glsl_math.odin @@ -2,30 +2,31 @@ package math_linalg_glsl import "core:math" -cos_f32 :: proc "c" (x: f32) -> f32 { return math.cos(x) } -sin_f32 :: proc "c" (x: f32) -> f32 { return math.sin(x) } -tan_f32 :: proc "c" (x: f32) -> f32 { return math.tan(x) } -acos_f32 :: proc "c" (x: f32) -> f32 { return math.acos(x) } -asin_f32 :: proc "c" (x: f32) -> f32 { return math.asin(x) } -atan_f32 :: proc "c" (x: f32) -> f32 { return math.atan(x) } -atan2_f32 :: proc "c" (y, x: f32) -> f32 { return math.atan2(y, x) } -cosh_f32 :: proc "c" (x: f32) -> f32 { return math.cosh(x) } -sinh_f32 :: proc "c" (x: f32) -> f32 { return math.sinh(x) } -tanh_f32 :: proc "c" (x: f32) -> f32 { return math.tanh(x) } -acosh_f32 :: proc "c" (x: f32) -> f32 { return math.acosh(x) } -asinh_f32 :: proc "c" (x: f32) -> f32 { return math.asinh(x) } -atanh_f32 :: proc "c" (x: f32) -> f32 { return math.atanh(x) } -sqrt_f32 :: proc "c" (x: f32) -> f32 { return math.sqrt(x) } -inversesqrt_f32 :: proc "c" (x: f32) -> f32 { return 1.0/math.sqrt(x) } -pow_f32 :: proc "c" (x, y: f32) -> f32 { return math.pow(x, y) } -exp_f32 :: proc "c" (x: f32) -> f32 { return math.exp(x) } -log_f32 :: proc "c" (x: f32) -> f32 { return math.ln(x) } -exp2_f32 :: proc "c" (x: f32) -> f32 { return math.pow(f32(2), x) } -sign_f32 :: proc "c" (x: f32) -> f32 { return math.sign(x) } -floor_f32 :: proc "c" (x: f32) -> f32 { return math.floor(x) } -round_f32 :: proc "c" (x: f32) -> f32 { return math.round(x) } -ceil_f32 :: proc "c" (x: f32) -> f32 { return math.ceil(x) } -mod_f32 :: proc "c" (x, y: f32) -> f32 { return math.mod(x, y) } +@(require_results) cos_f32 :: proc "c" (x: f32) -> f32 { return math.cos(x) } +@(require_results) sin_f32 :: proc "c" (x: f32) -> f32 { return math.sin(x) } +@(require_results) tan_f32 :: proc "c" (x: f32) -> f32 { return math.tan(x) } +@(require_results) acos_f32 :: proc "c" (x: f32) -> f32 { return math.acos(x) } +@(require_results) asin_f32 :: proc "c" (x: f32) -> f32 { return math.asin(x) } +@(require_results) atan_f32 :: proc "c" (x: f32) -> f32 { return math.atan(x) } +@(require_results) atan2_f32 :: proc "c" (y, x: f32) -> f32 { return math.atan2(y, x) } +@(require_results) cosh_f32 :: proc "c" (x: f32) -> f32 { return math.cosh(x) } +@(require_results) sinh_f32 :: proc "c" (x: f32) -> f32 { return math.sinh(x) } +@(require_results) tanh_f32 :: proc "c" (x: f32) -> f32 { return math.tanh(x) } +@(require_results) acosh_f32 :: proc "c" (x: f32) -> f32 { return math.acosh(x) } +@(require_results) asinh_f32 :: proc "c" (x: f32) -> f32 { return math.asinh(x) } +@(require_results) atanh_f32 :: proc "c" (x: f32) -> f32 { return math.atanh(x) } +@(require_results) sqrt_f32 :: proc "c" (x: f32) -> f32 { return math.sqrt(x) } +@(require_results) inversesqrt_f32 :: proc "c" (x: f32) -> f32 { return 1.0/math.sqrt(x) } +@(require_results) pow_f32 :: proc "c" (x, y: f32) -> f32 { return math.pow(x, y) } +@(require_results) exp_f32 :: proc "c" (x: f32) -> f32 { return math.exp(x) } +@(require_results) log_f32 :: proc "c" (x: f32) -> f32 { return math.ln(x) } +@(require_results) exp2_f32 :: proc "c" (x: f32) -> f32 { return math.pow(f32(2), x) } +@(require_results) sign_f32 :: proc "c" (x: f32) -> f32 { return math.sign(x) } +@(require_results) floor_f32 :: proc "c" (x: f32) -> f32 { return math.floor(x) } +@(require_results) round_f32 :: proc "c" (x: f32) -> f32 { return math.round(x) } +@(require_results) ceil_f32 :: proc "c" (x: f32) -> f32 { return math.ceil(x) } +@(require_results) mod_f32 :: proc "c" (x, y: f32) -> f32 { return math.mod(x, y) } +@(require_results) fract_f32 :: proc "c" (x: f32) -> f32 { if x >= 0 { return x - math.trunc(x) @@ -33,30 +34,31 @@ fract_f32 :: proc "c" (x: f32) -> f32 { return math.trunc(-x) + x } -cos_f64 :: proc "c" (x: f64) -> f64 { return math.cos(x) } -sin_f64 :: proc "c" (x: f64) -> f64 { return math.sin(x) } -tan_f64 :: proc "c" (x: f64) -> f64 { return math.tan(x) } -acos_f64 :: proc "c" (x: f64) -> f64 { return math.acos(x) } -asin_f64 :: proc "c" (x: f64) -> f64 { return math.asin(x) } -atan_f64 :: proc "c" (x: f64) -> f64 { return math.atan(x) } -atan2_f64 :: proc "c" (y, x: f64) -> f64 { return math.atan2(y, x) } -cosh_f64 :: proc "c" (x: f64) -> f64 { return math.cosh(x) } -sinh_f64 :: proc "c" (x: f64) -> f64 { return math.sinh(x) } -tanh_f64 :: proc "c" (x: f64) -> f64 { return math.tanh(x) } -acosh_f64 :: proc "c" (x: f64) -> f64 { return math.acosh(x) } -asinh_f64 :: proc "c" (x: f64) -> f64 { return math.asinh(x) } -atanh_f64 :: proc "c" (x: f64) -> f64 { return math.atanh(x) } -sqrt_f64 :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } -inversesqrt_f64 :: proc "c" (x: f64) -> f64 { return 1.0/math.sqrt(x) } -pow_f64 :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } -exp_f64 :: proc "c" (x: f64) -> f64 { return math.exp(x) } -log_f64 :: proc "c" (x: f64) -> f64 { return math.ln(x) } -exp2_f64 :: proc "c" (x: f64) -> f64 { return math.pow(f64(2), x) } -sign_f64 :: proc "c" (x: f64) -> f64 { return math.sign(x) } -floor_f64 :: proc "c" (x: f64) -> f64 { return math.floor(x) } -round_f64 :: proc "c" (x: f64) -> f64 { return math.round(x) } -ceil_f64 :: proc "c" (x: f64) -> f64 { return math.ceil(x) } -mod_f64 :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) } +@(require_results) cos_f64 :: proc "c" (x: f64) -> f64 { return math.cos(x) } +@(require_results) sin_f64 :: proc "c" (x: f64) -> f64 { return math.sin(x) } +@(require_results) tan_f64 :: proc "c" (x: f64) -> f64 { return math.tan(x) } +@(require_results) acos_f64 :: proc "c" (x: f64) -> f64 { return math.acos(x) } +@(require_results) asin_f64 :: proc "c" (x: f64) -> f64 { return math.asin(x) } +@(require_results) atan_f64 :: proc "c" (x: f64) -> f64 { return math.atan(x) } +@(require_results) atan2_f64 :: proc "c" (y, x: f64) -> f64 { return math.atan2(y, x) } +@(require_results) cosh_f64 :: proc "c" (x: f64) -> f64 { return math.cosh(x) } +@(require_results) sinh_f64 :: proc "c" (x: f64) -> f64 { return math.sinh(x) } +@(require_results) tanh_f64 :: proc "c" (x: f64) -> f64 { return math.tanh(x) } +@(require_results) acosh_f64 :: proc "c" (x: f64) -> f64 { return math.acosh(x) } +@(require_results) asinh_f64 :: proc "c" (x: f64) -> f64 { return math.asinh(x) } +@(require_results) atanh_f64 :: proc "c" (x: f64) -> f64 { return math.atanh(x) } +@(require_results) sqrt_f64 :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } +@(require_results) inversesqrt_f64 :: proc "c" (x: f64) -> f64 { return 1.0/math.sqrt(x) } +@(require_results) pow_f64 :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } +@(require_results) exp_f64 :: proc "c" (x: f64) -> f64 { return math.exp(x) } +@(require_results) log_f64 :: proc "c" (x: f64) -> f64 { return math.ln(x) } +@(require_results) exp2_f64 :: proc "c" (x: f64) -> f64 { return math.pow(f64(2), x) } +@(require_results) sign_f64 :: proc "c" (x: f64) -> f64 { return math.sign(x) } +@(require_results) floor_f64 :: proc "c" (x: f64) -> f64 { return math.floor(x) } +@(require_results) round_f64 :: proc "c" (x: f64) -> f64 { return math.round(x) } +@(require_results) ceil_f64 :: proc "c" (x: f64) -> f64 { return math.ceil(x) } +@(require_results) mod_f64 :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) } +@(require_results) fract_f64 :: proc "c" (x: f64) -> f64 { if x >= 0 { return x - math.trunc(x) diff --git a/core/math/linalg/hlsl/linalg_hlsl.odin b/core/math/linalg/hlsl/linalg_hlsl.odin index 3f73dcd1f..351aa7ea3 100644 --- a/core/math/linalg/hlsl/linalg_hlsl.odin +++ b/core/math/linalg/hlsl/linalg_hlsl.odin @@ -114,12 +114,12 @@ cos :: proc{ cos_double3, cos_double4, } -cos_float2 :: proc "c" (x: float2) -> float2 { return {cos(x.x), cos(x.y)} } -cos_float3 :: proc "c" (x: float3) -> float3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_float4 :: proc "c" (x: float4) -> float4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } -cos_double2 :: proc "c" (x: double2) -> double2 { return {cos(x.x), cos(x.y)} } -cos_double3 :: proc "c" (x: double3) -> double3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) cos_double2 :: proc "c" (x: double2) -> double2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_double3 :: proc "c" (x: double3) -> double3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(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_float, @@ -131,12 +131,12 @@ sin :: proc{ sin_double3, sin_double4, } -sin_float2 :: proc "c" (x: float2) -> float2 { return {sin(x.x), sin(x.y)} } -sin_float3 :: proc "c" (x: float3) -> float3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_float4 :: proc "c" (x: float4) -> float4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } -sin_double2 :: proc "c" (x: double2) -> double2 { return {sin(x.x), sin(x.y)} } -sin_double3 :: proc "c" (x: double3) -> double3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) sin_double2 :: proc "c" (x: double2) -> double2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_double3 :: proc "c" (x: double3) -> double3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(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_float, @@ -148,12 +148,12 @@ tan :: proc{ tan_double3, tan_double4, } -tan_float2 :: proc "c" (x: float2) -> float2 { return {tan(x.x), tan(x.y)} } -tan_float3 :: proc "c" (x: float3) -> float3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_float4 :: proc "c" (x: float4) -> float4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } -tan_double2 :: proc "c" (x: double2) -> double2 { return {tan(x.x), tan(x.y)} } -tan_double3 :: proc "c" (x: double3) -> double3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) tan_double2 :: proc "c" (x: double2) -> double2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_double3 :: proc "c" (x: double3) -> double3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(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_float, @@ -165,12 +165,12 @@ acos :: proc{ acos_double3, acos_double4, } -acos_float2 :: proc "c" (x: float2) -> float2 { return {acos(x.x), acos(x.y)} } -acos_float3 :: proc "c" (x: float3) -> float3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_float4 :: proc "c" (x: float4) -> float4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } -acos_double2 :: proc "c" (x: double2) -> double2 { return {acos(x.x), acos(x.y)} } -acos_double3 :: proc "c" (x: double3) -> double3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) acos_double2 :: proc "c" (x: double2) -> double2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_double3 :: proc "c" (x: double3) -> double3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(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_float, @@ -182,12 +182,12 @@ asin :: proc{ asin_double3, asin_double4, } -asin_float2 :: proc "c" (x: float2) -> float2 { return {asin(x.x), asin(x.y)} } -asin_float3 :: proc "c" (x: float3) -> float3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_float4 :: proc "c" (x: float4) -> float4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } -asin_double2 :: proc "c" (x: double2) -> double2 { return {asin(x.x), asin(x.y)} } -asin_double3 :: proc "c" (x: double3) -> double3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) asin_double2 :: proc "c" (x: double2) -> double2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_double3 :: proc "c" (x: double3) -> double3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(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_float, @@ -207,12 +207,12 @@ atan :: proc{ atan2_double3, atan2_double4, } -atan_float2 :: proc "c" (x: float2) -> float2 { return {atan(x.x), atan(x.y)} } -atan_float3 :: proc "c" (x: float3) -> float3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_float4 :: proc "c" (x: float4) -> float4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } -atan_double2 :: proc "c" (x: double2) -> double2 { return {atan(x.x), atan(x.y)} } -atan_double3 :: proc "c" (x: double3) -> double3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) atan_double2 :: proc "c" (x: double2) -> double2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_double3 :: proc "c" (x: double3) -> double3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(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_float, @@ -224,12 +224,12 @@ atan2 :: proc{ atan2_double3, atan2_double4, } -atan2_float2 :: proc "c" (y, x: float2) -> float2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_float3 :: proc "c" (y, x: float3) -> float3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -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)} } -atan2_double2 :: proc "c" (y, x: double2) -> double2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_double3 :: proc "c" (y, x: double3) -> double3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_double4 :: proc "c" (y, x: double4) -> double4 { 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)} } +@(require_results) atan2_double2 :: proc "c" (y, x: double2) -> double2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_double3 :: proc "c" (y, x: double3) -> double3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_double4 :: proc "c" (y, x: double4) -> double4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @@ -243,12 +243,12 @@ cosh :: proc{ cosh_double3, cosh_double4, } -cosh_float2 :: proc "c" (x: float2) -> float2 { return {cosh(x.x), cosh(x.y)} } -cosh_float3 :: proc "c" (x: float3) -> float3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_float4 :: proc "c" (x: float4) -> float4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } -cosh_double2 :: proc "c" (x: double2) -> double2 { return {cosh(x.x), cosh(x.y)} } -cosh_double3 :: proc "c" (x: double3) -> double3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) cosh_double2 :: proc "c" (x: double2) -> double2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_double3 :: proc "c" (x: double3) -> double3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_double4 :: proc "c" (x: double4) -> double4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } sinh :: proc{ @@ -261,12 +261,12 @@ sinh :: proc{ sinh_double3, sinh_double4, } -sinh_float2 :: proc "c" (x: float2) -> float2 { return {sinh(x.x), sinh(x.y)} } -sinh_float3 :: proc "c" (x: float3) -> float3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_float4 :: proc "c" (x: float4) -> float4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } -sinh_double2 :: proc "c" (x: double2) -> double2 { return {sinh(x.x), sinh(x.y)} } -sinh_double3 :: proc "c" (x: double3) -> double3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) sinh_double2 :: proc "c" (x: double2) -> double2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_double3 :: proc "c" (x: double3) -> double3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(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_float, @@ -278,12 +278,12 @@ tanh :: proc{ tanh_double3, tanh_double4, } -tanh_float2 :: proc "c" (x: float2) -> float2 { return {tanh(x.x), tanh(x.y)} } -tanh_float3 :: proc "c" (x: float3) -> float3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_float4 :: proc "c" (x: float4) -> float4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } -tanh_double2 :: proc "c" (x: double2) -> double2 { return {tanh(x.x), tanh(x.y)} } -tanh_double3 :: proc "c" (x: double3) -> double3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) tanh_double2 :: proc "c" (x: double2) -> double2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_double3 :: proc "c" (x: double3) -> double3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(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_float, @@ -295,12 +295,12 @@ acosh :: proc{ acosh_double3, acosh_double4, } -acosh_float2 :: proc "c" (x: float2) -> float2 { return {acosh(x.x), acosh(x.y)} } -acosh_float3 :: proc "c" (x: float3) -> float3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_float4 :: proc "c" (x: float4) -> float4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } -acosh_double2 :: proc "c" (x: double2) -> double2 { return {acosh(x.x), acosh(x.y)} } -acosh_double3 :: proc "c" (x: double3) -> double3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) acosh_double2 :: proc "c" (x: double2) -> double2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_double3 :: proc "c" (x: double3) -> double3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(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_float, @@ -312,12 +312,12 @@ asinh :: proc{ asinh_double3, asinh_double4, } -asinh_float2 :: proc "c" (x: float2) -> float2 { return {asinh(x.x), asinh(x.y)} } -asinh_float3 :: proc "c" (x: float3) -> float3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_float4 :: proc "c" (x: float4) -> float4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } -asinh_double2 :: proc "c" (x: double2) -> double2 { return {asinh(x.x), asinh(x.y)} } -asinh_double3 :: proc "c" (x: double3) -> double3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) asinh_double2 :: proc "c" (x: double2) -> double2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_double3 :: proc "c" (x: double3) -> double3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(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_float, @@ -329,12 +329,12 @@ atanh :: proc{ atanh_double3, atanh_double4, } -atanh_float2 :: proc "c" (x: float2) -> float2 { return {atanh(x.x), atanh(x.y)} } -atanh_float3 :: proc "c" (x: float3) -> float3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_float4 :: proc "c" (x: float4) -> float4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } -atanh_double2 :: proc "c" (x: double2) -> double2 { return {atanh(x.x), atanh(x.y)} } -atanh_double3 :: proc "c" (x: double3) -> double3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) atanh_double2 :: proc "c" (x: double2) -> double2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_double3 :: proc "c" (x: double3) -> double3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(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_float, @@ -346,12 +346,12 @@ sqrt :: proc{ sqrt_double3, sqrt_double4, } -sqrt_float2 :: proc "c" (x: float2) -> float2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_float3 :: proc "c" (x: float3) -> float3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_float4 :: proc "c" (x: float4) -> float4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } -sqrt_double2 :: proc "c" (x: double2) -> double2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_double3 :: proc "c" (x: double3) -> double3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) sqrt_double2 :: proc "c" (x: double2) -> double2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_double3 :: proc "c" (x: double3) -> double3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(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_float, @@ -363,12 +363,12 @@ rsqrt :: proc{ rsqrt_double3, rsqrt_double4, } -rsqrt_float2 :: proc "c" (x: float2) -> float2 { return {rsqrt(x.x), rsqrt(x.y)} } -rsqrt_float3 :: proc "c" (x: float3) -> float3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } -rsqrt_float4 :: proc "c" (x: float4) -> float4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } -rsqrt_double2 :: proc "c" (x: double2) -> double2 { return {rsqrt(x.x), rsqrt(x.y)} } -rsqrt_double3 :: proc "c" (x: double3) -> double3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } -rsqrt_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) rsqrt_double2 :: proc "c" (x: double2) -> double2 { return {rsqrt(x.x), rsqrt(x.y)} } +@(require_results) rsqrt_double3 :: proc "c" (x: double3) -> double3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } +@(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_float, @@ -380,12 +380,12 @@ rcp :: proc{ rcp_double3, rcp_double4, } -rcp_float2 :: proc "c" (x: float2) -> float2 { return {rcp(x.x), rcp(x.y)} } -rcp_float3 :: proc "c" (x: float3) -> float3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } -rcp_float4 :: proc "c" (x: float4) -> float4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } -rcp_double2 :: proc "c" (x: double2) -> double2 { return {rcp(x.x), rcp(x.y)} } -rcp_double3 :: proc "c" (x: double3) -> double3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } -rcp_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) rcp_double2 :: proc "c" (x: double2) -> double2 { return {rcp(x.x), rcp(x.y)} } +@(require_results) rcp_double3 :: proc "c" (x: double3) -> double3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } +@(require_results) rcp_double4 :: proc "c" (x: double4) -> double4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } pow :: proc{ @@ -398,12 +398,12 @@ pow :: proc{ pow_double3, pow_double4, } -pow_float2 :: proc "c" (x, y: float2) -> float2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_float3 :: proc "c" (x, y: float3) -> float3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -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)} } -pow_double2 :: proc "c" (x, y: double2) -> double2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_double3 :: proc "c" (x, y: double3) -> double3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_double4 :: proc "c" (x, y: double4) -> double4 { 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)} } +@(require_results) pow_double2 :: proc "c" (x, y: double2) -> double2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_double3 :: proc "c" (x, y: double3) -> double3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_double4 :: proc "c" (x, y: double4) -> double4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @@ -417,12 +417,12 @@ exp :: proc{ exp_double3, exp_double4, } -exp_float2 :: proc "c" (x: float2) -> float2 { return {exp(x.x), exp(x.y)} } -exp_float3 :: proc "c" (x: float3) -> float3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_float4 :: proc "c" (x: float4) -> float4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } -exp_double2 :: proc "c" (x: double2) -> double2 { return {exp(x.x), exp(x.y)} } -exp_double3 :: proc "c" (x: double3) -> double3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) exp_double2 :: proc "c" (x: double2) -> double2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_double3 :: proc "c" (x: double3) -> double3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_double4 :: proc "c" (x: double4) -> double4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @@ -436,12 +436,12 @@ log :: proc{ log_double3, log_double4, } -log_float2 :: proc "c" (x: float2) -> float2 { return {log(x.x), log(x.y)} } -log_float3 :: proc "c" (x: float3) -> float3 { return {log(x.x), log(x.y), log(x.z)} } -log_float4 :: proc "c" (x: float4) -> float4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } -log_double2 :: proc "c" (x: double2) -> double2 { return {log(x.x), log(x.y)} } -log_double3 :: proc "c" (x: double3) -> double3 { return {log(x.x), log(x.y), log(x.z)} } -log_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) log_double2 :: proc "c" (x: double2) -> double2 { return {log(x.x), log(x.y)} } +@(require_results) log_double3 :: proc "c" (x: double3) -> double3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_double4 :: proc "c" (x: double4) -> double4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } log2 :: proc{ @@ -454,12 +454,12 @@ log2 :: proc{ log2_double3, log2_double4, } -log2_float2 :: proc "c" (x: float2) -> float2 { return {log2(x.x), log2(x.y)} } -log2_float3 :: proc "c" (x: float3) -> float3 { return {log2(x.x), log2(x.y), log2(x.z)} } -log2_float4 :: proc "c" (x: float4) -> float4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } -log2_double2 :: proc "c" (x: double2) -> double2 { return {log2(x.x), log2(x.y)} } -log2_double3 :: proc "c" (x: double3) -> double3 { return {log2(x.x), log2(x.y), log2(x.z)} } -log2_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) log2_double2 :: proc "c" (x: double2) -> double2 { return {log2(x.x), log2(x.y)} } +@(require_results) log2_double3 :: proc "c" (x: double3) -> double3 { return {log2(x.x), log2(x.y), log2(x.z)} } +@(require_results) log2_double4 :: proc "c" (x: double4) -> double4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } @@ -473,12 +473,12 @@ log10 :: proc{ log10_double3, log10_double4, } -log10_float2 :: proc "c" (x: float2) -> float2 { return {log10(x.x), log10(x.y)} } -log10_float3 :: proc "c" (x: float3) -> float3 { return {log10(x.x), log10(x.y), log10(x.z)} } -log10_float4 :: proc "c" (x: float4) -> float4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } -log10_double2 :: proc "c" (x: double2) -> double2 { return {log10(x.x), log10(x.y)} } -log10_double3 :: proc "c" (x: double3) -> double3 { return {log10(x.x), log10(x.y), log10(x.z)} } -log10_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) log10_double2 :: proc "c" (x: double2) -> double2 { return {log10(x.x), log10(x.y)} } +@(require_results) log10_double3 :: proc "c" (x: double3) -> double3 { return {log10(x.x), log10(x.y), log10(x.z)} } +@(require_results) log10_double4 :: proc "c" (x: double4) -> double4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } @@ -493,12 +493,12 @@ exp2 :: proc{ exp2_double3, exp2_double4, } -exp2_float2 :: proc "c" (x: float2) -> float2 { return {exp2(x.x), exp2(x.y)} } -exp2_float3 :: proc "c" (x: float3) -> float3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_float4 :: proc "c" (x: float4) -> float4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } -exp2_double2 :: proc "c" (x: double2) -> double2 { return {exp2(x.x), exp2(x.y)} } -exp2_double3 :: proc "c" (x: double3) -> double3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) exp2_double2 :: proc "c" (x: double2) -> double2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_double3 :: proc "c" (x: double3) -> double3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_double4 :: proc "c" (x: double4) -> double4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } sign :: proc{ @@ -519,20 +519,20 @@ sign :: proc{ sign_uint3, sign_uint4, } -sign_int :: proc "c" (x: int) -> int { return -1 if x < 0 else +1 if x > 0 else 0 } -sign_uint :: proc "c" (x: uint) -> uint { return +1 if x > 0 else 0 } -sign_float2 :: proc "c" (x: float2) -> float2 { return {sign(x.x), sign(x.y)} } -sign_float3 :: proc "c" (x: float3) -> float3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_float4 :: proc "c" (x: float4) -> float4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_double2 :: proc "c" (x: double2) -> double2 { return {sign(x.x), sign(x.y)} } -sign_double3 :: proc "c" (x: double3) -> double3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_double4 :: proc "c" (x: double4) -> double4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_int2 :: proc "c" (x: int2) -> int2 { return {sign(x.x), sign(x.y)} } -sign_int3 :: proc "c" (x: int3) -> int3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_int4 :: proc "c" (x: int4) -> int4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_uint2 :: proc "c" (x: uint2) -> uint2 { return {sign(x.x), sign(x.y)} } -sign_uint3 :: proc "c" (x: uint3) -> uint3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_uint4 :: proc "c" (x: uint4) -> uint4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(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_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)} } +@(require_results) sign_double2 :: proc "c" (x: double2) -> double2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_double3 :: proc "c" (x: double3) -> double3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_double4 :: proc "c" (x: double4) -> double4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_int2 :: proc "c" (x: int2) -> int2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_int3 :: proc "c" (x: int3) -> int3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_int4 :: proc "c" (x: int4) -> int4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_uint2 :: proc "c" (x: uint2) -> uint2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_uint3 :: proc "c" (x: uint3) -> uint3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(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_float, @@ -544,12 +544,12 @@ floor :: proc{ floor_double3, floor_double4, } -floor_float2 :: proc "c" (x: float2) -> float2 { return {floor(x.x), floor(x.y)} } -floor_float3 :: proc "c" (x: float3) -> float3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_float4 :: proc "c" (x: float4) -> float4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } -floor_double2 :: proc "c" (x: double2) -> double2 { return {floor(x.x), floor(x.y)} } -floor_double3 :: proc "c" (x: double3) -> double3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) floor_double2 :: proc "c" (x: double2) -> double2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_double3 :: proc "c" (x: double3) -> double3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(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_float, @@ -561,12 +561,12 @@ round :: proc{ round_double3, round_double4, } -round_float2 :: proc "c" (x: float2) -> float2 { return {round(x.x), round(x.y)} } -round_float3 :: proc "c" (x: float3) -> float3 { return {round(x.x), round(x.y), round(x.z)} } -round_float4 :: proc "c" (x: float4) -> float4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } -round_double2 :: proc "c" (x: double2) -> double2 { return {round(x.x), round(x.y)} } -round_double3 :: proc "c" (x: double3) -> double3 { return {round(x.x), round(x.y), round(x.z)} } -round_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) round_double2 :: proc "c" (x: double2) -> double2 { return {round(x.x), round(x.y)} } +@(require_results) round_double3 :: proc "c" (x: double3) -> double3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_double4 :: proc "c" (x: double4) -> double4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } ceil :: proc{ @@ -579,22 +579,22 @@ ceil :: proc{ ceil_double3, ceil_double4, } -ceil_float2 :: proc "c" (x: float2) -> float2 { return {ceil(x.x), ceil(x.y)} } -ceil_float3 :: proc "c" (x: float3) -> float3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_float4 :: proc "c" (x: float4) -> float4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -ceil_double2 :: proc "c" (x: double2) -> double2 { return {ceil(x.x), ceil(x.y)} } -ceil_double3 :: proc "c" (x: double3) -> double3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) ceil_double2 :: proc "c" (x: double2) -> double2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_double3 :: proc "c" (x: double3) -> double3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_double4 :: proc "c" (x: double4) -> double4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -isfinite_float :: proc "c" (x: float) -> bool { return !isinf_float(x) } -isfinite_float2 :: proc "c" (x: float2) -> bool2 { return {isfinite_float(x.x), isfinite_float(x.y)} } -isfinite_float3 :: proc "c" (x: float3) -> bool3 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z)} } -isfinite_float4 :: proc "c" (x: float4) -> bool4 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z), isfinite_float(x.w)} } -isfinite_double :: proc "c" (x: double) -> bool { return !isinf_double(x) } -isfinite_double2 :: proc "c" (x: double2) -> bool2 { return {isfinite_double(x.x), isfinite_double(x.y)} } -isfinite_double3 :: proc "c" (x: double3) -> bool3 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z)} } -isfinite_double4 :: proc "c" (x: double4) -> bool4 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z), isfinite_double(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)} } +@(require_results) isfinite_float4 :: proc "c" (x: float4) -> bool4 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z), isfinite_float(x.w)} } +@(require_results) isfinite_double :: proc "c" (x: double) -> bool { return !isinf_double(x) } +@(require_results) isfinite_double2 :: proc "c" (x: double2) -> bool2 { return {isfinite_double(x.x), isfinite_double(x.y)} } +@(require_results) isfinite_double3 :: proc "c" (x: double3) -> bool3 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z)} } +@(require_results) isfinite_double4 :: proc "c" (x: double4) -> bool4 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z), isfinite_double(x.w)} } // isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite isfinite :: proc{ @@ -609,14 +609,14 @@ isfinite :: proc{ } -isinf_float :: proc "c" (x: float) -> bool { return x * 0.5 == x } -isinf_float2 :: proc "c" (x: float2) -> bool2 { return {isinf_float(x.x), isinf_float(x.y)} } -isinf_float3 :: proc "c" (x: float3) -> bool3 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z)} } -isinf_float4 :: proc "c" (x: float4) -> bool4 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z), isinf_float(x.w)} } -isinf_double :: proc "c" (x: double) -> bool { return x * 0.5 == x } -isinf_double2 :: proc "c" (x: double2) -> bool2 { return {isinf_double(x.x), isinf_double(x.y)} } -isinf_double3 :: proc "c" (x: double3) -> bool3 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z)} } -isinf_double4 :: proc "c" (x: double4) -> bool4 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z), isinf_double(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)} } +@(require_results) isinf_float4 :: proc "c" (x: float4) -> bool4 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z), isinf_float(x.w)} } +@(require_results) isinf_double :: proc "c" (x: double) -> bool { return x * 0.5 == x } +@(require_results) isinf_double2 :: proc "c" (x: double2) -> bool2 { return {isinf_double(x.x), isinf_double(x.y)} } +@(require_results) isinf_double3 :: proc "c" (x: double3) -> bool3 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z)} } +@(require_results) isinf_double4 :: proc "c" (x: double4) -> bool4 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z), isinf_double(x.w)} } // isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite isinf :: proc{ @@ -631,12 +631,12 @@ isinf :: proc{ } -isnan_float2 :: proc "c" (x: float2) -> bool2 { return {isnan_float(x.x), isnan_float(x.y)} } -isnan_float3 :: proc "c" (x: float3) -> bool3 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z)} } -isnan_float4 :: proc "c" (x: float4) -> bool4 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z), isnan_float(x.w)} } -isnan_double2 :: proc "c" (x: double2) -> bool2 { return {isnan_double(x.x), isnan_double(x.y)} } -isnan_double3 :: proc "c" (x: double3) -> bool3 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z)} } -isnan_double4 :: proc "c" (x: double4) -> bool4 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z), isnan_double(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)} } +@(require_results) isnan_double2 :: proc "c" (x: double2) -> bool2 { return {isnan_double(x.x), isnan_double(x.y)} } +@(require_results) isnan_double3 :: proc "c" (x: double3) -> bool3 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z)} } +@(require_results) isnan_double4 :: proc "c" (x: double4) -> bool4 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z), isnan_double(x.w)} } // isnan returns true if the input value is the special case of Not-A-Number isnan :: proc{ @@ -660,12 +660,12 @@ fmod :: proc{ fmod_double3, fmod_double4, } -fmod_float2 :: proc "c" (x, y: float2) -> float2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } -fmod_float3 :: proc "c" (x, y: float3) -> float3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } -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)} } -fmod_double2 :: proc "c" (x, y: double2) -> double2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } -fmod_double3 :: proc "c" (x, y: double3) -> double3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } -fmod_double4 :: proc "c" (x, y: double4) -> double4 { 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)} } +@(require_results) fmod_double2 :: proc "c" (x, y: double2) -> double2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } +@(require_results) fmod_double3 :: proc "c" (x, y: double3) -> double3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } +@(require_results) fmod_double4 :: proc "c" (x, y: double4) -> double4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } frac :: proc{ @@ -678,12 +678,12 @@ frac :: proc{ frac_double3, frac_double4, } -frac_float2 :: proc "c" (x: float2) -> float2 { return {frac(x.x), frac(x.y)} } -frac_float3 :: proc "c" (x: float3) -> float3 { return {frac(x.x), frac(x.y), frac(x.z)} } -frac_float4 :: proc "c" (x: float4) -> float4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } -frac_double2 :: proc "c" (x: double2) -> double2 { return {frac(x.x), frac(x.y)} } -frac_double3 :: proc "c" (x: double3) -> double3 { return {frac(x.x), frac(x.y), frac(x.z)} } -frac_double4 :: proc "c" (x: double4) -> double4 { 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)} } +@(require_results) frac_double2 :: proc "c" (x: double2) -> double2 { return {frac(x.x), frac(x.y)} } +@(require_results) frac_double3 :: proc "c" (x: double3) -> double3 { return {frac(x.x), frac(x.y), frac(x.z)} } +@(require_results) frac_double4 :: proc "c" (x: double4) -> double4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } @@ -697,14 +697,14 @@ radians :: proc{ radians_double3, radians_double4, } -radians_float :: proc "c" (degrees: float) -> float { return degrees * TAU / 360.0 } -radians_double :: proc "c" (degrees: double) -> double { return degrees * TAU / 360.0 } -radians_float2 :: proc "c" (degrees: float2) -> float2 { return degrees * TAU / 360.0 } -radians_float3 :: proc "c" (degrees: float3) -> float3 { return degrees * TAU / 360.0 } -radians_float4 :: proc "c" (degrees: float4) -> float4 { return degrees * TAU / 360.0 } -radians_double2 :: proc "c" (degrees: double2) -> double2 { return degrees * TAU / 360.0 } -radians_double3 :: proc "c" (degrees: double3) -> double3 { return degrees * TAU / 360.0 } -radians_double4 :: proc "c" (degrees: double4) -> double4 { 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_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 } +@(require_results) radians_double2 :: proc "c" (degrees: double2) -> double2 { return degrees * TAU / 360.0 } +@(require_results) radians_double3 :: proc "c" (degrees: double3) -> double3 { return degrees * TAU / 360.0 } +@(require_results) radians_double4 :: proc "c" (degrees: double4) -> double4 { return degrees * TAU / 360.0 } degrees :: proc{ @@ -717,14 +717,14 @@ degrees :: proc{ degrees_double3, degrees_double4, } -degrees_float :: proc "c" (radians: float) -> float { return radians * 360.0 / TAU } -degrees_double :: proc "c" (radians: double) -> double { return radians * 360.0 / TAU } -degrees_float2 :: proc "c" (radians: float2) -> float2 { return radians * 360.0 / TAU } -degrees_float3 :: proc "c" (radians: float3) -> float3 { return radians * 360.0 / TAU } -degrees_float4 :: proc "c" (radians: float4) -> float4 { return radians * 360.0 / TAU } -degrees_double2 :: proc "c" (radians: double2) -> double2 { return radians * 360.0 / TAU } -degrees_double3 :: proc "c" (radians: double3) -> double3 { return radians * 360.0 / TAU } -degrees_double4 :: proc "c" (radians: double4) -> double4 { 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_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 } +@(require_results) degrees_double2 :: proc "c" (radians: double2) -> double2 { return radians * 360.0 / TAU } +@(require_results) degrees_double3 :: proc "c" (radians: double3) -> double3 { return radians * 360.0 / TAU } +@(require_results) degrees_double4 :: proc "c" (radians: double4) -> double4 { return radians * 360.0 / TAU } min :: proc{ min_int, @@ -744,22 +744,22 @@ min :: proc{ min_uint3, min_uint4, } -min_int :: proc "c" (x, y: int) -> int { return builtin.min(x, y) } -min_uint :: proc "c" (x, y: uint) -> uint { return builtin.min(x, y) } -min_float :: proc "c" (x, y: float) -> float { return builtin.min(x, y) } -min_double :: proc "c" (x, y: double) -> double { return builtin.min(x, y) } -min_float2 :: proc "c" (x, y: float2) -> float2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_float3 :: proc "c" (x, y: float3) -> float3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -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)} } -min_double2 :: proc "c" (x, y: double2) -> double2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_double3 :: proc "c" (x, y: double3) -> double3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_double4 :: proc "c" (x, y: double4) -> double4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_int2 :: proc "c" (x, y: int2) -> int2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_int3 :: proc "c" (x, y: int3) -> int3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_int4 :: proc "c" (x, y: int4) -> int4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(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_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_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)} } +@(require_results) min_double2 :: proc "c" (x, y: double2) -> double2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_double3 :: proc "c" (x, y: double3) -> double3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_double4 :: proc "c" (x, y: double4) -> double4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_int2 :: proc "c" (x, y: int2) -> int2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_int3 :: proc "c" (x, y: int3) -> int3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_int4 :: proc "c" (x, y: int4) -> int4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } max :: proc{ @@ -780,22 +780,22 @@ max :: proc{ max_uint3, max_uint4, } -max_int :: proc "c" (x, y: int) -> int { return builtin.max(x, y) } -max_uint :: proc "c" (x, y: uint) -> uint { return builtin.max(x, y) } -max_float :: proc "c" (x, y: float) -> float { return builtin.max(x, y) } -max_double :: proc "c" (x, y: double) -> double { return builtin.max(x, y) } -max_float2 :: proc "c" (x, y: float2) -> float2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_float3 :: proc "c" (x, y: float3) -> float3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -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)} } -max_double2 :: proc "c" (x, y: double2) -> double2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_double3 :: proc "c" (x, y: double3) -> double3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_double4 :: proc "c" (x, y: double4) -> double4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_int2 :: proc "c" (x, y: int2) -> int2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_int3 :: proc "c" (x, y: int3) -> int3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_int4 :: proc "c" (x, y: int4) -> int4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(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_double :: proc "c" (x, y: double) -> double { return builtin.max(x, y) } +@(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)} } +@(require_results) max_double2 :: proc "c" (x, y: double2) -> double2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_double3 :: proc "c" (x, y: double3) -> double3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_double4 :: proc "c" (x, y: double4) -> double4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_int2 :: proc "c" (x, y: int2) -> int2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_int3 :: proc "c" (x, y: int3) -> int3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_int4 :: proc "c" (x, y: int4) -> int4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @@ -817,22 +817,22 @@ clamp :: proc{ clamp_uint3, clamp_uint4, } -clamp_int :: proc "c" (x, y, z: int) -> int { return builtin.clamp(x, y, z) } -clamp_uint :: proc "c" (x, y, z: uint) -> uint { return builtin.clamp(x, y, z) } -clamp_float :: proc "c" (x, y, z: float) -> float { return builtin.clamp(x, y, z) } -clamp_double :: proc "c" (x, y, z: double) -> double { return builtin.clamp(x, y, z) } -clamp_float2 :: proc "c" (x, y, z: float2) -> float2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -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)} } -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)} } -clamp_double2 :: proc "c" (x, y, z: double2) -> double2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_double3 :: proc "c" (x, y, z: double3) -> double3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_double4 :: proc "c" (x, y, z: double4) -> double4 { 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)} } -clamp_int2 :: proc "c" (x, y, z: int2) -> int2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_int3 :: proc "c" (x, y, z: int3) -> int3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_int4 :: proc "c" (x, y, z: int4) -> int4 { 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)} } -clamp_uint2 :: proc "c" (x, y, z: uint2) -> uint2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_uint3 :: proc "c" (x, y, z: uint3) -> uint3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_uint4 :: proc "c" (x, y, z: uint4) -> uint4 { 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_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_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_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)} } +@(require_results) clamp_double2 :: proc "c" (x, y, z: double2) -> double2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_double3 :: proc "c" (x, y, z: double3) -> double3 { 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_double4 :: proc "c" (x, y, z: double4) -> double4 { 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_int2 :: proc "c" (x, y, z: int2) -> int2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_int3 :: proc "c" (x, y, z: int3) -> int3 { 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_int4 :: proc "c" (x, y, z: int4) -> int4 { 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_uint2 :: proc "c" (x, y, z: uint2) -> uint2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_uint3 :: proc "c" (x, y, z: uint3) -> uint3 { 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_uint4 :: proc "c" (x, y, z: uint4) -> uint4 { 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)} } saturate :: proc{ saturate_int, @@ -852,22 +852,22 @@ saturate :: proc{ saturate_uint3, saturate_uint4, } -saturate_int :: proc "c" (v: int) -> int { return builtin.clamp(v, 0, 1) } -saturate_uint :: proc "c" (v: uint) -> uint { return builtin.clamp(v, 0, 1) } -saturate_float :: proc "c" (v: float) -> float { return builtin.clamp(v, 0, 1) } -saturate_double :: proc "c" (v: double) -> double { return builtin.clamp(v, 0, 1) } -saturate_float2 :: proc "c" (v: float2) -> float2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -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)} } -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)} } -saturate_double2 :: proc "c" (v: double2) -> double2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_double3 :: proc "c" (v: double3) -> double3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_double4 :: proc "c" (v: double4) -> double4 { 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)} } -saturate_int2 :: proc "c" (v: int2) -> int2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_int3 :: proc "c" (v: int3) -> int3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_int4 :: proc "c" (v: int4) -> int4 { 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)} } -saturate_uint2 :: proc "c" (v: uint2) -> uint2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_uint3 :: proc "c" (v: uint3) -> uint3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_uint4 :: proc "c" (v: uint4) -> uint4 { 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_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_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_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)} } +@(require_results) saturate_double2 :: proc "c" (v: double2) -> double2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_double3 :: proc "c" (v: double3) -> double3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_double4 :: proc "c" (v: double4) -> double4 { 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_int2 :: proc "c" (v: int2) -> int2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_int3 :: proc "c" (v: int3) -> int3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_int4 :: proc "c" (v: int4) -> int4 { 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_uint2 :: proc "c" (v: uint2) -> uint2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_uint3 :: proc "c" (v: uint3) -> uint3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_uint4 :: proc "c" (v: uint4) -> uint4 { 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)} } lerp :: proc{ @@ -880,14 +880,14 @@ lerp :: proc{ lerp_double3, lerp_double4, } -lerp_float :: proc "c" (x, y, t: float) -> float { return x*(1-t) + y*t } -lerp_double :: proc "c" (x, y, t: double) -> double { return x*(1-t) + y*t } -lerp_float2 :: proc "c" (x, y, t: float2) -> float2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -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)} } -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)} } -lerp_double2 :: proc "c" (x, y, t: double2) -> double2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_double3 :: proc "c" (x, y, t: double3) -> double3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_double4 :: proc "c" (x, y, t: double4) -> double4 { 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_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_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)} } +@(require_results) lerp_double2 :: proc "c" (x, y, t: double2) -> double2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_double3 :: proc "c" (x, y, t: double3) -> double3 { 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_double4 :: proc "c" (x, y, t: double4) -> double4 { 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)} } step :: proc{ @@ -900,14 +900,14 @@ step :: proc{ step_double3, step_double4, } -step_float :: proc "c" (edge, x: float) -> float { return 0 if x < edge else 1 } -step_double :: proc "c" (edge, x: double) -> double { return 0 if x < edge else 1 } -step_float2 :: proc "c" (edge, x: float2) -> float2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_float3 :: proc "c" (edge, x: float3) -> float3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -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)} } -step_double2 :: proc "c" (edge, x: double2) -> double2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_double3 :: proc "c" (edge, x: double3) -> double3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -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)} } +@(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_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)} } +@(require_results) step_double2 :: proc "c" (edge, x: double2) -> double2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_double3 :: proc "c" (edge, x: double3) -> double3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(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_float, @@ -919,20 +919,20 @@ smoothstep :: proc{ smoothstep_double3, smoothstep_double4, } -smoothstep_float :: proc "c" (edge0, edge1, x: float) -> float { +@(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) } -smoothstep_double :: proc "c" (edge0, edge1, x: double) -> double { +@(require_results) smoothstep_double :: proc "c" (edge0, edge1, x: double) -> double { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_float2 :: proc "c" (edge0, edge1, x: float2) -> float2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -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)} } -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)} } -smoothstep_double2 :: proc "c" (edge0, edge1, x: double2) -> double2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_double3 :: proc "c" (edge0, edge1, x: double3) -> double3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_double4 :: proc "c" (edge0, edge1, x: double4) -> double4 { 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)} } +@(require_results) smoothstep_double2 :: proc "c" (edge0, edge1, x: double2) -> double2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_double3 :: proc "c" (edge0, edge1, x: double3) -> double3 { 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_double4 :: proc "c" (edge0, edge1, x: double4) -> double4 { 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)} } abs :: proc{ @@ -953,22 +953,22 @@ abs :: proc{ abs_uint3, abs_uint4, } -abs_int :: proc "c" (x: int) -> int { return builtin.abs(x) } -abs_uint :: proc "c" (x: uint) -> uint { return x } -abs_float :: proc "c" (x: float) -> float { return builtin.abs(x) } -abs_double :: proc "c" (x: double) -> double { return builtin.abs(x) } -abs_float2 :: proc "c" (x: float2) -> float2 { return {abs(x.x), abs(x.y)} } -abs_float3 :: proc "c" (x: float3) -> float3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_float4 :: proc "c" (x: float4) -> float4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_double2 :: proc "c" (x: double2) -> double2 { return {abs(x.x), abs(x.y)} } -abs_double3 :: proc "c" (x: double3) -> double3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_double4 :: proc "c" (x: double4) -> double4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_int2 :: proc "c" (x: int2) -> int2 { return {abs(x.x), abs(x.y)} } -abs_int3 :: proc "c" (x: int3) -> int3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_int4 :: proc "c" (x: int4) -> int4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_uint2 :: proc "c" (x: uint2) -> uint2 { return x } -abs_uint3 :: proc "c" (x: uint3) -> uint3 { return x } -abs_uint4 :: proc "c" (x: uint4) -> uint4 { return x } +@(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_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_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)} } +@(require_results) abs_double2 :: proc "c" (x: double2) -> double2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_double3 :: proc "c" (x: double3) -> double3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_double4 :: proc "c" (x: double4) -> double4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_int2 :: proc "c" (x: int2) -> int2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_int3 :: proc "c" (x: int3) -> int3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_int4 :: proc "c" (x: int4) -> int4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_uint2 :: proc "c" (x: uint2) -> uint2 { return x } +@(require_results) abs_uint3 :: proc "c" (x: uint3) -> uint3 { return x } +@(require_results) abs_uint4 :: proc "c" (x: uint4) -> uint4 { return x } dot :: proc{ dot_int, @@ -988,22 +988,22 @@ dot :: proc{ dot_uint3, dot_uint4, } -dot_int :: proc "c" (a, b: int) -> int { return a*b } -dot_uint :: proc "c" (a, b: uint) -> uint { return a*b } -dot_float :: proc "c" (a, b: float) -> float { return a*b } -dot_double :: proc "c" (a, b: double) -> double { return a*b } -dot_float2 :: proc "c" (a, b: float2) -> float { return a.x*b.x + a.y*b.y } -dot_float3 :: proc "c" (a, b: float3) -> float { return a.x*b.x + a.y*b.y + a.z*b.z } -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 } -dot_double2 :: proc "c" (a, b: double2) -> double { return a.x*b.x + a.y*b.y } -dot_double3 :: proc "c" (a, b: double3) -> double { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_double4 :: proc "c" (a, b: double4) -> double { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_int2 :: proc "c" (a, b: int2) -> int { return a.x*b.x + a.y*b.y } -dot_int3 :: proc "c" (a, b: int3) -> int { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_int4 :: proc "c" (a, b: int4) -> int { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_uint2 :: proc "c" (a, b: uint2) -> uint { return a.x*b.x + a.y*b.y } -dot_uint3 :: proc "c" (a, b: uint3) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z } -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 } +@(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_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_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 } +@(require_results) dot_double2 :: proc "c" (a, b: double2) -> double { return a.x*b.x + a.y*b.y } +@(require_results) dot_double3 :: proc "c" (a, b: double3) -> double { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_double4 :: proc "c" (a, b: double4) -> double { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_int2 :: proc "c" (a, b: int2) -> int { return a.x*b.x + a.y*b.y } +@(require_results) dot_int3 :: proc "c" (a, b: int3) -> int { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_int4 :: proc "c" (a, b: int4) -> int { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_uint2 :: proc "c" (a, b: uint2) -> uint { return a.x*b.x + a.y*b.y } +@(require_results) dot_uint3 :: proc "c" (a, b: uint3) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z } +@(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_float, @@ -1015,14 +1015,14 @@ length :: proc{ length_double3, length_double4, } -length_float :: proc "c" (x: float) -> float { return builtin.abs(x) } -length_double :: proc "c" (x: double) -> double { return builtin.abs(x) } -length_float2 :: proc "c" (x: float2) -> float { return sqrt(x.x*x.x + x.y*x.y) } -length_float3 :: proc "c" (x: float3) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -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) } -length_double2 :: proc "c" (x: double2) -> double { return sqrt(x.x*x.x + x.y*x.y) } -length_double3 :: proc "c" (x: double3) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_double4 :: proc "c" (x: double4) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(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_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) } +@(require_results) length_double2 :: proc "c" (x: double2) -> double { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_double3 :: proc "c" (x: double3) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_double4 :: proc "c" (x: double4) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } distance :: proc{ @@ -1035,14 +1035,14 @@ distance :: proc{ distance_double3, distance_double4, } -distance_float :: proc "c" (x, y: float) -> float { return length(y-x) } -distance_double :: proc "c" (x, y: double) -> double { return length(y-x) } -distance_float2 :: proc "c" (x, y: float2) -> float { return length(y-x) } -distance_float3 :: proc "c" (x, y: float3) -> float { return length(y-x) } -distance_float4 :: proc "c" (x, y: float4) -> float { return length(y-x) } -distance_double2 :: proc "c" (x, y: double2) -> double { return length(y-x) } -distance_double3 :: proc "c" (x, y: double3) -> double { return length(y-x) } -distance_double4 :: proc "c" (x, y: double4) -> double { 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_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) } +@(require_results) distance_double2 :: proc "c" (x, y: double2) -> double { return length(y-x) } +@(require_results) distance_double3 :: proc "c" (x, y: double3) -> double { return length(y-x) } +@(require_results) distance_double4 :: proc "c" (x, y: double4) -> double { return length(y-x) } cross :: proc{ @@ -1051,19 +1051,19 @@ cross :: proc{ cross_int3, } -cross_float3 :: proc "c" (a, b: float3) -> (c: float3) { +@(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 c.z = a.x*b.y - b.x*a.y return } -cross_double3 :: proc "c" (a, b: double3) -> (c: double3) { +@(require_results) cross_double3 :: proc "c" (a, b: double3) -> (c: double3) { 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 } -cross_int3 :: proc "c" (a, b: int3) -> (c: int3) { +@(require_results) cross_int3 :: proc "c" (a, b: int3) -> (c: int3) { 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 @@ -1080,14 +1080,14 @@ normalize :: proc{ normalize_double3, normalize_double4, } -normalize_float :: proc "c" (x: float) -> float { return 1.0 } -normalize_double :: proc "c" (x: double) -> double { return 1.0 } -normalize_float2 :: proc "c" (x: float2) -> float2 { return x / length(x) } -normalize_float3 :: proc "c" (x: float3) -> float3 { return x / length(x) } -normalize_float4 :: proc "c" (x: float4) -> float4 { return x / length(x) } -normalize_double2 :: proc "c" (x: double2) -> double2 { return x / length(x) } -normalize_double3 :: proc "c" (x: double3) -> double3 { return x / length(x) } -normalize_double4 :: proc "c" (x: double4) -> double4 { return x / length(x) } +@(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_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) } +@(require_results) normalize_double2 :: proc "c" (x: double2) -> double2 { return x / length(x) } +@(require_results) normalize_double3 :: proc "c" (x: double3) -> double3 { return x / length(x) } +@(require_results) normalize_double4 :: proc "c" (x: double4) -> double4 { return x / length(x) } faceforward :: proc{ @@ -1100,14 +1100,14 @@ faceforward :: proc{ faceforward_double3, faceforward_double4, } -faceforward_float :: proc "c" (N, I, Nref: float) -> float { return N if dot(I, Nref) < 0 else -N } -faceforward_double :: proc "c" (N, I, Nref: double) -> double { return N if dot(I, Nref) < 0 else -N } -faceforward_float2 :: proc "c" (N, I, Nref: float2) -> float2 { return N if dot(I, Nref) < 0 else -N } -faceforward_float3 :: proc "c" (N, I, Nref: float3) -> float3 { return N if dot(I, Nref) < 0 else -N } -faceforward_float4 :: proc "c" (N, I, Nref: float4) -> float4 { return N if dot(I, Nref) < 0 else -N } -faceforward_double2 :: proc "c" (N, I, Nref: double2) -> double2 { return N if dot(I, Nref) < 0 else -N } -faceforward_double3 :: proc "c" (N, I, Nref: double3) -> double3 { return N if dot(I, Nref) < 0 else -N } -faceforward_double4 :: proc "c" (N, I, Nref: double4) -> double4 { 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_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 } +@(require_results) faceforward_double2 :: proc "c" (N, I, Nref: double2) -> double2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double3 :: proc "c" (N, I, Nref: double3) -> double3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double4 :: proc "c" (N, I, Nref: double4) -> double4 { return N if dot(I, Nref) < 0 else -N } reflect :: proc{ @@ -1120,14 +1120,14 @@ reflect :: proc{ reflect_double3, reflect_double4, } -reflect_float :: proc "c" (I, N: float) -> float { return I - 2*N*dot(N, I) } -reflect_double :: proc "c" (I, N: double) -> double { return I - 2*N*dot(N, I) } -reflect_float2 :: proc "c" (I, N: float2) -> float2 { return I - 2*N*dot(N, I) } -reflect_float3 :: proc "c" (I, N: float3) -> float3 { return I - 2*N*dot(N, I) } -reflect_float4 :: proc "c" (I, N: float4) -> float4 { return I - 2*N*dot(N, I) } -reflect_double2 :: proc "c" (I, N: double2) -> double2 { return I - 2*N*dot(N, I) } -reflect_double3 :: proc "c" (I, N: double3) -> double3 { return I - 2*N*dot(N, I) } -reflect_double4 :: proc "c" (I, N: double4) -> double4 { 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_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) } +@(require_results) reflect_double2 :: proc "c" (I, N: double2) -> double2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_double3 :: proc "c" (I, N: double3) -> double3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_double4 :: proc "c" (I, N: double4) -> double4 { return I - 2*N*dot(N, I) } @@ -1142,49 +1142,57 @@ refract :: proc{ refract_double3, refract_double4, } -refract_float :: proc "c" (i, n, eta: float) -> float { +@(require_results) +refract_float :: proc "c" (i, n, eta: float) -> float { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float(int(cost2 > 0)) } -refract_double :: proc "c" (i, n, eta: double) -> double { +@(require_results) +refract_double :: proc "c" (i, n, eta: double) -> double { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double(int(cost2 > 0)) } -refract_float2 :: proc "c" (i, n, eta: float2) -> float2 { +@(require_results) +refract_float2 :: proc "c" (i, n, eta: float2) -> float2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float2{float(int(cost2.x > 0)), float(int(cost2.y > 0))} } -refract_float3 :: proc "c" (i, n, eta: float3) -> float3 { +@(require_results) +refract_float3 :: proc "c" (i, n, eta: float3) -> float3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float3{float(int(cost2.x > 0)), float(int(cost2.y > 0)), float(int(cost2.z > 0))} } -refract_float4 :: proc "c" (i, n, eta: float4) -> float4 { +@(require_results) +refract_float4 :: proc "c" (i, n, eta: float4) -> float4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float4{float(int(cost2.x > 0)), float(int(cost2.y > 0)), float(int(cost2.z > 0)), float(int(cost2.w > 0))} } -refract_double2 :: proc "c" (i, n, eta: double2) -> double2 { +@(require_results) +refract_double2 :: proc "c" (i, n, eta: double2) -> double2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double2{double(int(cost2.x > 0)), double(int(cost2.y > 0))} } -refract_double3 :: proc "c" (i, n, eta: double3) -> double3 { +@(require_results) +refract_double3 :: proc "c" (i, n, eta: double3) -> double3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double3{double(int(cost2.x > 0)), double(int(cost2.y > 0)), double(int(cost2.z > 0))} } -refract_double4 :: proc "c" (i, n, eta: double4) -> double4 { +@(require_results) +refract_double4 :: proc "c" (i, n, eta: double4) -> double4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) @@ -1196,18 +1204,18 @@ scalarTripleProduct :: proc{ scalarTripleProduct_double3, scalarTripleProduct_int3, } -scalarTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float { return dot(a, cross(b, c)) } -scalarTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double { return dot(a, cross(b, c)) } -scalarTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int { 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_float3, vectorTripleProduct_double3, vectorTripleProduct_int3, } -vectorTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float3 { return cross(a, cross(b, c)) } -vectorTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double3 { return cross(a, cross(b, c)) } -vectorTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int3 { 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)) } // Vector Relational Procedures @@ -1230,22 +1238,22 @@ lessThan :: proc{ lessThan_int4, lessThan_uint4, } -lessThan_float :: proc "c" (a, b: float) -> bool { return a < b } -lessThan_double :: proc "c" (a, b: double) -> bool { return a < b } -lessThan_int :: proc "c" (a, b: int) -> bool { return a < b } -lessThan_uint :: proc "c" (a, b: uint) -> bool { return a < b } -lessThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -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} } -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} } -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} } -lessThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(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_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_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_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} } +@(require_results) lessThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } lessThanEqual :: proc{ @@ -1266,22 +1274,22 @@ lessThanEqual :: proc{ lessThanEqual_int4, lessThanEqual_uint4, } -lessThanEqual_float :: proc "c" (a, b: float) -> bool { return a <= b } -lessThanEqual_double :: proc "c" (a, b: double) -> bool { return a <= b } -lessThanEqual_int :: proc "c" (a, b: int) -> bool { return a <= b } -lessThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a <= b } -lessThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -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} } -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} } -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} } -lessThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(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_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_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_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} } +@(require_results) lessThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } greaterThan :: proc{ @@ -1302,22 +1310,22 @@ greaterThan :: proc{ greaterThan_int4, greaterThan_uint4, } -greaterThan_float :: proc "c" (a, b: float) -> bool { return a > b } -greaterThan_double :: proc "c" (a, b: double) -> bool { return a > b } -greaterThan_int :: proc "c" (a, b: int) -> bool { return a > b } -greaterThan_uint :: proc "c" (a, b: uint) -> bool { return a > b } -greaterThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -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} } -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} } -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} } -greaterThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(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_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_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_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} } +@(require_results) greaterThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } greaterThanEqual :: proc{ @@ -1338,22 +1346,22 @@ greaterThanEqual :: proc{ greaterThanEqual_int4, greaterThanEqual_uint4, } -greaterThanEqual_float :: proc "c" (a, b: float) -> bool { return a >= b } -greaterThanEqual_double :: proc "c" (a, b: double) -> bool { return a >= b } -greaterThanEqual_int :: proc "c" (a, b: int) -> bool { return a >= b } -greaterThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a >= b } -greaterThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -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} } -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} } -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} } -greaterThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(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_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_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_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} } +@(require_results) greaterThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } equal :: proc{ @@ -1374,22 +1382,22 @@ equal :: proc{ equal_int4, equal_uint4, } -equal_float :: proc "c" (a, b: float) -> bool { return a == b } -equal_double :: proc "c" (a, b: double) -> bool { return a == b } -equal_int :: proc "c" (a, b: int) -> bool { return a == b } -equal_uint :: proc "c" (a, b: uint) -> bool { return a == b } -equal_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -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} } -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} } -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} } -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} } +@(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_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_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_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_float, @@ -1409,22 +1417,22 @@ notEqual :: proc{ notEqual_int4, notEqual_uint4, } -notEqual_float :: proc "c" (a, b: float) -> bool { return a != b } -notEqual_double :: proc "c" (a, b: double) -> bool { return a != b } -notEqual_int :: proc "c" (a, b: int) -> bool { return a != b } -notEqual_uint :: proc "c" (a, b: uint) -> bool { return a != b } -notEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -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} } -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} } -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} } -notEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(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_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_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_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} } +@(require_results) notEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } any :: proc{ @@ -1433,10 +1441,10 @@ any :: proc{ any_bool3, any_bool4, } -any_bool :: proc "c" (v: bool) -> bool { return v } -any_bool2 :: proc "c" (v: bool2) -> bool { return v.x || v.y } -any_bool3 :: proc "c" (v: bool3) -> bool { return v.x || v.y || v.z } -any_bool4 :: proc "c" (v: bool4) -> bool { return v.x || v.y || v.z || v.w } +@(require_results) any_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) any_bool2 :: proc "c" (v: bool2) -> bool { return v.x || v.y } +@(require_results) any_bool3 :: proc "c" (v: bool3) -> bool { return v.x || v.y || v.z } +@(require_results) any_bool4 :: proc "c" (v: bool4) -> bool { return v.x || v.y || v.z || v.w } all :: proc{ all_bool, @@ -1444,10 +1452,10 @@ all :: proc{ all_bool3, all_bool4, } -all_bool :: proc "c" (v: bool) -> bool { return v } -all_bool2 :: proc "c" (v: bool2) -> bool { return v.x && v.y } -all_bool3 :: proc "c" (v: bool3) -> bool { return v.x && v.y && v.z } -all_bool4 :: proc "c" (v: bool4) -> bool { return v.x && v.y && v.z && v.w } +@(require_results) all_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) all_bool2 :: proc "c" (v: bool2) -> bool { return v.x && v.y } +@(require_results) all_bool3 :: proc "c" (v: bool3) -> bool { return v.x && v.y && v.z } +@(require_results) all_bool4 :: proc "c" (v: bool4) -> bool { return v.x && v.y && v.z && v.w } not :: proc{ not_bool, @@ -1455,22 +1463,22 @@ not :: proc{ not_bool3, not_bool4, } -not_bool :: proc "c" (v: bool) -> bool { return !v } -not_bool2 :: proc "c" (v: bool2) -> bool2 { return {!v.x, !v.y} } -not_bool3 :: proc "c" (v: bool3) -> bool3 { return {!v.x, !v.y, !v.z} } -not_bool4 :: proc "c" (v: bool4) -> bool4 { return {!v.x, !v.y, !v.z, !v.w} } +@(require_results) not_bool :: proc "c" (v: bool) -> bool { return !v } +@(require_results) not_bool2 :: proc "c" (v: bool2) -> bool2 { return {!v.x, !v.y} } +@(require_results) not_bool3 :: proc "c" (v: bool3) -> bool3 { return {!v.x, !v.y, !v.z} } +@(require_results) not_bool4 :: proc "c" (v: bool4) -> bool4 { return {!v.x, !v.y, !v.z, !v.w} } -inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return builtin.inverse(m) } -inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return builtin.inverse(m) } -inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return builtin.inverse(m) } -inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return builtin.inverse(m) } -inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return builtin.inverse(m) } -inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return builtin.inverse(m) } -inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return builtin.inverse(m) } -inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return builtin.inverse(m) } +@(require_results) inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return builtin.inverse(m) } +@(require_results) inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return builtin.inverse(m) } +@(require_results) inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return builtin.inverse(m) } +@(require_results) inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return builtin.inverse(m) } +@(require_results) inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return builtin.inverse(m) } +@(require_results) inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return builtin.inverse(m) } +@(require_results) inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return builtin.inverse(m) } +@(require_results) inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return builtin.inverse(m) } inverse :: proc{ inverse_float1x1, @@ -1544,57 +1552,57 @@ asfloat :: proc{ asfloat_double3, asfloat_double4, } -asfloat_float :: proc "c" (v: float) -> float { return float(v) } -asfloat_double :: proc "c" (v: double) -> float { return float(v) } -asfloat_int :: proc "c" (v: int) -> float { return float(v) } -asfloat_uint :: proc "c" (v: uint) -> float { return float(v) } -asfloat_float1x1 :: proc "c" (v: float1x1) -> float1x1 { return float1x1(v) } -asfloat_float2x2 :: proc "c" (v: float2x2) -> float2x2 { return float2x2(v) } -asfloat_float3x3 :: proc "c" (v: float3x3) -> float3x3 { return float3x3(v) } -asfloat_float4x4 :: proc "c" (v: float4x4) -> float4x4 { return float4x4(v) } -asfloat_float1x2 :: proc "c" (v: float1x2) -> float1x2 { return float1x2(v) } -asfloat_float1x3 :: proc "c" (v: float1x3) -> float1x3 { return float1x3(v) } -asfloat_float1x4 :: proc "c" (v: float1x4) -> float1x4 { return float1x4(v) } -asfloat_float2x1 :: proc "c" (v: float2x1) -> float2x1 { return float2x1(v) } -asfloat_float2x3 :: proc "c" (v: float2x3) -> float2x3 { return float2x3(v) } -asfloat_float2x4 :: proc "c" (v: float2x4) -> float2x4 { return float2x4(v) } -asfloat_float3x1 :: proc "c" (v: float3x1) -> float3x1 { return float3x1(v) } -asfloat_float3x2 :: proc "c" (v: float3x2) -> float3x2 { return float3x2(v) } -asfloat_float3x4 :: proc "c" (v: float3x4) -> float3x4 { return float3x4(v) } -asfloat_float4x1 :: proc "c" (v: float4x1) -> float4x1 { return float4x1(v) } -asfloat_float4x2 :: proc "c" (v: float4x2) -> float4x2 { return float4x2(v) } -asfloat_float4x3 :: proc "c" (v: float4x3) -> float4x3 { return float4x3(v) } -asfloat_float2 :: proc "c" (v: float2) -> float2 { return float2(v) } -asfloat_float3 :: proc "c" (v: float3) -> float3 { return float3(v) } -asfloat_float4 :: proc "c" (v: float4) -> float4 { return float4(v) } -asfloat_int2 :: proc "c" (v: int2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_int3 :: proc "c" (v: int3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_int4 :: proc "c" (v: int4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } -asfloat_uint2 :: proc "c" (v: uint2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_uint3 :: proc "c" (v: uint3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_uint4 :: proc "c" (v: uint4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } -asfloat_bool2 :: proc "c" (v: bool2) -> float2 { return float2{float(int(v.x)), float(int(v.y))} } -asfloat_bool3 :: proc "c" (v: bool3) -> float3 { return float3{float(int(v.x)), float(int(v.y)), float(int(v.z))} } -asfloat_bool4 :: proc "c" (v: bool4) -> float4 { return float4{float(int(v.x)), float(int(v.y)), float(int(v.z)), float(int(v.w))} } -asfloat_double1x1 :: proc "c" (v: double1x1) -> float1x1 { return float1x1(v) } -asfloat_double2x2 :: proc "c" (v: double2x2) -> float2x2 { return float2x2(v) } -asfloat_double3x3 :: proc "c" (v: double3x3) -> float3x3 { return float3x3(v) } -asfloat_double4x4 :: proc "c" (v: double4x4) -> float4x4 { return float4x4(v) } -asfloat_double1x2 :: proc "c" (v: double1x2) -> float1x2 { return float1x2(v) } -asfloat_double1x3 :: proc "c" (v: double1x3) -> float1x3 { return float1x3(v) } -asfloat_double1x4 :: proc "c" (v: double1x4) -> float1x4 { return float1x4(v) } -asfloat_double2x1 :: proc "c" (v: double2x1) -> float2x1 { return float2x1(v) } -asfloat_double2x3 :: proc "c" (v: double2x3) -> float2x3 { return float2x3(v) } -asfloat_double2x4 :: proc "c" (v: double2x4) -> float2x4 { return float2x4(v) } -asfloat_double3x1 :: proc "c" (v: double3x1) -> float3x1 { return float3x1(v) } -asfloat_double3x2 :: proc "c" (v: double3x2) -> float3x2 { return float3x2(v) } -asfloat_double3x4 :: proc "c" (v: double3x4) -> float3x4 { return float3x4(v) } -asfloat_double4x1 :: proc "c" (v: double4x1) -> float4x1 { return float4x1(v) } -asfloat_double4x2 :: proc "c" (v: double4x2) -> float4x2 { return float4x2(v) } -asfloat_double4x3 :: proc "c" (v: double4x3) -> float4x3 { return float4x3(v) } -asfloat_double2 :: proc "c" (v: double2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_double3 :: proc "c" (v: double3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_double4 :: proc "c" (v: double4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(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_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) } +@(require_results) asfloat_float4x4 :: proc "c" (v: float4x4) -> float4x4 { return float4x4(v) } +@(require_results) asfloat_float1x2 :: proc "c" (v: float1x2) -> float1x2 { return float1x2(v) } +@(require_results) asfloat_float1x3 :: proc "c" (v: float1x3) -> float1x3 { return float1x3(v) } +@(require_results) asfloat_float1x4 :: proc "c" (v: float1x4) -> float1x4 { return float1x4(v) } +@(require_results) asfloat_float2x1 :: proc "c" (v: float2x1) -> float2x1 { return float2x1(v) } +@(require_results) asfloat_float2x3 :: proc "c" (v: float2x3) -> float2x3 { return float2x3(v) } +@(require_results) asfloat_float2x4 :: proc "c" (v: float2x4) -> float2x4 { return float2x4(v) } +@(require_results) asfloat_float3x1 :: proc "c" (v: float3x1) -> float3x1 { return float3x1(v) } +@(require_results) asfloat_float3x2 :: proc "c" (v: float3x2) -> float3x2 { return float3x2(v) } +@(require_results) asfloat_float3x4 :: proc "c" (v: float3x4) -> float3x4 { return float3x4(v) } +@(require_results) asfloat_float4x1 :: proc "c" (v: float4x1) -> float4x1 { return float4x1(v) } +@(require_results) asfloat_float4x2 :: proc "c" (v: float4x2) -> float4x2 { return float4x2(v) } +@(require_results) asfloat_float4x3 :: proc "c" (v: float4x3) -> float4x3 { return float4x3(v) } +@(require_results) asfloat_float2 :: proc "c" (v: float2) -> float2 { return float2(v) } +@(require_results) asfloat_float3 :: proc "c" (v: float3) -> float3 { return float3(v) } +@(require_results) asfloat_float4 :: proc "c" (v: float4) -> float4 { return float4(v) } +@(require_results) asfloat_int2 :: proc "c" (v: int2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_int3 :: proc "c" (v: int3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_int4 :: proc "c" (v: int4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(require_results) asfloat_uint2 :: proc "c" (v: uint2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_uint3 :: proc "c" (v: uint3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_uint4 :: proc "c" (v: uint4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(require_results) asfloat_bool2 :: proc "c" (v: bool2) -> float2 { return float2{float(int(v.x)), float(int(v.y))} } +@(require_results) asfloat_bool3 :: proc "c" (v: bool3) -> float3 { return float3{float(int(v.x)), float(int(v.y)), float(int(v.z))} } +@(require_results) asfloat_bool4 :: proc "c" (v: bool4) -> float4 { return float4{float(int(v.x)), float(int(v.y)), float(int(v.z)), float(int(v.w))} } +@(require_results) asfloat_double1x1 :: proc "c" (v: double1x1) -> float1x1 { return float1x1(v) } +@(require_results) asfloat_double2x2 :: proc "c" (v: double2x2) -> float2x2 { return float2x2(v) } +@(require_results) asfloat_double3x3 :: proc "c" (v: double3x3) -> float3x3 { return float3x3(v) } +@(require_results) asfloat_double4x4 :: proc "c" (v: double4x4) -> float4x4 { return float4x4(v) } +@(require_results) asfloat_double1x2 :: proc "c" (v: double1x2) -> float1x2 { return float1x2(v) } +@(require_results) asfloat_double1x3 :: proc "c" (v: double1x3) -> float1x3 { return float1x3(v) } +@(require_results) asfloat_double1x4 :: proc "c" (v: double1x4) -> float1x4 { return float1x4(v) } +@(require_results) asfloat_double2x1 :: proc "c" (v: double2x1) -> float2x1 { return float2x1(v) } +@(require_results) asfloat_double2x3 :: proc "c" (v: double2x3) -> float2x3 { return float2x3(v) } +@(require_results) asfloat_double2x4 :: proc "c" (v: double2x4) -> float2x4 { return float2x4(v) } +@(require_results) asfloat_double3x1 :: proc "c" (v: double3x1) -> float3x1 { return float3x1(v) } +@(require_results) asfloat_double3x2 :: proc "c" (v: double3x2) -> float3x2 { return float3x2(v) } +@(require_results) asfloat_double3x4 :: proc "c" (v: double3x4) -> float3x4 { return float3x4(v) } +@(require_results) asfloat_double4x1 :: proc "c" (v: double4x1) -> float4x1 { return float4x1(v) } +@(require_results) asfloat_double4x2 :: proc "c" (v: double4x2) -> float4x2 { return float4x2(v) } +@(require_results) asfloat_double4x3 :: proc "c" (v: double4x3) -> float4x3 { return float4x3(v) } +@(require_results) asfloat_double2 :: proc "c" (v: double2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_double3 :: proc "c" (v: double3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(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_float, @@ -1649,57 +1657,57 @@ asdouble :: proc{ asdouble_double3, asdouble_double4, } -asdouble_float :: proc "c" (v: float) -> double { return double(v) } -asdouble_double :: proc "c" (v: double) -> double { return double(v) } -asdouble_int :: proc "c" (v: int) -> double { return double(v) } -asdouble_uint :: proc "c" (v: uint) -> double { return double(v) } -asdouble_float1x1 :: proc "c" (v: float1x1) -> double1x1 { return double1x1(v) } -asdouble_float2x2 :: proc "c" (v: float2x2) -> double2x2 { return double2x2(v) } -asdouble_float3x3 :: proc "c" (v: float3x3) -> double3x3 { return double3x3(v) } -asdouble_float4x4 :: proc "c" (v: float4x4) -> double4x4 { return double4x4(v) } -asdouble_float1x2 :: proc "c" (v: float1x2) -> double1x2 { return double1x2(v) } -asdouble_float1x3 :: proc "c" (v: float1x3) -> double1x3 { return double1x3(v) } -asdouble_float1x4 :: proc "c" (v: float1x4) -> double1x4 { return double1x4(v) } -asdouble_float2x1 :: proc "c" (v: float2x1) -> double2x1 { return double2x1(v) } -asdouble_float2x3 :: proc "c" (v: float2x3) -> double2x3 { return double2x3(v) } -asdouble_float2x4 :: proc "c" (v: float2x4) -> double2x4 { return double2x4(v) } -asdouble_float3x1 :: proc "c" (v: float3x1) -> double3x1 { return double3x1(v) } -asdouble_float3x2 :: proc "c" (v: float3x2) -> double3x2 { return double3x2(v) } -asdouble_float3x4 :: proc "c" (v: float3x4) -> double3x4 { return double3x4(v) } -asdouble_float4x1 :: proc "c" (v: float4x1) -> double4x1 { return double4x1(v) } -asdouble_float4x2 :: proc "c" (v: float4x2) -> double4x2 { return double4x2(v) } -asdouble_float4x3 :: proc "c" (v: float4x3) -> double4x3 { return double4x3(v) } -asdouble_float2 :: proc "c" (v: float2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_float3 :: proc "c" (v: float3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_float4 :: proc "c" (v: float4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_int2 :: proc "c" (v: int2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_int3 :: proc "c" (v: int3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_int4 :: proc "c" (v: int4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_uint2 :: proc "c" (v: uint2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_uint3 :: proc "c" (v: uint3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_uint4 :: proc "c" (v: uint4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_bool2 :: proc "c" (v: bool2) -> double2 { return double2{double(int(v.x)), double(int(v.y))} } -asdouble_bool3 :: proc "c" (v: bool3) -> double3 { return double3{double(int(v.x)), double(int(v.y)), double(int(v.z))} } -asdouble_bool4 :: proc "c" (v: bool4) -> double4 { return double4{double(int(v.x)), double(int(v.y)), double(int(v.z)), double(int(v.w))} } -asdouble_double1x1 :: proc "c" (v: double1x1) -> double1x1 { return double1x1(v) } -asdouble_double2x2 :: proc "c" (v: double2x2) -> double2x2 { return double2x2(v) } -asdouble_double3x3 :: proc "c" (v: double3x3) -> double3x3 { return double3x3(v) } -asdouble_double4x4 :: proc "c" (v: double4x4) -> double4x4 { return double4x4(v) } -asdouble_double1x2 :: proc "c" (v: double1x2) -> double1x2 { return double1x2(v) } -asdouble_double1x3 :: proc "c" (v: double1x3) -> double1x3 { return double1x3(v) } -asdouble_double1x4 :: proc "c" (v: double1x4) -> double1x4 { return double1x4(v) } -asdouble_double2x1 :: proc "c" (v: double2x1) -> double2x1 { return double2x1(v) } -asdouble_double2x3 :: proc "c" (v: double2x3) -> double2x3 { return double2x3(v) } -asdouble_double2x4 :: proc "c" (v: double2x4) -> double2x4 { return double2x4(v) } -asdouble_double3x1 :: proc "c" (v: double3x1) -> double3x1 { return double3x1(v) } -asdouble_double3x2 :: proc "c" (v: double3x2) -> double3x2 { return double3x2(v) } -asdouble_double3x4 :: proc "c" (v: double3x4) -> double3x4 { return double3x4(v) } -asdouble_double4x1 :: proc "c" (v: double4x1) -> double4x1 { return double4x1(v) } -asdouble_double4x2 :: proc "c" (v: double4x2) -> double4x2 { return double4x2(v) } -asdouble_double4x3 :: proc "c" (v: double4x3) -> double4x3 { return double4x3(v) } -asdouble_double2 :: proc "c" (v: double2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_double3 :: proc "c" (v: double3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_double4 :: proc "c" (v: double4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(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_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) } +@(require_results) asdouble_float4x4 :: proc "c" (v: float4x4) -> double4x4 { return double4x4(v) } +@(require_results) asdouble_float1x2 :: proc "c" (v: float1x2) -> double1x2 { return double1x2(v) } +@(require_results) asdouble_float1x3 :: proc "c" (v: float1x3) -> double1x3 { return double1x3(v) } +@(require_results) asdouble_float1x4 :: proc "c" (v: float1x4) -> double1x4 { return double1x4(v) } +@(require_results) asdouble_float2x1 :: proc "c" (v: float2x1) -> double2x1 { return double2x1(v) } +@(require_results) asdouble_float2x3 :: proc "c" (v: float2x3) -> double2x3 { return double2x3(v) } +@(require_results) asdouble_float2x4 :: proc "c" (v: float2x4) -> double2x4 { return double2x4(v) } +@(require_results) asdouble_float3x1 :: proc "c" (v: float3x1) -> double3x1 { return double3x1(v) } +@(require_results) asdouble_float3x2 :: proc "c" (v: float3x2) -> double3x2 { return double3x2(v) } +@(require_results) asdouble_float3x4 :: proc "c" (v: float3x4) -> double3x4 { return double3x4(v) } +@(require_results) asdouble_float4x1 :: proc "c" (v: float4x1) -> double4x1 { return double4x1(v) } +@(require_results) asdouble_float4x2 :: proc "c" (v: float4x2) -> double4x2 { return double4x2(v) } +@(require_results) asdouble_float4x3 :: proc "c" (v: float4x3) -> double4x3 { return double4x3(v) } +@(require_results) asdouble_float2 :: proc "c" (v: float2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_float3 :: proc "c" (v: float3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_float4 :: proc "c" (v: float4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_int2 :: proc "c" (v: int2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_int3 :: proc "c" (v: int3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_int4 :: proc "c" (v: int4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_uint2 :: proc "c" (v: uint2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_uint3 :: proc "c" (v: uint3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_uint4 :: proc "c" (v: uint4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_bool2 :: proc "c" (v: bool2) -> double2 { return double2{double(int(v.x)), double(int(v.y))} } +@(require_results) asdouble_bool3 :: proc "c" (v: bool3) -> double3 { return double3{double(int(v.x)), double(int(v.y)), double(int(v.z))} } +@(require_results) asdouble_bool4 :: proc "c" (v: bool4) -> double4 { return double4{double(int(v.x)), double(int(v.y)), double(int(v.z)), double(int(v.w))} } +@(require_results) asdouble_double1x1 :: proc "c" (v: double1x1) -> double1x1 { return double1x1(v) } +@(require_results) asdouble_double2x2 :: proc "c" (v: double2x2) -> double2x2 { return double2x2(v) } +@(require_results) asdouble_double3x3 :: proc "c" (v: double3x3) -> double3x3 { return double3x3(v) } +@(require_results) asdouble_double4x4 :: proc "c" (v: double4x4) -> double4x4 { return double4x4(v) } +@(require_results) asdouble_double1x2 :: proc "c" (v: double1x2) -> double1x2 { return double1x2(v) } +@(require_results) asdouble_double1x3 :: proc "c" (v: double1x3) -> double1x3 { return double1x3(v) } +@(require_results) asdouble_double1x4 :: proc "c" (v: double1x4) -> double1x4 { return double1x4(v) } +@(require_results) asdouble_double2x1 :: proc "c" (v: double2x1) -> double2x1 { return double2x1(v) } +@(require_results) asdouble_double2x3 :: proc "c" (v: double2x3) -> double2x3 { return double2x3(v) } +@(require_results) asdouble_double2x4 :: proc "c" (v: double2x4) -> double2x4 { return double2x4(v) } +@(require_results) asdouble_double3x1 :: proc "c" (v: double3x1) -> double3x1 { return double3x1(v) } +@(require_results) asdouble_double3x2 :: proc "c" (v: double3x2) -> double3x2 { return double3x2(v) } +@(require_results) asdouble_double3x4 :: proc "c" (v: double3x4) -> double3x4 { return double3x4(v) } +@(require_results) asdouble_double4x1 :: proc "c" (v: double4x1) -> double4x1 { return double4x1(v) } +@(require_results) asdouble_double4x2 :: proc "c" (v: double4x2) -> double4x2 { return double4x2(v) } +@(require_results) asdouble_double4x3 :: proc "c" (v: double4x3) -> double4x3 { return double4x3(v) } +@(require_results) asdouble_double2 :: proc "c" (v: double2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_double3 :: proc "c" (v: double3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(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_float, @@ -1754,57 +1762,57 @@ asint :: proc{ asint_double3, asint_double4, } -asint_float :: proc "c" (v: float) -> int { return int(v) } -asint_double :: proc "c" (v: double) -> int { return int(v) } -asint_int :: proc "c" (v: int) -> int { return int(v) } -asint_uint :: proc "c" (v: uint) -> int { return int(v) } -asint_float1x1 :: proc "c" (v: float1x1) -> int1x1 { return int1x1(v) } -asint_float2x2 :: proc "c" (v: float2x2) -> int2x2 { return int2x2(v) } -asint_float3x3 :: proc "c" (v: float3x3) -> int3x3 { return int3x3(v) } -asint_float4x4 :: proc "c" (v: float4x4) -> int4x4 { return int4x4(v) } -asint_float1x2 :: proc "c" (v: float1x2) -> int1x2 { return int1x2(v) } -asint_float1x3 :: proc "c" (v: float1x3) -> int1x3 { return int1x3(v) } -asint_float1x4 :: proc "c" (v: float1x4) -> int1x4 { return int1x4(v) } -asint_float2x1 :: proc "c" (v: float2x1) -> int2x1 { return int2x1(v) } -asint_float2x3 :: proc "c" (v: float2x3) -> int2x3 { return int2x3(v) } -asint_float2x4 :: proc "c" (v: float2x4) -> int2x4 { return int2x4(v) } -asint_float3x1 :: proc "c" (v: float3x1) -> int3x1 { return int3x1(v) } -asint_float3x2 :: proc "c" (v: float3x2) -> int3x2 { return int3x2(v) } -asint_float3x4 :: proc "c" (v: float3x4) -> int3x4 { return int3x4(v) } -asint_float4x1 :: proc "c" (v: float4x1) -> int4x1 { return int4x1(v) } -asint_float4x2 :: proc "c" (v: float4x2) -> int4x2 { return int4x2(v) } -asint_float4x3 :: proc "c" (v: float4x3) -> int4x3 { return int4x3(v) } -asint_float2 :: proc "c" (v: float2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_float3 :: proc "c" (v: float3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_float4 :: proc "c" (v: float4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_int2 :: proc "c" (v: int2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_int3 :: proc "c" (v: int3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_int4 :: proc "c" (v: int4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_uint2 :: proc "c" (v: uint2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_uint3 :: proc "c" (v: uint3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_uint4 :: proc "c" (v: uint4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_bool2 :: proc "c" (v: bool2) -> int2 { return int2{int(int(v.x)), int(int(v.y))} } -asint_bool3 :: proc "c" (v: bool3) -> int3 { return int3{int(int(v.x)), int(int(v.y)), int(int(v.z))} } -asint_bool4 :: proc "c" (v: bool4) -> int4 { return int4{int(int(v.x)), int(int(v.y)), int(int(v.z)), int(int(v.w))} } -asint_double1x1 :: proc "c" (v: double1x1) -> int1x1 { return int1x1(v) } -asint_double2x2 :: proc "c" (v: double2x2) -> int2x2 { return int2x2(v) } -asint_double3x3 :: proc "c" (v: double3x3) -> int3x3 { return int3x3(v) } -asint_double4x4 :: proc "c" (v: double4x4) -> int4x4 { return int4x4(v) } -asint_double1x2 :: proc "c" (v: double1x2) -> int1x2 { return int1x2(v) } -asint_double1x3 :: proc "c" (v: double1x3) -> int1x3 { return int1x3(v) } -asint_double1x4 :: proc "c" (v: double1x4) -> int1x4 { return int1x4(v) } -asint_double2x1 :: proc "c" (v: double2x1) -> int2x1 { return int2x1(v) } -asint_double2x3 :: proc "c" (v: double2x3) -> int2x3 { return int2x3(v) } -asint_double2x4 :: proc "c" (v: double2x4) -> int2x4 { return int2x4(v) } -asint_double3x1 :: proc "c" (v: double3x1) -> int3x1 { return int3x1(v) } -asint_double3x2 :: proc "c" (v: double3x2) -> int3x2 { return int3x2(v) } -asint_double3x4 :: proc "c" (v: double3x4) -> int3x4 { return int3x4(v) } -asint_double4x1 :: proc "c" (v: double4x1) -> int4x1 { return int4x1(v) } -asint_double4x2 :: proc "c" (v: double4x2) -> int4x2 { return int4x2(v) } -asint_double4x3 :: proc "c" (v: double4x3) -> int4x3 { return int4x3(v) } -asint_double2 :: proc "c" (v: double2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_double3 :: proc "c" (v: double3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_double4 :: proc "c" (v: double4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(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_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) } +@(require_results) asint_float4x4 :: proc "c" (v: float4x4) -> int4x4 { return int4x4(v) } +@(require_results) asint_float1x2 :: proc "c" (v: float1x2) -> int1x2 { return int1x2(v) } +@(require_results) asint_float1x3 :: proc "c" (v: float1x3) -> int1x3 { return int1x3(v) } +@(require_results) asint_float1x4 :: proc "c" (v: float1x4) -> int1x4 { return int1x4(v) } +@(require_results) asint_float2x1 :: proc "c" (v: float2x1) -> int2x1 { return int2x1(v) } +@(require_results) asint_float2x3 :: proc "c" (v: float2x3) -> int2x3 { return int2x3(v) } +@(require_results) asint_float2x4 :: proc "c" (v: float2x4) -> int2x4 { return int2x4(v) } +@(require_results) asint_float3x1 :: proc "c" (v: float3x1) -> int3x1 { return int3x1(v) } +@(require_results) asint_float3x2 :: proc "c" (v: float3x2) -> int3x2 { return int3x2(v) } +@(require_results) asint_float3x4 :: proc "c" (v: float3x4) -> int3x4 { return int3x4(v) } +@(require_results) asint_float4x1 :: proc "c" (v: float4x1) -> int4x1 { return int4x1(v) } +@(require_results) asint_float4x2 :: proc "c" (v: float4x2) -> int4x2 { return int4x2(v) } +@(require_results) asint_float4x3 :: proc "c" (v: float4x3) -> int4x3 { return int4x3(v) } +@(require_results) asint_float2 :: proc "c" (v: float2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_float3 :: proc "c" (v: float3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_float4 :: proc "c" (v: float4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_int2 :: proc "c" (v: int2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_int3 :: proc "c" (v: int3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_int4 :: proc "c" (v: int4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_uint2 :: proc "c" (v: uint2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_uint3 :: proc "c" (v: uint3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_uint4 :: proc "c" (v: uint4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_bool2 :: proc "c" (v: bool2) -> int2 { return int2{int(int(v.x)), int(int(v.y))} } +@(require_results) asint_bool3 :: proc "c" (v: bool3) -> int3 { return int3{int(int(v.x)), int(int(v.y)), int(int(v.z))} } +@(require_results) asint_bool4 :: proc "c" (v: bool4) -> int4 { return int4{int(int(v.x)), int(int(v.y)), int(int(v.z)), int(int(v.w))} } +@(require_results) asint_double1x1 :: proc "c" (v: double1x1) -> int1x1 { return int1x1(v) } +@(require_results) asint_double2x2 :: proc "c" (v: double2x2) -> int2x2 { return int2x2(v) } +@(require_results) asint_double3x3 :: proc "c" (v: double3x3) -> int3x3 { return int3x3(v) } +@(require_results) asint_double4x4 :: proc "c" (v: double4x4) -> int4x4 { return int4x4(v) } +@(require_results) asint_double1x2 :: proc "c" (v: double1x2) -> int1x2 { return int1x2(v) } +@(require_results) asint_double1x3 :: proc "c" (v: double1x3) -> int1x3 { return int1x3(v) } +@(require_results) asint_double1x4 :: proc "c" (v: double1x4) -> int1x4 { return int1x4(v) } +@(require_results) asint_double2x1 :: proc "c" (v: double2x1) -> int2x1 { return int2x1(v) } +@(require_results) asint_double2x3 :: proc "c" (v: double2x3) -> int2x3 { return int2x3(v) } +@(require_results) asint_double2x4 :: proc "c" (v: double2x4) -> int2x4 { return int2x4(v) } +@(require_results) asint_double3x1 :: proc "c" (v: double3x1) -> int3x1 { return int3x1(v) } +@(require_results) asint_double3x2 :: proc "c" (v: double3x2) -> int3x2 { return int3x2(v) } +@(require_results) asint_double3x4 :: proc "c" (v: double3x4) -> int3x4 { return int3x4(v) } +@(require_results) asint_double4x1 :: proc "c" (v: double4x1) -> int4x1 { return int4x1(v) } +@(require_results) asint_double4x2 :: proc "c" (v: double4x2) -> int4x2 { return int4x2(v) } +@(require_results) asint_double4x3 :: proc "c" (v: double4x3) -> int4x3 { return int4x3(v) } +@(require_results) asint_double2 :: proc "c" (v: double2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_double3 :: proc "c" (v: double3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_double4 :: proc "c" (v: double4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } asuint :: proc{ @@ -1828,25 +1836,25 @@ asuint :: proc{ asuint_double3, asuint_double4, } -asuint_float :: proc "c" (v: float) -> uint { return uint(v) } -asuint_double :: proc "c" (v: double) -> uint { return uint(v) } -asuint_int :: proc "c" (v: int) -> uint { return uint(v) } -asuint_uint :: proc "c" (v: uint) -> uint { return uint(v) } -asuint_float2 :: proc "c" (v: float2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_float3 :: proc "c" (v: float3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_float4 :: proc "c" (v: float4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_int2 :: proc "c" (v: int2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_int3 :: proc "c" (v: int3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_int4 :: proc "c" (v: int4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_uint2 :: proc "c" (v: uint2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_uint3 :: proc "c" (v: uint3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_uint4 :: proc "c" (v: uint4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_bool2 :: proc "c" (v: bool2) -> uint2 { return uint2{uint(uint(v.x)), uint(uint(v.y))} } -asuint_bool3 :: proc "c" (v: bool3) -> uint3 { return uint3{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z))} } -asuint_bool4 :: proc "c" (v: bool4) -> uint4 { return uint4{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z)), uint(uint(v.w))} } -asuint_double2 :: proc "c" (v: double2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_double3 :: proc "c" (v: double3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_double4 :: proc "c" (v: double4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(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_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)} } +@(require_results) asuint_int2 :: proc "c" (v: int2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_int3 :: proc "c" (v: int3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_int4 :: proc "c" (v: int4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_uint2 :: proc "c" (v: uint2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_uint3 :: proc "c" (v: uint3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_uint4 :: proc "c" (v: uint4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_bool2 :: proc "c" (v: bool2) -> uint2 { return uint2{uint(uint(v.x)), uint(uint(v.y))} } +@(require_results) asuint_bool3 :: proc "c" (v: bool3) -> uint3 { return uint3{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z))} } +@(require_results) asuint_bool4 :: proc "c" (v: bool4) -> uint4 { return uint4{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z)), uint(uint(v.w))} } +@(require_results) asuint_double2 :: proc "c" (v: double2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_double3 :: proc "c" (v: double3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_double4 :: proc "c" (v: double4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } // TODO(bill): All of the `mul` procedures diff --git a/core/math/linalg/hlsl/linalg_hlsl_math.odin b/core/math/linalg/hlsl/linalg_hlsl_math.odin index 91c542b59..5b8004342 100644 --- a/core/math/linalg/hlsl/linalg_hlsl_math.odin +++ b/core/math/linalg/hlsl/linalg_hlsl_math.odin @@ -2,34 +2,35 @@ package math_linalg_hlsl import "core:math" -cos_float :: proc "c" (x: float) -> float { return math.cos(x) } -sin_float :: proc "c" (x: float) -> float { return math.sin(x) } -tan_float :: proc "c" (x: float) -> float { return math.tan(x) } -acos_float :: proc "c" (x: float) -> float { return math.acos(x) } -asin_float :: proc "c" (x: float) -> float { return math.asin(x) } -atan_float :: proc "c" (x: float) -> float { return math.atan(x) } -atan2_float :: proc "c" (y, x: float) -> float { return math.atan2(y, x) } -cosh_float :: proc "c" (x: float) -> float { return math.cosh(x) } -sinh_float :: proc "c" (x: float) -> float { return math.sinh(x) } -tanh_float :: proc "c" (x: float) -> float { return math.tanh(x) } -acosh_float :: proc "c" (x: float) -> float { return math.acosh(x) } -asinh_float :: proc "c" (x: float) -> float { return math.asinh(x) } -atanh_float :: proc "c" (x: float) -> float { return math.atanh(x) } -sqrt_float :: proc "c" (x: float) -> float { return math.sqrt(x) } -rsqrt_float :: proc "c" (x: float) -> float { return 1.0/math.sqrt(x) } -rcp_float :: proc "c" (x: float) -> float { return 1.0/x } -pow_float :: proc "c" (x, y: float) -> float { return math.pow(x, y) } -exp_float :: proc "c" (x: float) -> float { return math.exp(x) } -log_float :: proc "c" (x: float) -> float { return math.ln(x) } -log2_float :: proc "c" (x: float) -> float { return math.log(x, 2) } -log10_float :: proc "c" (x: float) -> float { return math.log(x, 10) } -exp2_float :: proc "c" (x: float) -> float { return math.pow(float(2), x) } -sign_float :: proc "c" (x: float) -> float { return math.sign(x) } -floor_float :: proc "c" (x: float) -> float { return math.floor(x) } -round_float :: proc "c" (x: float) -> float { return math.round(x) } -ceil_float :: proc "c" (x: float) -> float { return math.ceil(x) } -isnan_float :: proc "c" (x: float) -> bool { return math.classify(x) == .NaN} -fmod_float :: proc "c" (x, y: float) -> float { return math.mod(x, y) } +@(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) } +@(require_results) acos_float :: proc "c" (x: float) -> float { return math.acos(x) } +@(require_results) asin_float :: proc "c" (x: float) -> float { return math.asin(x) } +@(require_results) atan_float :: proc "c" (x: float) -> float { return math.atan(x) } +@(require_results) atan2_float :: proc "c" (y, x: float) -> float { return math.atan2(y, x) } +@(require_results) cosh_float :: proc "c" (x: float) -> float { return math.cosh(x) } +@(require_results) sinh_float :: proc "c" (x: float) -> float { return math.sinh(x) } +@(require_results) tanh_float :: proc "c" (x: float) -> float { return math.tanh(x) } +@(require_results) acosh_float :: proc "c" (x: float) -> float { return math.acosh(x) } +@(require_results) asinh_float :: proc "c" (x: float) -> float { return math.asinh(x) } +@(require_results) atanh_float :: proc "c" (x: float) -> float { return math.atanh(x) } +@(require_results) sqrt_float :: proc "c" (x: float) -> float { return math.sqrt(x) } +@(require_results) rsqrt_float :: proc "c" (x: float) -> float { return 1.0/math.sqrt(x) } +@(require_results) rcp_float :: proc "c" (x: float) -> float { return 1.0/x } +@(require_results) pow_float :: proc "c" (x, y: float) -> float { return math.pow(x, y) } +@(require_results) exp_float :: proc "c" (x: float) -> float { return math.exp(x) } +@(require_results) log_float :: proc "c" (x: float) -> float { return math.ln(x) } +@(require_results) log2_float :: proc "c" (x: float) -> float { return math.log(x, 2) } +@(require_results) log10_float :: proc "c" (x: float) -> float { return math.log(x, 10) } +@(require_results) exp2_float :: proc "c" (x: float) -> float { return math.pow(float(2), x) } +@(require_results) sign_float :: proc "c" (x: float) -> float { return math.sign(x) } +@(require_results) floor_float :: proc "c" (x: float) -> float { return math.floor(x) } +@(require_results) round_float :: proc "c" (x: float) -> float { return math.round(x) } +@(require_results) ceil_float :: proc "c" (x: float) -> float { return math.ceil(x) } +@(require_results) isnan_float :: proc "c" (x: float) -> bool { return math.classify(x) == .NaN} +@(require_results) fmod_float :: proc "c" (x, y: float) -> float { return math.mod(x, y) } +@(require_results) frac_float :: proc "c" (x: float) -> float { if x >= 0 { return x - math.trunc(x) @@ -38,34 +39,35 @@ frac_float :: proc "c" (x: float) -> float { } -cos_double :: proc "c" (x: double) -> double { return math.cos(x) } -sin_double :: proc "c" (x: double) -> double { return math.sin(x) } -tan_double :: proc "c" (x: double) -> double { return math.tan(x) } -acos_double :: proc "c" (x: double) -> double { return math.acos(x) } -asin_double :: proc "c" (x: double) -> double { return math.asin(x) } -atan_double :: proc "c" (x: double) -> double { return math.atan(x) } -atan2_double :: proc "c" (y, x: double) -> double { return math.atan2(y, x) } -cosh_double :: proc "c" (x: double) -> double { return math.cosh(x) } -sinh_double :: proc "c" (x: double) -> double { return math.sinh(x) } -tanh_double :: proc "c" (x: double) -> double { return math.tanh(x) } -acosh_double :: proc "c" (x: double) -> double { return math.acosh(x) } -asinh_double :: proc "c" (x: double) -> double { return math.asinh(x) } -atanh_double :: proc "c" (x: double) -> double { return math.atanh(x) } -sqrt_double :: proc "c" (x: double) -> double { return math.sqrt(x) } -rsqrt_double :: proc "c" (x: double) -> double { return 1.0/math.sqrt(x) } -rcp_double :: proc "c" (x: double) -> double { return 1.0/x } -pow_double :: proc "c" (x, y: double) -> double { return math.pow(x, y) } -exp_double :: proc "c" (x: double) -> double { return math.exp(x) } -log_double :: proc "c" (x: double) -> double { return math.ln(x) } -log2_double :: proc "c" (x: double) -> double { return math.log(x, 2) } -log10_double :: proc "c" (x: double) -> double { return math.log(x, 10) } -exp2_double :: proc "c" (x: double) -> double { return math.pow(double(2), x) } -sign_double :: proc "c" (x: double) -> double { return math.sign(x) } -floor_double :: proc "c" (x: double) -> double { return math.floor(x) } -round_double :: proc "c" (x: double) -> double { return math.round(x) } -ceil_double :: proc "c" (x: double) -> double { return math.ceil(x) } -isnan_double :: proc "c" (x: double) -> bool { return math.classify(x) == .NaN} -fmod_double :: proc "c" (x, y: double) -> double { return math.mod(x, y) } +@(require_results) cos_double :: proc "c" (x: double) -> double { return math.cos(x) } +@(require_results) sin_double :: proc "c" (x: double) -> double { return math.sin(x) } +@(require_results) tan_double :: proc "c" (x: double) -> double { return math.tan(x) } +@(require_results) acos_double :: proc "c" (x: double) -> double { return math.acos(x) } +@(require_results) asin_double :: proc "c" (x: double) -> double { return math.asin(x) } +@(require_results) atan_double :: proc "c" (x: double) -> double { return math.atan(x) } +@(require_results) atan2_double :: proc "c" (y, x: double) -> double { return math.atan2(y, x) } +@(require_results) cosh_double :: proc "c" (x: double) -> double { return math.cosh(x) } +@(require_results) sinh_double :: proc "c" (x: double) -> double { return math.sinh(x) } +@(require_results) tanh_double :: proc "c" (x: double) -> double { return math.tanh(x) } +@(require_results) acosh_double :: proc "c" (x: double) -> double { return math.acosh(x) } +@(require_results) asinh_double :: proc "c" (x: double) -> double { return math.asinh(x) } +@(require_results) atanh_double :: proc "c" (x: double) -> double { return math.atanh(x) } +@(require_results) sqrt_double :: proc "c" (x: double) -> double { return math.sqrt(x) } +@(require_results) rsqrt_double :: proc "c" (x: double) -> double { return 1.0/math.sqrt(x) } +@(require_results) rcp_double :: proc "c" (x: double) -> double { return 1.0/x } +@(require_results) pow_double :: proc "c" (x, y: double) -> double { return math.pow(x, y) } +@(require_results) exp_double :: proc "c" (x: double) -> double { return math.exp(x) } +@(require_results) log_double :: proc "c" (x: double) -> double { return math.ln(x) } +@(require_results) log2_double :: proc "c" (x: double) -> double { return math.log(x, 2) } +@(require_results) log10_double :: proc "c" (x: double) -> double { return math.log(x, 10) } +@(require_results) exp2_double :: proc "c" (x: double) -> double { return math.pow(double(2), x) } +@(require_results) sign_double :: proc "c" (x: double) -> double { return math.sign(x) } +@(require_results) floor_double :: proc "c" (x: double) -> double { return math.floor(x) } +@(require_results) round_double :: proc "c" (x: double) -> double { return math.round(x) } +@(require_results) ceil_double :: proc "c" (x: double) -> double { return math.ceil(x) } +@(require_results) isnan_double :: proc "c" (x: double) -> bool { return math.classify(x) == .NaN} +@(require_results) fmod_double :: proc "c" (x, y: double) -> double { return math.mod(x, y) } +@(require_results) frac_double :: proc "c" (x: double) -> double { if x >= 0 { return x - math.trunc(x)