warp-lang 1.7.2rc1__py3-none-macosx_10_13_universal2.whl → 1.8.1__py3-none-macosx_10_13_universal2.whl

warp/native/builtin.h

@@ -52,6 +52,11 @@
 __device__ void __debugbreak() {}
 #endif
 
+#if defined(__clang__) && defined(__CUDA__) && defined(__CUDA_ARCH__)
+// clang compiling CUDA code, device mode (NOTE: Used when building core library with Clang)
+#include <cuda_fp16.h>
+#endif
+
 namespace wp
 {
 
@@ -177,14 +182,14 @@ CUDA_CALLABLE inline float half_to_float(half x)
 #elif defined(__clang__)
 
 // _Float16 is Clang's native half-precision floating-point type
-inline half float_to_half(float x)
+CUDA_CALLABLE inline half float_to_half(float x)
 {
 
     _Float16 f16 = static_cast<_Float16>(x);
     return *reinterpret_cast<half*>(&f16);
 }
 
-inline float half_to_float(half h)
+CUDA_CALLABLE inline float half_to_float(half h)
 {
     _Float16 f16 = *reinterpret_cast<_Float16*>(&h);
     return static_cast<float>(f16);
@@ -263,16 +268,20 @@ inline CUDA_CALLABLE half operator / (half a,half b)
 
 
 template <typename T>
-CUDA_CALLABLE float cast_float(T x) { return (float)(x); }
+CUDA_CALLABLE inline float cast_float(T x) { return (float)(x); }
 
 template <typename T>
-CUDA_CALLABLE int cast_int(T x) { return (int)(x); }
+CUDA_CALLABLE inline int cast_int(T x) { return (int)(x); }
 
 template <typename T>
-CUDA_CALLABLE void adj_cast_float(T x, T& adj_x, float adj_ret) { adj_x += T(adj_ret); }
+CUDA_CALLABLE inline void adj_cast_float(T x, T& adj_x, float adj_ret) {}
+
+CUDA_CALLABLE inline void adj_cast_float(float16 x, float16& adj_x, float adj_ret) { adj_x += float16(adj_ret); }
+CUDA_CALLABLE inline void adj_cast_float(float32 x, float32& adj_x, float adj_ret) { adj_x += float32(adj_ret); }
+CUDA_CALLABLE inline void adj_cast_float(float64 x, float64& adj_x, float adj_ret) { adj_x += float64(adj_ret); }
 
 template <typename T>
-CUDA_CALLABLE void adj_cast_int(T x, T& adj_x, int adj_ret) { adj_x += adj_ret; }
+CUDA_CALLABLE inline void adj_cast_int(T x, T& adj_x, int adj_ret) {}
 
 template <typename T>
 CUDA_CALLABLE inline void adj_int8(T, T&, int8) {}
@@ -1221,6 +1230,15 @@ inline CUDA_CALLABLE launch_coord_t launch_coord(size_t linear, const launch_bou
     return coord;
 }
 
+inline CUDA_CALLABLE int block_dim()
+{
+#if defined(__CUDA_ARCH__)
+    return blockDim.x;
+#else
+    return 1;
+#endif
+}
+
 inline CUDA_CALLABLE int tid(size_t index, const launch_bounds_t& bounds)
 {
     // For the 1-D tid() we need to warn the user if we're about to provide a truncated index
@@ -1301,34 +1319,35 @@ inline CUDA_CALLABLE float16 atomic_add(float16* buf, float16 value)
     float16 old = buf[0];
     buf[0] += value;
     return old;
-#elif defined(__clang__)  // CUDA compiled by Clang
-	__half r = atomicAdd(reinterpret_cast<__half*>(buf), *reinterpret_cast<__half*>(&value));
-    return *reinterpret_cast<float16*>(&r);
 #else  // CUDA compiled by NVRTC
-    //return atomicAdd(buf, value);
-    
-    /* Define __PTR for atomicAdd prototypes below, undef after done */
-    #if (defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__) || defined(__CUDACC_RTC__)
-    #define __PTR   "l"
-    #else
-    #define __PTR   "r"
-    #endif /*(defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__) || defined(__CUDACC_RTC__)*/
-   
-    half r = 0.0;
-
     #if __CUDA_ARCH__ >= 700
-
-        asm volatile ("{ atom.add.noftz.f16 %0,[%1],%2; }\n"
-                    : "=h"(r.u)
-                    : __PTR(buf), "h"(value.u)
-                    : "memory");
+        #if defined(__clang__)  // CUDA compiled by Clang
+            __half r = atomicAdd(reinterpret_cast<__half*>(buf), *reinterpret_cast<__half*>(&value));
+            return *reinterpret_cast<float16*>(&r);
+        #else  // CUDA compiled by NVRTC
+            /* Define __PTR for atomicAdd prototypes below, undef after done */
+            #if (defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__) || defined(__CUDACC_RTC__)
+            #define __PTR   "l"
+            #else
+            #define __PTR   "r"
+            #endif /*(defined(_MSC_VER) && defined(_WIN64)) || defined(__LP64__) || defined(__CUDACC_RTC__)*/
+        
+            half r = 0.0;
+
+            asm volatile ("{ atom.add.noftz.f16 %0,[%1],%2; }\n"
+                        : "=h"(r.u)
+                        : __PTR(buf), "h"(value.u)
+                        : "memory");
+
+            return r;
+
+            #undef __PTR
+        #endif
+    #else
+        // No native __half atomic support on compute capability < 7.0
+        return float16(0.0f);
     #endif
-
-    return r;
-
-    #undef __PTR
-
-#endif  // CUDA compiled by NVRTC
+#endif
 }
 
 template<>
@@ -1508,6 +1527,129 @@ CUDA_CALLABLE inline void adj_atomic_minmax(uint64* buf, uint64* adj_buf, const
 CUDA_CALLABLE inline void adj_atomic_minmax(bool* buf, bool* adj_buf, const bool &value, bool &adj_value) { }
 
 
+template<typename T>
+inline CUDA_CALLABLE T atomic_cas(T* address, T compare, T val)
+{
+#if defined(__CUDA_ARCH__)
+    return atomicCAS(address, compare, val);
+#else
+    T old = *address;
+    if (old == compare) 
+    {
+        *address = val;
+    }
+    return old;
+#endif
+}
+
+template<>
+inline CUDA_CALLABLE float atomic_cas(float* address, float compare, float val)
+{
+#if defined(__CUDA_ARCH__)
+    auto result = atomicCAS(reinterpret_cast<unsigned int*>(address), 
+                    reinterpret_cast<unsigned int&>(compare), 
+                    reinterpret_cast<unsigned int&>(val));
+    return reinterpret_cast<float&>(result);
+#else
+    float old = *address;
+    if (old == compare) 
+    {
+        *address = val;
+    }
+    return old;
+#endif
+}
+
+template<>
+inline CUDA_CALLABLE double atomic_cas(double* address, double compare, double val)
+{
+#if defined(__CUDA_ARCH__)
+    auto result = atomicCAS(reinterpret_cast<unsigned long long int *>(address), 
+                    reinterpret_cast<unsigned long long int &>(compare), 
+                    reinterpret_cast<unsigned long long int &>(val));
+    return reinterpret_cast<double&>(result);
+#else
+    double old = *address;
+    if (old == compare) 
+    {
+        *address = val;
+    }
+    return old;
+#endif
+}
+
+template<>
+inline CUDA_CALLABLE int64 atomic_cas(int64* address, int64 compare, int64 val)
+{
+#if defined(__CUDA_ARCH__)
+    auto result = atomicCAS(reinterpret_cast<unsigned long long int *>(address), 
+                    reinterpret_cast<unsigned long long int &>(compare), 
+                    reinterpret_cast<unsigned long long int &>(val));
+    return reinterpret_cast<int64&>(result);
+#else
+    int64 old = *address;
+    if (old == compare) 
+    {
+        *address = val;
+    }
+    return old;
+#endif
+}
+
+template<typename T>
+inline CUDA_CALLABLE T atomic_exch(T* address, T val)
+{
+#if defined(__CUDA_ARCH__)
+    return atomicExch(address, val);
+#else
+    T old = *address;
+    *address = val;
+    return old;
+#endif
+}
+
+template<>
+inline CUDA_CALLABLE double atomic_exch(double* address, double val)
+{
+#if defined(__CUDA_ARCH__)
+    auto result = atomicExch(reinterpret_cast<unsigned long long int*>(address), 
+                     reinterpret_cast<unsigned long long int&>(val));
+    return reinterpret_cast<double&>(result);
+#else
+    double old = *address;
+    *address = val;
+    return old;
+#endif
+}
+
+template<>
+inline CUDA_CALLABLE int64 atomic_exch(int64* address, int64 val)
+{
+#if defined(__CUDA_ARCH__)
+    auto result = atomicExch(reinterpret_cast<unsigned long long int*>(address), 
+                     reinterpret_cast<unsigned long long int&>(val));
+    return reinterpret_cast<int64&>(result);
+#else
+    int64 old = *address;
+    *address = val;
+    return old;
+#endif
+}
+
+
+template<typename T>
+CUDA_CALLABLE inline void adj_atomic_cas(T* address, T compare, T val, T* adj_address, T& adj_compare, T& adj_val, T adj_ret)
+{
+    // Not implemented
+}
+
+template<typename T>
+CUDA_CALLABLE inline void adj_atomic_exch(T* address, T val, T* adj_address, T& adj_val, T adj_ret)
+{
+    // Not implemented
+}
+
+
 } // namespace wp
 
 
@@ -1778,8 +1920,9 @@ inline CUDA_CALLABLE void expect_near(const T& actual, const T& expected, const
     if (abs(actual - expected) > tolerance)
     {
         printf("Error, expect_near() failed with tolerance "); print(tolerance);
-        printf("\t Expected: "); print(expected); 
-        printf("\t Actual: "); print(actual);
+        printf("    Expected: "); print(expected); 
+        printf("    Actual: "); print(actual);
+        printf("    Absolute difference: "); print(abs(actual - expected));
     }
 }
 
@@ -1789,8 +1932,9 @@ inline CUDA_CALLABLE void expect_near(const vec3& actual, const vec3& expected,
     if (diff > tolerance)
     {
         printf("Error, expect_near() failed with tolerance "); print(tolerance);
-        printf("\t Expected: "); print(expected); 
-        printf("\t Actual: "); print(actual);
+        printf("    Expected: "); print(expected); 
+        printf("    Actual: "); print(actual);
+        printf("    Max absolute difference: "); print(diff);
     }
 }
 
@@ -1810,6 +1954,7 @@ inline CUDA_CALLABLE void adj_expect_near(const vec3& actual, const vec3& expect
 
 // include array.h so we have the print, isfinite functions for the inner array types defined
 #include "array.h"
+#include "tuple.h"
 #include "mesh.h"
 #include "bvh.h" 
 #include "svd.h"
@@ -1823,4 +1968,6 @@ inline CUDA_CALLABLE void adj_expect_near(const vec3& actual, const vec3& expect
 #if !defined(WP_ENABLE_CUDA) // only include in kernels for now
 #include "tile.h"
 #include "tile_reduce.h"
+#include "tile_scan.h"
+#include "tile_radix_sort.h"
 #endif //!defined(WP_ENABLE_CUDA)

warp/native/coloring.cpp

@@ -209,9 +209,13 @@ float balance_color_groups(float target_max_min_ratio,
     do
     {
         int biggest_group = -1, smallest_group = -1;
-
+        float prev_max_min_ratio = max_min_ratio;
         max_min_ratio = find_largest_smallest_groups(color_groups, biggest_group, smallest_group);
 
+        if (prev_max_min_ratio > 0 && prev_max_min_ratio < max_min_ratio) {
+            return max_min_ratio;
+        }
+
         // graph is not optimizable anymore or target ratio reached
         if (color_groups[biggest_group].size() - color_groups[smallest_group].size() <= 2 
             || max_min_ratio < target_max_min_ratio)
@@ -372,7 +376,7 @@ public:
             // we need to update max_weight because weight_buckets[max_weight] became empty
         {
             int new_max_weight = 0;
-            for (size_t bucket_idx = max_weight - 1; bucket_idx >= 0; bucket_idx--)
+            for (int bucket_idx = max_weight - 1; bucket_idx >= 0; bucket_idx--)
             {
                 if (weight_buckets[bucket_idx].size())
                 {

warp/native/cuda_util.cpp

@@ -212,7 +212,7 @@ bool init_cuda_driver()
     get_driver_entry_point("cuDeviceGetCount", 2000, &(void*&)pfn_cuDeviceGetCount);
     get_driver_entry_point("cuDeviceGetName", 2000, &(void*&)pfn_cuDeviceGetName);
     get_driver_entry_point("cuDeviceGetAttribute", 2000, &(void*&)pfn_cuDeviceGetAttribute);
-    get_driver_entry_point("cuDeviceGetUuid", 110400, &(void*&)pfn_cuDeviceGetUuid);
+    get_driver_entry_point("cuDeviceGetUuid", 11040, &(void*&)pfn_cuDeviceGetUuid);
     get_driver_entry_point("cuDevicePrimaryCtxRetain", 7000, &(void*&)pfn_cuDevicePrimaryCtxRetain);
     get_driver_entry_point("cuDevicePrimaryCtxRelease", 11000, &(void*&)pfn_cuDevicePrimaryCtxRelease);
     get_driver_entry_point("cuDeviceCanAccessPeer", 4000, &(void*&)pfn_cuDeviceCanAccessPeer);

warp/native/exports.h

@@ -953,10 +953,25 @@ WP_API void builtin_cw_div_mat22d_mat22d(mat22d& a, mat22d& b, mat22d* ret) { *r
 WP_API void builtin_cw_div_mat33d_mat33d(mat33d& a, mat33d& b, mat33d* ret) { *ret = wp::cw_div(a, b); }
 WP_API void builtin_cw_div_mat44d_mat44d(mat44d& a, mat44d& b, mat44d* ret) { *ret = wp::cw_div(a, b); }
 WP_API void builtin_cw_div_spatial_matrixd_spatial_matrixd(spatial_matrixd& a, spatial_matrixd& b, spatial_matrixd* ret) { *ret = wp::cw_div(a, b); }
+WP_API void builtin_svd3_mat33h(mat33h& A, mat33h& ret_0, vec3h& ret_1, mat33h& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd3_mat33f(mat33f& A, mat33f& ret_0, vec3f& ret_1, mat33f& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd3_mat33d(mat33d& A, mat33d& ret_0, vec3d& ret_1, mat33d& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22h(mat22h& A, mat22h& ret_0, vec2h& ret_1, mat22h& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22f(mat22f& A, mat22f& ret_0, vec2f& ret_1, mat22f& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22d(mat22d& A, mat22d& ret_0, vec2d& ret_1, mat22d& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_qr3_mat33h(mat33h& A, mat33h& ret_0, mat33h& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_qr3_mat33f(mat33f& A, mat33f& ret_0, mat33f& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_qr3_mat33d(mat33d& A, mat33d& ret_0, mat33d& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33h(mat33h& A, mat33h& ret_0, vec3h& ret_1) { wp::eig3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33f(mat33f& A, mat33f& ret_0, vec3f& ret_1) { wp::eig3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33d(mat33d& A, mat33d& ret_0, vec3d& ret_1) { wp::eig3(A, ret_0, ret_1); }
 WP_API void builtin_quat_identity(quatf* ret) { *ret = wp::quat_identity(); }
 WP_API void builtin_quat_from_axis_angle_vec3h_float16(vec3h& axis, float16 angle, quath* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
 WP_API void builtin_quat_from_axis_angle_vec3f_float32(vec3f& axis, float32 angle, quatf* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
 WP_API void builtin_quat_from_axis_angle_vec3d_float64(vec3d& axis, float64 angle, quatd* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
+WP_API void builtin_quat_to_axis_angle_quath(quath& quat, vec3h& ret_0, float16& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
+WP_API void builtin_quat_to_axis_angle_quatf(quatf& quat, vec3f& ret_0, float32& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
+WP_API void builtin_quat_to_axis_angle_quatd(quatd& quat, vec3d& ret_0, float64& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
 WP_API void builtin_quat_from_matrix_mat33h(mat33h& mat, quath* ret) { *ret = wp::quat_from_matrix(mat); }
 WP_API void builtin_quat_from_matrix_mat33f(mat33f& mat, quatf* ret) { *ret = wp::quat_from_matrix(mat); }
 WP_API void builtin_quat_from_matrix_mat33d(mat33d& mat, quatd* ret) { *ret = wp::quat_from_matrix(mat); }
@@ -988,6 +1003,12 @@ WP_API void builtin_transform_get_translation_transformd(transformd& xform, vec3
 WP_API void builtin_transform_get_rotation_transformh(transformh& xform, quath* ret) { *ret = wp::transform_get_rotation(xform); }
 WP_API void builtin_transform_get_rotation_transformf(transformf& xform, quatf* ret) { *ret = wp::transform_get_rotation(xform); }
 WP_API void builtin_transform_get_rotation_transformd(transformd& xform, quatd* ret) { *ret = wp::transform_get_rotation(xform); }
+WP_API void builtin_transform_set_translation_transformh_vec3h(transformh& xform, vec3h& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_translation_transformf_vec3f(transformf& xform, vec3f& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_translation_transformd_vec3d(transformd& xform, vec3d& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_rotation_transformh_quath(transformh& xform, quath& q) { wp::transform_set_rotation(xform, q); }
+WP_API void builtin_transform_set_rotation_transformf_quatf(transformf& xform, quatf& q) { wp::transform_set_rotation(xform, q); }
+WP_API void builtin_transform_set_rotation_transformd_quatd(transformd& xform, quatd& q) { wp::transform_set_rotation(xform, q); }
 WP_API void builtin_transform_multiply_transformh_transformh(transformh& a, transformh& b, transformh* ret) { *ret = wp::transform_multiply(a, b); }
 WP_API void builtin_transform_multiply_transformf_transformf(transformf& a, transformf& b, transformf* ret) { *ret = wp::transform_multiply(a, b); }
 WP_API void builtin_transform_multiply_transformd_transformd(transformd& a, transformd& b, transformd* ret) { *ret = wp::transform_multiply(a, b); }
@@ -1063,6 +1084,7 @@ WP_API void builtin_pnoise_uint32_vec4f_int32_int32_int32_int32(uint32 state, ve
 WP_API void builtin_curlnoise_uint32_vec2f_uint32_float32_float32(uint32 state, vec2f& xy, uint32 octaves, float32 lacunarity, float32 gain, vec2f* ret) { *ret = wp::curlnoise(state, xy, octaves, lacunarity, gain); }
 WP_API void builtin_curlnoise_uint32_vec3f_uint32_float32_float32(uint32 state, vec3f& xyz, uint32 octaves, float32 lacunarity, float32 gain, vec3f* ret) { *ret = wp::curlnoise(state, xyz, octaves, lacunarity, gain); }
 WP_API void builtin_curlnoise_uint32_vec4f_uint32_float32_float32(uint32 state, vec4f& xyzt, uint32 octaves, float32 lacunarity, float32 gain, vec3f* ret) { *ret = wp::curlnoise(state, xyzt, octaves, lacunarity, gain); }
+WP_API void builtin_block_dim(int* ret) { *ret = wp::block_dim(); }
 WP_API void builtin_extract_vec2h_int32(vec2h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_vec3h_int32(vec3h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_vec4h_int32(vec4h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
@@ -1130,69 +1152,72 @@ WP_API void builtin_extract_transformh_int32(transformh& a, int32 i, float16* re
 WP_API void builtin_extract_transformf_int32(transformf& a, int32 i, float32* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_transformd_int32(transformd& a, int32 i, float64* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_shape_t_int32(shape_t s, int32 i, int* ret) { *ret = wp::extract(s, i); }
-WP_API void builtin_assign_copy_vec2h_int32_float16(vec2h& a, int32 i, float16 value, vec2h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3h_int32_float16(vec3h& a, int32 i, float16 value, vec3h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4h_int32_float16(vec4h& a, int32 i, float16 value, vec4h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectorh_int32_float16(spatial_vectorh& a, int32 i, float16 value, spatial_vectorh* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2f_int32_float32(vec2f& a, int32 i, float32 value, vec2f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3f_int32_float32(vec3f& a, int32 i, float32 value, vec3f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4f_int32_float32(vec4f& a, int32 i, float32 value, vec4f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectorf_int32_float32(spatial_vectorf& a, int32 i, float32 value, spatial_vectorf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2d_int32_float64(vec2d& a, int32 i, float64 value, vec2d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3d_int32_float64(vec3d& a, int32 i, float64 value, vec3d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4d_int32_float64(vec4d& a, int32 i, float64 value, vec4d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectord_int32_float64(spatial_vectord& a, int32 i, float64 value, spatial_vectord* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2s_int32_int16(vec2s& a, int32 i, int16 value, vec2s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3s_int32_int16(vec3s& a, int32 i, int16 value, vec3s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4s_int32_int16(vec4s& a, int32 i, int16 value, vec4s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2i_int32_int32(vec2i& a, int32 i, int32 value, vec2i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3i_int32_int32(vec3i& a, int32 i, int32 value, vec3i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4i_int32_int32(vec4i& a, int32 i, int32 value, vec4i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2l_int32_int64(vec2l& a, int32 i, int64 value, vec2l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3l_int32_int64(vec3l& a, int32 i, int64 value, vec3l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4l_int32_int64(vec4l& a, int32 i, int64 value, vec4l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2b_int32_int8(vec2b& a, int32 i, int8 value, vec2b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3b_int32_int8(vec3b& a, int32 i, int8 value, vec3b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4b_int32_int8(vec4b& a, int32 i, int8 value, vec4b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2us_int32_uint16(vec2us& a, int32 i, uint16 value, vec2us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3us_int32_uint16(vec3us& a, int32 i, uint16 value, vec3us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4us_int32_uint16(vec4us& a, int32 i, uint16 value, vec4us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ui_int32_uint32(vec2ui& a, int32 i, uint32 value, vec2ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ui_int32_uint32(vec3ui& a, int32 i, uint32 value, vec3ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ui_int32_uint32(vec4ui& a, int32 i, uint32 value, vec4ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ul_int32_uint64(vec2ul& a, int32 i, uint64 value, vec2ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ul_int32_uint64(vec3ul& a, int32 i, uint64 value, vec3ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ul_int32_uint64(vec4ul& a, int32 i, uint64 value, vec4ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ub_int32_uint8(vec2ub& a, int32 i, uint8 value, vec2ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ub_int32_uint8(vec3ub& a, int32 i, uint8 value, vec3ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ub_int32_uint8(vec4ub& a, int32 i, uint8 value, vec4ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quath_int32_float16(quath& a, int32 i, float16 value, quath* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quatf_int32_float32(quatf& a, int32 i, float32 value, quatf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quatd_int32_float64(quatd& a, int32 i, float64 value, quatd* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22h_int32_int32_float16(mat22h& a, int32 i, int32 j, float16 value, mat22h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33h_int32_int32_float16(mat33h& a, int32 i, int32 j, float16 value, mat33h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44h_int32_int32_float16(mat44h& a, int32 i, int32 j, float16 value, mat44h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixh_int32_int32_float16(spatial_matrixh& a, int32 i, int32 j, float16 value, spatial_matrixh* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22f_int32_int32_float32(mat22f& a, int32 i, int32 j, float32 value, mat22f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33f_int32_int32_float32(mat33f& a, int32 i, int32 j, float32 value, mat33f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44f_int32_int32_float32(mat44f& a, int32 i, int32 j, float32 value, mat44f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixf_int32_int32_float32(spatial_matrixf& a, int32 i, int32 j, float32 value, spatial_matrixf* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22d_int32_int32_float64(mat22d& a, int32 i, int32 j, float64 value, mat22d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33d_int32_int32_float64(mat33d& a, int32 i, int32 j, float64 value, mat33d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44d_int32_int32_float64(mat44d& a, int32 i, int32 j, float64 value, mat44d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixd_int32_int32_float64(spatial_matrixd& a, int32 i, int32 j, float64 value, spatial_matrixd* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22h_int32_vec2h(mat22h& a, int32 i, vec2h& value, mat22h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33h_int32_vec3h(mat33h& a, int32 i, vec3h& value, mat33h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44h_int32_vec4h(mat44h& a, int32 i, vec4h& value, mat44h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixh_int32_spatial_vectorh(spatial_matrixh& a, int32 i, spatial_vectorh& value, spatial_matrixh* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22f_int32_vec2f(mat22f& a, int32 i, vec2f& value, mat22f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33f_int32_vec3f(mat33f& a, int32 i, vec3f& value, mat33f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44f_int32_vec4f(mat44f& a, int32 i, vec4f& value, mat44f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixf_int32_spatial_vectorf(spatial_matrixf& a, int32 i, spatial_vectorf& value, spatial_matrixf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22d_int32_vec2d(mat22d& a, int32 i, vec2d& value, mat22d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33d_int32_vec3d(mat33d& a, int32 i, vec3d& value, mat33d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44d_int32_vec4d(mat44d& a, int32 i, vec4d& value, mat44d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixd_int32_spatial_vectord(spatial_matrixd& a, int32 i, spatial_vectord& value, spatial_matrixd* ret) { *ret = wp::assign_copy(a, i, value); }
+WP_API void builtin_expect_eq_int8_int8(int8 a, int8 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint8_uint8(uint8 a, uint8 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int16_int16(int16 a, int16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint16_uint16(uint16 a, uint16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int32_int32(int32 a, int32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint32_uint32(uint32 a, uint32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int64_int64(int64 a, int64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint64_uint64(uint64 a, uint64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float16_float16(float16 a, float16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float32_float32(float32 a, float32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float64_float64(float64 a, float64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quath_quath(quath& a, quath& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quatf_quatf(quatf& a, quatf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quatd_quatd(quatd& a, quatd& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformh_transformh(transformh& a, transformh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformf_transformf(transformf& a, transformf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformd_transformd(transformd& a, transformd& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_bool_bool(bool a, bool b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2h_vec2h(vec2h& a, vec2h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3h_vec3h(vec3h& a, vec3h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4h_vec4h(vec4h& a, vec4h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectorh_spatial_vectorh(spatial_vectorh& a, spatial_vectorh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2f_vec2f(vec2f& a, vec2f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3f_vec3f(vec3f& a, vec3f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4f_vec4f(vec4f& a, vec4f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectorf_spatial_vectorf(spatial_vectorf& a, spatial_vectorf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2d_vec2d(vec2d& a, vec2d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3d_vec3d(vec3d& a, vec3d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4d_vec4d(vec4d& a, vec4d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectord_spatial_vectord(spatial_vectord& a, spatial_vectord& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2s_vec2s(vec2s& a, vec2s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3s_vec3s(vec3s& a, vec3s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4s_vec4s(vec4s& a, vec4s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2i_vec2i(vec2i& a, vec2i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3i_vec3i(vec3i& a, vec3i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4i_vec4i(vec4i& a, vec4i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2l_vec2l(vec2l& a, vec2l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3l_vec3l(vec3l& a, vec3l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4l_vec4l(vec4l& a, vec4l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2b_vec2b(vec2b& a, vec2b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3b_vec3b(vec3b& a, vec3b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4b_vec4b(vec4b& a, vec4b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2us_vec2us(vec2us& a, vec2us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3us_vec3us(vec3us& a, vec3us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4us_vec4us(vec4us& a, vec4us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ui_vec2ui(vec2ui& a, vec2ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ui_vec3ui(vec3ui& a, vec3ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ui_vec4ui(vec4ui& a, vec4ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ul_vec2ul(vec2ul& a, vec2ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ul_vec3ul(vec3ul& a, vec3ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ul_vec4ul(vec4ul& a, vec4ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ub_vec2ub(vec2ub& a, vec2ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ub_vec3ub(vec3ub& a, vec3ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ub_vec4ub(vec4ub& a, vec4ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22h_mat22h(mat22h& a, mat22h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33h_mat33h(mat33h& a, mat33h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44h_mat44h(mat44h& a, mat44h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixh_spatial_matrixh(spatial_matrixh& a, spatial_matrixh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22f_mat22f(mat22f& a, mat22f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33f_mat33f(mat33f& a, mat33f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44f_mat44f(mat44f& a, mat44f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixf_spatial_matrixf(spatial_matrixf& a, spatial_matrixf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22d_mat22d(mat22d& a, mat22d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33d_mat33d(mat33d& a, mat33d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44d_mat44d(mat44d& a, mat44d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixd_spatial_matrixd(spatial_matrixd& a, spatial_matrixd& b) { wp::expect_eq(a, b); }
 WP_API void builtin_lerp_float16_float16_float16(float16 a, float16 b, float16 t, float16* ret) { *ret = wp::lerp(a, b, t); }
 WP_API void builtin_lerp_float32_float32_float32(float32 a, float32 b, float32 t, float32* ret) { *ret = wp::lerp(a, b, t); }
 WP_API void builtin_lerp_float64_float64_float64(float64 a, float64 b, float64 t, float64* ret) { *ret = wp::lerp(a, b, t); }
@@ -1229,6 +1254,36 @@ WP_API void builtin_lerp_transformd_transformd_float64(transformd& a, transformd
 WP_API void builtin_smoothstep_float16_float16_float16(float16 a, float16 b, float16 x, float16* ret) { *ret = wp::smoothstep(a, b, x); }
 WP_API void builtin_smoothstep_float32_float32_float32(float32 a, float32 b, float32 x, float32* ret) { *ret = wp::smoothstep(a, b, x); }
 WP_API void builtin_smoothstep_float64_float64_float64(float64 a, float64 b, float64 x, float64* ret) { *ret = wp::smoothstep(a, b, x); }
+WP_API void builtin_expect_near_float16_float16_float16(float16 a, float16 b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_float32_float32_float32(float32 a, float32 b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_float64_float64_float64(float64 a, float64 b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2h_vec2h_float16(vec2h& a, vec2h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3h_vec3h_float16(vec3h& a, vec3h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4h_vec4h_float16(vec4h& a, vec4h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectorh_spatial_vectorh_float16(spatial_vectorh& a, spatial_vectorh& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2f_vec2f_float32(vec2f& a, vec2f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3f_vec3f_float32(vec3f& a, vec3f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4f_vec4f_float32(vec4f& a, vec4f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectorf_spatial_vectorf_float32(spatial_vectorf& a, spatial_vectorf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2d_vec2d_float64(vec2d& a, vec2d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3d_vec3d_float64(vec3d& a, vec3d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4d_vec4d_float64(vec4d& a, vec4d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectord_spatial_vectord_float64(spatial_vectord& a, spatial_vectord& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quath_quath_float16(quath& a, quath& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quatf_quatf_float32(quatf& a, quatf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quatd_quatd_float64(quatd& a, quatd& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22h_mat22h_float16(mat22h& a, mat22h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33h_mat33h_float16(mat33h& a, mat33h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44h_mat44h_float16(mat44h& a, mat44h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixh_spatial_matrixh_float16(spatial_matrixh& a, spatial_matrixh& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22f_mat22f_float32(mat22f& a, mat22f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33f_mat33f_float32(mat33f& a, mat33f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44f_mat44f_float32(mat44f& a, mat44f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixf_spatial_matrixf_float32(spatial_matrixf& a, spatial_matrixf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22d_mat22d_float64(mat22d& a, mat22d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33d_mat33d_float64(mat33d& a, mat33d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44d_mat44d_float64(mat44d& a, mat44d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixd_spatial_matrixd_float64(spatial_matrixd& a, spatial_matrixd& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
 WP_API void builtin_add_float16_float16(float16 a, float16 b, float16* ret) { *ret = wp::add(a, b); }
 WP_API void builtin_add_float32_float32(float32 a, float32 b, float32* ret) { *ret = wp::add(a, b); }
 WP_API void builtin_add_float64_float64(float64 a, float64 b, float64* ret) { *ret = wp::add(a, b); }

warp/native/intersect.h

@@ -316,7 +316,7 @@ CUDA_CALLABLE inline bool intersect_ray_tri_woop(const vec3& p, const vec3& dir,
 
 	if (dir[kz] < 0.0f)
 	{
-		float tmp = kx;
+		int tmp = kx;
 		kx = ky;
 		ky = tmp;
 	}
@@ -410,7 +410,7 @@ CUDA_CALLABLE inline void adj_intersect_ray_tri_woop(
 
 	if (dir[kz] < 0.0f)
 	{
-		float tmp = kx;
+		int tmp = kx;
 		kx = ky;
 		ky = tmp;
 	}
@@ -665,7 +665,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     bool var_25;
     bool var_26;
     bool var_27;
-    float32 var_28;
+    float32 var_28 = 0.0;
     vec2 var_29;
     vec2 var_30;
     vec3 var_31;
@@ -685,7 +685,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     bool var_45;
     bool var_46;
     bool var_47;
-    float32 var_48;
+    float32 var_48 = 0.0;
     vec2 var_49;
     vec2 var_50;
     float32 var_51;
@@ -702,7 +702,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     float32 var_62;
     bool var_63;
     bool var_64;
-    float32 var_65;
+    float32 var_65 = 0.0;
     vec2 var_66;
     // vec2 var_67;
     float32 var_68;