warp-lang 1.9.0__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/native/exports.h

@@ -369,6 +369,18 @@ WP_API void wp_builtin_exp_float64(float64 x, float64* ret) { *ret = wp::exp(x);
 WP_API void wp_builtin_pow_float16_float16(float16 x, float16 y, float16* ret) { *ret = wp::pow(x, y); }
 WP_API void wp_builtin_pow_float32_float32(float32 x, float32 y, float32* ret) { *ret = wp::pow(x, y); }
 WP_API void wp_builtin_pow_float64_float64(float64 x, float64 y, float64* ret) { *ret = wp::pow(x, y); }
+WP_API void wp_builtin_erf_float16(float16 x, float16* ret) { *ret = wp::erf(x); }
+WP_API void wp_builtin_erf_float32(float32 x, float32* ret) { *ret = wp::erf(x); }
+WP_API void wp_builtin_erf_float64(float64 x, float64* ret) { *ret = wp::erf(x); }
+WP_API void wp_builtin_erfc_float16(float16 x, float16* ret) { *ret = wp::erfc(x); }
+WP_API void wp_builtin_erfc_float32(float32 x, float32* ret) { *ret = wp::erfc(x); }
+WP_API void wp_builtin_erfc_float64(float64 x, float64* ret) { *ret = wp::erfc(x); }
+WP_API void wp_builtin_erfinv_float16(float16 x, float16* ret) { *ret = wp::erfinv(x); }
+WP_API void wp_builtin_erfinv_float32(float32 x, float32* ret) { *ret = wp::erfinv(x); }
+WP_API void wp_builtin_erfinv_float64(float64 x, float64* ret) { *ret = wp::erfinv(x); }
+WP_API void wp_builtin_erfcinv_float16(float16 x, float16* ret) { *ret = wp::erfcinv(x); }
+WP_API void wp_builtin_erfcinv_float32(float32 x, float32* ret) { *ret = wp::erfcinv(x); }
+WP_API void wp_builtin_erfcinv_float64(float64 x, float64* ret) { *ret = wp::erfcinv(x); }
 WP_API void wp_builtin_round_float16(float16 x, float16* ret) { *ret = wp::round(x); }
 WP_API void wp_builtin_round_float32(float32 x, float32* ret) { *ret = wp::round(x); }
 WP_API void wp_builtin_round_float64(float64 x, float64* ret) { *ret = wp::round(x); }
@@ -1356,6 +1368,30 @@ WP_API void wp_builtin_bit_and_uint16_uint16(uint16 a, uint16 b, uint16* ret) {
 WP_API void wp_builtin_bit_and_uint32_uint32(uint32 a, uint32 b, uint32* ret) { *ret = wp::bit_and(a, b); }
 WP_API void wp_builtin_bit_and_uint64_uint64(uint64 a, uint64 b, uint64* ret) { *ret = wp::bit_and(a, b); }
 WP_API void wp_builtin_bit_and_uint8_uint8(uint8 a, uint8 b, uint8* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2s_vec2s(vec2s& a, vec2s& b, vec2s* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3s_vec3s(vec3s& a, vec3s& b, vec3s* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4s_vec4s(vec4s& a, vec4s& b, vec4s* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2i_vec2i(vec2i& a, vec2i& b, vec2i* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3i_vec3i(vec3i& a, vec3i& b, vec3i* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4i_vec4i(vec4i& a, vec4i& b, vec4i* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2l_vec2l(vec2l& a, vec2l& b, vec2l* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3l_vec3l(vec3l& a, vec3l& b, vec3l* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4l_vec4l(vec4l& a, vec4l& b, vec4l* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2b_vec2b(vec2b& a, vec2b& b, vec2b* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3b_vec3b(vec3b& a, vec3b& b, vec3b* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4b_vec4b(vec4b& a, vec4b& b, vec4b* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2us_vec2us(vec2us& a, vec2us& b, vec2us* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3us_vec3us(vec3us& a, vec3us& b, vec3us* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4us_vec4us(vec4us& a, vec4us& b, vec4us* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2ui_vec2ui(vec2ui& a, vec2ui& b, vec2ui* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3ui_vec3ui(vec3ui& a, vec3ui& b, vec3ui* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4ui_vec4ui(vec4ui& a, vec4ui& b, vec4ui* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2ul_vec2ul(vec2ul& a, vec2ul& b, vec2ul* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3ul_vec3ul(vec3ul& a, vec3ul& b, vec3ul* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4ul_vec4ul(vec4ul& a, vec4ul& b, vec4ul* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec2ub_vec2ub(vec2ub& a, vec2ub& b, vec2ub* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec3ub_vec3ub(vec3ub& a, vec3ub& b, vec3ub* ret) { *ret = wp::bit_and(a, b); }
+WP_API void wp_builtin_bit_and_vec4ub_vec4ub(vec4ub& a, vec4ub& b, vec4ub* ret) { *ret = wp::bit_and(a, b); }
 WP_API void wp_builtin_bit_or_int16_int16(int16 a, int16 b, int16* ret) { *ret = wp::bit_or(a, b); }
 WP_API void wp_builtin_bit_or_int32_int32(int32 a, int32 b, int32* ret) { *ret = wp::bit_or(a, b); }
 WP_API void wp_builtin_bit_or_int64_int64(int64 a, int64 b, int64* ret) { *ret = wp::bit_or(a, b); }
@@ -1364,6 +1400,30 @@ WP_API void wp_builtin_bit_or_uint16_uint16(uint16 a, uint16 b, uint16* ret) { *
 WP_API void wp_builtin_bit_or_uint32_uint32(uint32 a, uint32 b, uint32* ret) { *ret = wp::bit_or(a, b); }
 WP_API void wp_builtin_bit_or_uint64_uint64(uint64 a, uint64 b, uint64* ret) { *ret = wp::bit_or(a, b); }
 WP_API void wp_builtin_bit_or_uint8_uint8(uint8 a, uint8 b, uint8* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2s_vec2s(vec2s& a, vec2s& b, vec2s* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3s_vec3s(vec3s& a, vec3s& b, vec3s* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4s_vec4s(vec4s& a, vec4s& b, vec4s* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2i_vec2i(vec2i& a, vec2i& b, vec2i* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3i_vec3i(vec3i& a, vec3i& b, vec3i* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4i_vec4i(vec4i& a, vec4i& b, vec4i* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2l_vec2l(vec2l& a, vec2l& b, vec2l* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3l_vec3l(vec3l& a, vec3l& b, vec3l* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4l_vec4l(vec4l& a, vec4l& b, vec4l* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2b_vec2b(vec2b& a, vec2b& b, vec2b* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3b_vec3b(vec3b& a, vec3b& b, vec3b* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4b_vec4b(vec4b& a, vec4b& b, vec4b* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2us_vec2us(vec2us& a, vec2us& b, vec2us* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3us_vec3us(vec3us& a, vec3us& b, vec3us* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4us_vec4us(vec4us& a, vec4us& b, vec4us* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2ui_vec2ui(vec2ui& a, vec2ui& b, vec2ui* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3ui_vec3ui(vec3ui& a, vec3ui& b, vec3ui* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4ui_vec4ui(vec4ui& a, vec4ui& b, vec4ui* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2ul_vec2ul(vec2ul& a, vec2ul& b, vec2ul* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3ul_vec3ul(vec3ul& a, vec3ul& b, vec3ul* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4ul_vec4ul(vec4ul& a, vec4ul& b, vec4ul* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec2ub_vec2ub(vec2ub& a, vec2ub& b, vec2ub* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec3ub_vec3ub(vec3ub& a, vec3ub& b, vec3ub* ret) { *ret = wp::bit_or(a, b); }
+WP_API void wp_builtin_bit_or_vec4ub_vec4ub(vec4ub& a, vec4ub& b, vec4ub* ret) { *ret = wp::bit_or(a, b); }
 WP_API void wp_builtin_bit_xor_int16_int16(int16 a, int16 b, int16* ret) { *ret = wp::bit_xor(a, b); }
 WP_API void wp_builtin_bit_xor_int32_int32(int32 a, int32 b, int32* ret) { *ret = wp::bit_xor(a, b); }
 WP_API void wp_builtin_bit_xor_int64_int64(int64 a, int64 b, int64* ret) { *ret = wp::bit_xor(a, b); }
@@ -1372,6 +1432,30 @@ WP_API void wp_builtin_bit_xor_uint16_uint16(uint16 a, uint16 b, uint16* ret) {
 WP_API void wp_builtin_bit_xor_uint32_uint32(uint32 a, uint32 b, uint32* ret) { *ret = wp::bit_xor(a, b); }
 WP_API void wp_builtin_bit_xor_uint64_uint64(uint64 a, uint64 b, uint64* ret) { *ret = wp::bit_xor(a, b); }
 WP_API void wp_builtin_bit_xor_uint8_uint8(uint8 a, uint8 b, uint8* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2s_vec2s(vec2s& a, vec2s& b, vec2s* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3s_vec3s(vec3s& a, vec3s& b, vec3s* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4s_vec4s(vec4s& a, vec4s& b, vec4s* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2i_vec2i(vec2i& a, vec2i& b, vec2i* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3i_vec3i(vec3i& a, vec3i& b, vec3i* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4i_vec4i(vec4i& a, vec4i& b, vec4i* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2l_vec2l(vec2l& a, vec2l& b, vec2l* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3l_vec3l(vec3l& a, vec3l& b, vec3l* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4l_vec4l(vec4l& a, vec4l& b, vec4l* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2b_vec2b(vec2b& a, vec2b& b, vec2b* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3b_vec3b(vec3b& a, vec3b& b, vec3b* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4b_vec4b(vec4b& a, vec4b& b, vec4b* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2us_vec2us(vec2us& a, vec2us& b, vec2us* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3us_vec3us(vec3us& a, vec3us& b, vec3us* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4us_vec4us(vec4us& a, vec4us& b, vec4us* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2ui_vec2ui(vec2ui& a, vec2ui& b, vec2ui* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3ui_vec3ui(vec3ui& a, vec3ui& b, vec3ui* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4ui_vec4ui(vec4ui& a, vec4ui& b, vec4ui* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2ul_vec2ul(vec2ul& a, vec2ul& b, vec2ul* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3ul_vec3ul(vec3ul& a, vec3ul& b, vec3ul* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4ul_vec4ul(vec4ul& a, vec4ul& b, vec4ul* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec2ub_vec2ub(vec2ub& a, vec2ub& b, vec2ub* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec3ub_vec3ub(vec3ub& a, vec3ub& b, vec3ub* ret) { *ret = wp::bit_xor(a, b); }
+WP_API void wp_builtin_bit_xor_vec4ub_vec4ub(vec4ub& a, vec4ub& b, vec4ub* ret) { *ret = wp::bit_xor(a, b); }
 WP_API void wp_builtin_lshift_int16_int16(int16 a, int16 b, int16* ret) { *ret = wp::lshift(a, b); }
 WP_API void wp_builtin_lshift_int32_int32(int32 a, int32 b, int32* ret) { *ret = wp::lshift(a, b); }
 WP_API void wp_builtin_lshift_int64_int64(int64 a, int64 b, int64* ret) { *ret = wp::lshift(a, b); }
@@ -1380,6 +1464,30 @@ WP_API void wp_builtin_lshift_uint16_uint16(uint16 a, uint16 b, uint16* ret) { *
 WP_API void wp_builtin_lshift_uint32_uint32(uint32 a, uint32 b, uint32* ret) { *ret = wp::lshift(a, b); }
 WP_API void wp_builtin_lshift_uint64_uint64(uint64 a, uint64 b, uint64* ret) { *ret = wp::lshift(a, b); }
 WP_API void wp_builtin_lshift_uint8_uint8(uint8 a, uint8 b, uint8* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2s_vec2s(vec2s& a, vec2s& b, vec2s* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3s_vec3s(vec3s& a, vec3s& b, vec3s* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4s_vec4s(vec4s& a, vec4s& b, vec4s* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2i_vec2i(vec2i& a, vec2i& b, vec2i* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3i_vec3i(vec3i& a, vec3i& b, vec3i* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4i_vec4i(vec4i& a, vec4i& b, vec4i* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2l_vec2l(vec2l& a, vec2l& b, vec2l* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3l_vec3l(vec3l& a, vec3l& b, vec3l* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4l_vec4l(vec4l& a, vec4l& b, vec4l* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2b_vec2b(vec2b& a, vec2b& b, vec2b* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3b_vec3b(vec3b& a, vec3b& b, vec3b* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4b_vec4b(vec4b& a, vec4b& b, vec4b* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2us_vec2us(vec2us& a, vec2us& b, vec2us* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3us_vec3us(vec3us& a, vec3us& b, vec3us* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4us_vec4us(vec4us& a, vec4us& b, vec4us* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2ui_vec2ui(vec2ui& a, vec2ui& b, vec2ui* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3ui_vec3ui(vec3ui& a, vec3ui& b, vec3ui* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4ui_vec4ui(vec4ui& a, vec4ui& b, vec4ui* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2ul_vec2ul(vec2ul& a, vec2ul& b, vec2ul* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3ul_vec3ul(vec3ul& a, vec3ul& b, vec3ul* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4ul_vec4ul(vec4ul& a, vec4ul& b, vec4ul* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec2ub_vec2ub(vec2ub& a, vec2ub& b, vec2ub* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec3ub_vec3ub(vec3ub& a, vec3ub& b, vec3ub* ret) { *ret = wp::lshift(a, b); }
+WP_API void wp_builtin_lshift_vec4ub_vec4ub(vec4ub& a, vec4ub& b, vec4ub* ret) { *ret = wp::lshift(a, b); }
 WP_API void wp_builtin_rshift_int16_int16(int16 a, int16 b, int16* ret) { *ret = wp::rshift(a, b); }
 WP_API void wp_builtin_rshift_int32_int32(int32 a, int32 b, int32* ret) { *ret = wp::rshift(a, b); }
 WP_API void wp_builtin_rshift_int64_int64(int64 a, int64 b, int64* ret) { *ret = wp::rshift(a, b); }
@@ -1388,6 +1496,30 @@ WP_API void wp_builtin_rshift_uint16_uint16(uint16 a, uint16 b, uint16* ret) { *
 WP_API void wp_builtin_rshift_uint32_uint32(uint32 a, uint32 b, uint32* ret) { *ret = wp::rshift(a, b); }
 WP_API void wp_builtin_rshift_uint64_uint64(uint64 a, uint64 b, uint64* ret) { *ret = wp::rshift(a, b); }
 WP_API void wp_builtin_rshift_uint8_uint8(uint8 a, uint8 b, uint8* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2s_vec2s(vec2s& a, vec2s& b, vec2s* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3s_vec3s(vec3s& a, vec3s& b, vec3s* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4s_vec4s(vec4s& a, vec4s& b, vec4s* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2i_vec2i(vec2i& a, vec2i& b, vec2i* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3i_vec3i(vec3i& a, vec3i& b, vec3i* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4i_vec4i(vec4i& a, vec4i& b, vec4i* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2l_vec2l(vec2l& a, vec2l& b, vec2l* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3l_vec3l(vec3l& a, vec3l& b, vec3l* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4l_vec4l(vec4l& a, vec4l& b, vec4l* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2b_vec2b(vec2b& a, vec2b& b, vec2b* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3b_vec3b(vec3b& a, vec3b& b, vec3b* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4b_vec4b(vec4b& a, vec4b& b, vec4b* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2us_vec2us(vec2us& a, vec2us& b, vec2us* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3us_vec3us(vec3us& a, vec3us& b, vec3us* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4us_vec4us(vec4us& a, vec4us& b, vec4us* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2ui_vec2ui(vec2ui& a, vec2ui& b, vec2ui* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3ui_vec3ui(vec3ui& a, vec3ui& b, vec3ui* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4ui_vec4ui(vec4ui& a, vec4ui& b, vec4ui* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2ul_vec2ul(vec2ul& a, vec2ul& b, vec2ul* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3ul_vec3ul(vec3ul& a, vec3ul& b, vec3ul* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4ul_vec4ul(vec4ul& a, vec4ul& b, vec4ul* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec2ub_vec2ub(vec2ub& a, vec2ub& b, vec2ub* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec3ub_vec3ub(vec3ub& a, vec3ub& b, vec3ub* ret) { *ret = wp::rshift(a, b); }
+WP_API void wp_builtin_rshift_vec4ub_vec4ub(vec4ub& a, vec4ub& b, vec4ub* ret) { *ret = wp::rshift(a, b); }
 WP_API void wp_builtin_invert_int16(int16 a, int16* ret) { *ret = wp::invert(a); }
 WP_API void wp_builtin_invert_int32(int32 a, int32* ret) { *ret = wp::invert(a); }
 WP_API void wp_builtin_invert_int64(int64 a, int64* ret) { *ret = wp::invert(a); }
@@ -1396,6 +1528,30 @@ WP_API void wp_builtin_invert_uint16(uint16 a, uint16* ret) { *ret = wp::invert(
 WP_API void wp_builtin_invert_uint32(uint32 a, uint32* ret) { *ret = wp::invert(a); }
 WP_API void wp_builtin_invert_uint64(uint64 a, uint64* ret) { *ret = wp::invert(a); }
 WP_API void wp_builtin_invert_uint8(uint8 a, uint8* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2s(vec2s& a, vec2s* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3s(vec3s& a, vec3s* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4s(vec4s& a, vec4s* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2i(vec2i& a, vec2i* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3i(vec3i& a, vec3i* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4i(vec4i& a, vec4i* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2l(vec2l& a, vec2l* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3l(vec3l& a, vec3l* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4l(vec4l& a, vec4l* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2b(vec2b& a, vec2b* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3b(vec3b& a, vec3b* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4b(vec4b& a, vec4b* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2us(vec2us& a, vec2us* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3us(vec3us& a, vec3us* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4us(vec4us& a, vec4us* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2ui(vec2ui& a, vec2ui* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3ui(vec3ui& a, vec3ui* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4ui(vec4ui& a, vec4ui* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2ul(vec2ul& a, vec2ul* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3ul(vec3ul& a, vec3ul* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4ul(vec4ul& a, vec4ul* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec2ub(vec2ub& a, vec2ub* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec3ub(vec3ub& a, vec3ub* ret) { *ret = wp::invert(a); }
+WP_API void wp_builtin_invert_vec4ub(vec4ub& a, vec4ub* ret) { *ret = wp::invert(a); }
 WP_API void wp_builtin_mul_float16_float16(float16 a, float16 b, float16* ret) { *ret = wp::mul(a, b); }
 WP_API void wp_builtin_mul_float32_float32(float32 a, float32 b, float32* ret) { *ret = wp::mul(a, b); }
 WP_API void wp_builtin_mul_float64_float64(float64 a, float64 b, float64* ret) { *ret = wp::mul(a, b); }

warp/native/hashgrid.cu

@@ -20,6 +20,8 @@
 #include "hashgrid.h"
 #include "sort.h"
 
+extern CUcontext get_current_context();
+
 namespace wp
 {
 

warp/native/intersect.h

@@ -613,7 +613,15 @@ CUDA_CALLABLE inline int intersect_tri_tri(
     vec3& v0, vec3& v1, vec3& v2,
     vec3& u0, vec3& u1, vec3& u2)
 {
-	return NoDivTriTriIsect(&v0[0], &v1[0], &v2[0], &u0[0], &u1[0], &u2[0]);
+	return NoDivTriTriIsect<float>(&v0[0], &v1[0], &v2[0], &u0[0], &u1[0], &u2[0]);
+}
+
+
+CUDA_CALLABLE inline int intersect_tri_tri(
+    vec3d& v0, vec3d& v1, vec3d& v2,
+    vec3d& u0, vec3d& u1, vec3d& u2)
+{
+    return NoDivTriTriIsect<double>(&v0[0], &v1[0], &v2[0], &u0[0], &u1[0], &u2[0]);
 }
 
 CUDA_CALLABLE inline void adj_intersect_tri_tri(const vec3& var_v0,
@@ -631,6 +639,21 @@ CUDA_CALLABLE inline void adj_intersect_tri_tri(const vec3& var_v0,
 												int adj_ret) {}
 
 
+CUDA_CALLABLE inline void adj_intersect_tri_tri(const vec3d& var_v0,
+    const vec3d& var_v1,
+    const vec3d& var_v2,
+    const vec3d& var_u0,
+    const vec3d& var_u1,
+    const vec3d& var_u2,
+    vec3d& adj_v0,
+    vec3d& adj_v1,
+    vec3d& adj_v2,
+    vec3d& adj_u0,
+    vec3d& adj_u1,
+    vec3d& adj_u2,
+    int adj_ret) {}
+
+
 CUDA_CALLABLE inline void adj_closest_point_to_triangle(
 	const vec3& var_a, const vec3& var_b, const vec3& var_c, const vec3& var_p,
 	vec3& adj_a, vec3& adj_b, vec3& adj_c, vec3& adj_p, vec2& adj_ret)

warp/native/intersect_tri.h

@@ -23,8 +23,8 @@
  * Updated June 1999: removed the divisions -- a little faster now!
  * Updated October 1999: added {} to CROSS and SUB macros
  *
- * int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
- *                      float U0[3],float U1[3],float U2[3])
+ * int NoDivTriTriIsect(T V0[3],T V1[3],T V2[3],
+ *                      T U0[3],T U1[3],T U2[3])
  *
  * parameters: vertices of triangle 1: V0,V1,V2
  *             vertices of triangle 2: U0,U1,U2
@@ -74,7 +74,7 @@
 #define SORT(a,b)       \
              if(a>b)    \
              {          \
-               float c; \
+               T c; \
                c=a;     \
                a=b;     \
                b=c;     \
@@ -106,7 +106,7 @@
 
 #define EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2) \
 {                                              \
-  float Ax,Ay,Bx,By,Cx,Cy,e,d,f;               \
+  T Ax,Ay,Bx,By,Cx,Cy,e,d,f;               \
   Ax=V1[i0]-V0[i0];                            \
   Ay=V1[i1]-V0[i1];                            \
   /* test edge U0,U1 against V0,V1 */          \
@@ -119,7 +119,7 @@
 
 #define POINT_IN_TRI(V0,U0,U1,U2)           \
 {                                           \
-  float a,b,c,d0,d1,d2;                     \
+  T a,b,c,d0,d1,d2;                     \
   /* is T1 completely inside T2? */          \
   /* check if V0 is inside tri(U0,U1,U2) */ \
   a=U1[i1]-U0[i1];                          \
@@ -142,16 +142,25 @@
   }                                         \
 }
 
-CUDA_CALLABLE inline int coplanar_tri_tri(float N[3],float V0[3],float V1[3],float V2[3],
-                     float U0[3],float U1[3],float U2[3])
+
+// Type-generic abs that works on device & host without relying on std overloads
+CUDA_CALLABLE inline float abs_t(float x) { return fabsf(x); }
+CUDA_CALLABLE inline double abs_t(double x) { return fabs(x); }
+
+template <typename T>
+CUDA_CALLABLE inline T abs_t(T x) { return x < T(0) ? -x : x; }
+
+template<typename T>
+CUDA_CALLABLE inline int coplanar_tri_tri(T N[3],T V0[3],T V1[3],T V2[3],
+                     T U0[3],T U1[3],T U2[3])
 {
-   float A[3];
+   T A[3];
    short i0,i1;
    /* first project onto an axis-aligned plane, that maximizes the area */
    /* of the triangles, compute indices: i0,i1. */
-   A[0]=fabsf(N[0]);
-   A[1]=fabsf(N[1]);
-   A[2]=fabsf(N[2]);
+   A[0]=abs_t(N[0]);
+   A[1]=abs_t(N[1]);
+   A[2]=abs_t(N[2]);
    if(A[0]>A[1])
    {
       if(A[0]>A[2])
@@ -227,20 +236,20 @@ CUDA_CALLABLE inline int coplanar_tri_tri(float N[3],float V0[3],float V1[3],flo
 }
 
 
-
-CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
-                     float U0[3],float U1[3],float U2[3])
+template<typename T>
+CUDA_CALLABLE inline int NoDivTriTriIsect(T V0[3], T V1[3], T V2[3],
+    T U0[3], T U1[3], T U2[3])
 {
-  float E1[3],E2[3];
-  float N1[3],N2[3],d1,d2;
-  float du0,du1,du2,dv0,dv1,dv2;
-  float D[3];
-  float isect1[2], isect2[2];
-  float du0du1,du0du2,dv0dv1,dv0dv2;
+  T E1[3],E2[3];
+  T N1[3],N2[3],d1,d2;
+  T du0,du1,du2,dv0,dv1,dv2;
+  T D[3];
+  T isect1[2], isect2[2];
+  T du0du1,du0du2,dv0dv1,dv0dv2;
   short index;
-  float vp0,vp1,vp2;
-  float up0,up1,up2;
-  float bb,cc,max;
+  T vp0,vp1,vp2;
+  T up0,up1,up2;
+  T bb,cc,max;
 
   /* compute plane equation of triangle(V0,V1,V2) */
   SUB(E1,V1,V0);
@@ -256,9 +265,9 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
 
   /* coplanarity robustness check */
 #if USE_EPSILON_TEST==TRUE
-  if(fabsf(du0)<EPSILON) du0=0.0;
-  if(fabsf(du1)<EPSILON) du1=0.0;
-  if(fabsf(du2)<EPSILON) du2=0.0;
+  if(abs_t(du0)<EPSILON) du0=0.0;
+  if(abs_t(du1)<EPSILON) du1=0.0;
+  if(abs_t(du2)<EPSILON) du2=0.0;
 #endif
   du0du1=du0*du1;
   du0du2=du0*du2;
@@ -279,9 +288,9 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
   dv2=DOT(N2,V2)+d2;
 
 #if USE_EPSILON_TEST==TRUE
-  if(fabsf(dv0)<EPSILON) dv0=0.0;
-  if(fabsf(dv1)<EPSILON) dv1=0.0;
-  if(fabsf(dv2)<EPSILON) dv2=0.0;
+  if(abs_t(dv0)<EPSILON) dv0=0.0;
+  if(abs_t(dv1)<EPSILON) dv1=0.0;
+  if(abs_t(dv2)<EPSILON) dv2=0.0;
 #endif
 
   dv0dv1=dv0*dv1;
@@ -294,10 +303,10 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
   CROSS(D,N1,N2);
 
   /* compute and index to the largest component of D */
-  max=fabsf(D[0]);
+  max=abs_t(D[0]);
   index=0;
-  bb=fabsf(D[1]);
-  cc=fabsf(D[2]);
+  bb=abs_t(D[1]);
+  cc=abs_t(D[2]);
   if(bb>max) max=bb,index=1;
   if(cc>max) max=cc,index=2;
 
@@ -311,14 +320,14 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
   up2=U2[index];
 
   /* compute interval for triangle 1 */
-  float a,b,c,x0,x1;
+  T a,b,c,x0,x1;
   NEWCOMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,a,b,c,x0,x1);
 
   /* compute interval for triangle 2 */
-  float d,e,f,y0,y1;
+  T d,e,f,y0,y1;
   NEWCOMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,d,e,f,y0,y1);
 
-  float xx,yy,xxyy,tmp;
+  T xx,yy,xxyy,tmp;
   xx=x0*x1;
   yy=y0*y1;
   xxyy=xx*yy;