warp-lang 1.1.0__py3-none-macosx_10_13_universal2.whl → 1.2.1__py3-none-macosx_10_13_universal2.whl

warp/native/exports.h

@@ -298,6 +298,192 @@ WP_API void builtin_ceil_float64(float64 x, float64* ret) { *ret = wp::ceil(x);
 WP_API void builtin_frac_float16(float16 x, float16* ret) { *ret = wp::frac(x); }
 WP_API void builtin_frac_float32(float32 x, float32* ret) { *ret = wp::frac(x); }
 WP_API void builtin_frac_float64(float64 x, float64* ret) { *ret = wp::frac(x); }
+WP_API void builtin_isfinite_float16(float16 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_float32(float32 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_float64(float64 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_int16(int16 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_int32(int32 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_int64(int64 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_int8(int8 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_uint16(uint16 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_uint32(uint32 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_uint64(uint64 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_uint8(uint8 x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2h(vec2h& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3h(vec3h& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4h(vec4h& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_spatial_vectorh(spatial_vectorh& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2f(vec2f& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3f(vec3f& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4f(vec4f& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_spatial_vectorf(spatial_vectorf& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2d(vec2d& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3d(vec3d& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4d(vec4d& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_spatial_vectord(spatial_vectord& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2s(vec2s& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3s(vec3s& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4s(vec4s& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2i(vec2i& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3i(vec3i& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4i(vec4i& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2l(vec2l& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3l(vec3l& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4l(vec4l& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2b(vec2b& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3b(vec3b& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4b(vec4b& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2us(vec2us& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3us(vec3us& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4us(vec4us& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2ui(vec2ui& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3ui(vec3ui& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4ui(vec4ui& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2ul(vec2ul& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3ul(vec3ul& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4ul(vec4ul& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec2ub(vec2ub& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec3ub(vec3ub& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_vec4ub(vec4ub& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_quath(quath& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_quatf(quatf& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_quatd(quatd& x, bool* ret) { *ret = wp::isfinite(x); }
+WP_API void builtin_isfinite_mat22h(mat22h& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat33h(mat33h& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat44h(mat44h& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_spatial_matrixh(spatial_matrixh& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat22f(mat22f& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat33f(mat33f& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat44f(mat44f& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_spatial_matrixf(spatial_matrixf& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat22d(mat22d& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat33d(mat33d& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_mat44d(mat44d& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isfinite_spatial_matrixd(spatial_matrixd& m, bool* ret) { *ret = wp::isfinite(m); }
+WP_API void builtin_isnan_float16(float16 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_float32(float32 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_float64(float64 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_int16(int16 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_int32(int32 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_int64(int64 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_int8(int8 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_uint16(uint16 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_uint32(uint32 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_uint64(uint64 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_uint8(uint8 x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2h(vec2h& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3h(vec3h& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4h(vec4h& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_spatial_vectorh(spatial_vectorh& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2f(vec2f& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3f(vec3f& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4f(vec4f& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_spatial_vectorf(spatial_vectorf& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2d(vec2d& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3d(vec3d& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4d(vec4d& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_spatial_vectord(spatial_vectord& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2s(vec2s& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3s(vec3s& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4s(vec4s& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2i(vec2i& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3i(vec3i& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4i(vec4i& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2l(vec2l& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3l(vec3l& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4l(vec4l& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2b(vec2b& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3b(vec3b& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4b(vec4b& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2us(vec2us& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3us(vec3us& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4us(vec4us& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2ui(vec2ui& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3ui(vec3ui& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4ui(vec4ui& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2ul(vec2ul& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3ul(vec3ul& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4ul(vec4ul& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec2ub(vec2ub& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec3ub(vec3ub& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_vec4ub(vec4ub& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_quath(quath& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_quatf(quatf& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_quatd(quatd& x, bool* ret) { *ret = wp::isnan(x); }
+WP_API void builtin_isnan_mat22h(mat22h& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat33h(mat33h& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat44h(mat44h& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_spatial_matrixh(spatial_matrixh& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat22f(mat22f& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat33f(mat33f& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat44f(mat44f& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_spatial_matrixf(spatial_matrixf& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat22d(mat22d& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat33d(mat33d& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_mat44d(mat44d& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isnan_spatial_matrixd(spatial_matrixd& m, bool* ret) { *ret = wp::isnan(m); }
+WP_API void builtin_isinf_float16(float16 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_float32(float32 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_float64(float64 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_int16(int16 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_int32(int32 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_int64(int64 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_int8(int8 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_uint16(uint16 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_uint32(uint32 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_uint64(uint64 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_uint8(uint8 x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2h(vec2h& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3h(vec3h& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4h(vec4h& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_spatial_vectorh(spatial_vectorh& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2f(vec2f& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3f(vec3f& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4f(vec4f& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_spatial_vectorf(spatial_vectorf& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2d(vec2d& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3d(vec3d& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4d(vec4d& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_spatial_vectord(spatial_vectord& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2s(vec2s& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3s(vec3s& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4s(vec4s& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2i(vec2i& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3i(vec3i& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4i(vec4i& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2l(vec2l& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3l(vec3l& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4l(vec4l& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2b(vec2b& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3b(vec3b& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4b(vec4b& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2us(vec2us& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3us(vec3us& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4us(vec4us& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2ui(vec2ui& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3ui(vec3ui& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4ui(vec4ui& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2ul(vec2ul& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3ul(vec3ul& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4ul(vec4ul& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec2ub(vec2ub& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec3ub(vec3ub& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_vec4ub(vec4ub& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_quath(quath& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_quatf(quatf& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_quatd(quatd& x, bool* ret) { *ret = wp::isinf(x); }
+WP_API void builtin_isinf_mat22h(mat22h& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat33h(mat33h& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat44h(mat44h& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_spatial_matrixh(spatial_matrixh& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat22f(mat22f& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat33f(mat33f& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat44f(mat44f& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_spatial_matrixf(spatial_matrixf& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat22d(mat22d& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat33d(mat33d& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_mat44d(mat44d& m, bool* ret) { *ret = wp::isinf(m); }
+WP_API void builtin_isinf_spatial_matrixd(spatial_matrixd& m, bool* ret) { *ret = wp::isinf(m); }
 WP_API void builtin_dot_vec2h_vec2h(vec2h& x, vec2h& y, float16* ret) { *ret = wp::dot(x, y); }
 WP_API void builtin_dot_vec3h_vec3h(vec3h& x, vec3h& y, float16* ret) { *ret = wp::dot(x, y); }
 WP_API void builtin_dot_vec4h_vec4h(vec4h& x, vec4h& y, float16* ret) { *ret = wp::dot(x, y); }
@@ -782,6 +968,7 @@ WP_API void builtin_volume_sample_v_uint64_vec3f_int32(uint64 id, vec3f& uvw, in
 WP_API void builtin_volume_lookup_v_uint64_int32_int32_int32(uint64 id, int32 i, int32 j, int32 k, vec3f* ret) { *ret = wp::volume_lookup_v(id, i, j, k); }
 WP_API void builtin_volume_sample_i_uint64_vec3f(uint64 id, vec3f& uvw, int* ret) { *ret = wp::volume_sample_i(id, uvw); }
 WP_API void builtin_volume_lookup_i_uint64_int32_int32_int32(uint64 id, int32 i, int32 j, int32 k, int* ret) { *ret = wp::volume_lookup_i(id, i, j, k); }
+WP_API void builtin_volume_lookup_index_uint64_int32_int32_int32(uint64 id, int32 i, int32 j, int32 k, int32* ret) { *ret = wp::volume_lookup_index(id, i, j, k); }
 WP_API void builtin_volume_index_to_world_uint64_vec3f(uint64 id, vec3f& uvw, vec3f* ret) { *ret = wp::volume_index_to_world(id, uvw); }
 WP_API void builtin_volume_world_to_index_uint64_vec3f(uint64 id, vec3f& xyz, vec3f* ret) { *ret = wp::volume_world_to_index(id, xyz); }
 WP_API void builtin_volume_index_to_world_dir_uint64_vec3f(uint64 id, vec3f& uvw, vec3f* ret) { *ret = wp::volume_index_to_world_dir(id, uvw); }

warp/native/mat.h

@@ -397,6 +397,41 @@ inline bool CUDA_CALLABLE isfinite(const mat_t<Rows,Cols,Type>& m)
     return true;
 }
 
+template<unsigned Rows, unsigned Cols, typename Type>
+inline void CUDA_CALLABLE adj_isfinite(const mat_t<Rows,Cols,Type>& m, mat_t<Rows,Cols,Type>& adj_m, const bool &adj_ret)
+{
+}
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline bool CUDA_CALLABLE isnan(const mat_t<Rows,Cols,Type>& m)
+{
+    for (unsigned i=0; i < Rows; ++i)
+        for (unsigned j=0; j < Cols; ++j)
+            if (isnan(m.data[i][j]))
+                return true;
+    return false;
+}
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline void CUDA_CALLABLE adj_isnan(const mat_t<Rows,Cols,Type>& m, mat_t<Rows,Cols,Type>& adj_m, const bool &adj_ret)
+{
+}
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline bool CUDA_CALLABLE isinf(const mat_t<Rows,Cols,Type>& m)
+{
+    for (unsigned i=0; i < Rows; ++i)
+        for (unsigned j=0; j < Cols; ++j)
+            if (isinf(m.data[i][j]))
+                return true;
+    return false;
+}
+
+template<unsigned Rows, unsigned Cols, typename Type>
+inline void CUDA_CALLABLE adj_isinf(const mat_t<Rows,Cols,Type>& m, mat_t<Rows,Cols,Type>& adj_m, const bool &adj_ret)
+{
+}
+
 template<unsigned Rows, unsigned Cols, typename Type>
 inline CUDA_CALLABLE mat_t<Rows,Cols,Type> add(const mat_t<Rows,Cols,Type>& a, const mat_t<Rows,Cols,Type>& b)
 {
@@ -842,6 +877,18 @@ inline CUDA_CALLABLE mat_t<Rows,Cols,Type> outer(const vec_t<Rows,Type>& a, cons
     return ret;
 }
 
+template<unsigned Cols,typename Type>
+inline CUDA_CALLABLE vec_t<Cols,Type> outer(Type a, const vec_t<Cols,Type>& b)
+{
+    return mul(a, b);
+}
+
+template<unsigned Rows,typename Type>
+inline CUDA_CALLABLE vec_t<Rows,Type> outer(const vec_t<Rows,Type>& a, Type b)
+{
+    return mul(a, b);
+}
+
 template<typename Type>
 inline CUDA_CALLABLE mat_t<3,3,Type> skew(const vec_t<3,Type>& a)
 {

warp/native/mesh.cpp

@@ -127,7 +127,7 @@ uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities
     }
     m->average_edge_length = sum / (num_tris*3);
 
-    m->bvh = *(wp::BVH*)bvh_create_host(m->lowers, m->uppers, num_tris);
+    wp::bvh_create_host(m->lowers, m->uppers, num_tris, m->bvh);
     
     if (support_winding_number) 
     {

warp/native/mesh.cu

@@ -208,8 +208,7 @@ uint64_t mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::arr
 
         wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_triangle_bounds, num_tris, (num_tris, points.data, indices.data, mesh.lowers, mesh.uppers));
 
-        uint64_t bvh_id = bvh_create_device(mesh.context, mesh.lowers, mesh.uppers, num_tris);
-        wp::bvh_get_descriptor(bvh_id, mesh.bvh);
+        wp::bvh_create_device(mesh.context, mesh.lowers, mesh.uppers, num_tris, mesh.bvh);
 
         if (support_winding_number)
         {

warp/native/nanovdb/GridHandle.h

@@ -0,0 +1,366 @@
+// Copyright Contributors to the OpenVDB Project
+// SPDX-License-Identifier: MPL-2.0
+
+/*!
+    \file nanovdb/GridHandle.h
+
+    \author Ken Museth
+
+    \date January 8, 2020
+
+    \brief Defines GridHandle, which manages a host, and possibly a device,
+           memory buffer containing one or more NanoVDB grids.
+*/
+
+#ifndef NANOVDB_GRID_HANDLE_H_HAS_BEEN_INCLUDED
+#define NANOVDB_GRID_HANDLE_H_HAS_BEEN_INCLUDED
+
+#include <fstream> // for std::ifstream
+#include <iostream> // for std::cerr/cout
+#include <vector>
+#include <initializer_list>
+
+#include <nanovdb/NanoVDB.h>// for toGridType
+#include <nanovdb/HostBuffer.h>
+
+namespace nanovdb {
+
+// --------------------------> GridHandle <------------------------------------
+
+struct GridHandleMetaData {uint64_t offset, size; GridType gridType;};
+
+/// @brief This class serves to manage a buffer containing one or more NanoVDB Grids.
+///
+/// @note  It is important to note that this class does NOT depend on OpenVDB.
+template<typename BufferT = HostBuffer>
+class GridHandle
+{
+    std::vector<GridHandleMetaData> mMetaData;
+    BufferT mBuffer;
+
+    template <typename T>
+    static T* no_const(const T* ptr) { return const_cast<T*>(ptr); }
+
+public:
+    using BufferType = BufferT;
+
+    /// @brief  Move constructor from a host buffer
+    /// @param buffer buffer containing one or more NanoGrids that will be moved into this GridHandle
+    /// @throw Will throw and error with the buffer does not contain a valid NanoGrid!
+    template<typename T = BufferT, typename util::enable_if<BufferTraits<T>::hasDeviceDual, int>::type = 0>
+    GridHandle(T&& buffer);
+
+    /// @brief  Move constructor from a dual host-device buffer
+    /// @param buffer buffer containing one or more NanoGrids that will be moved into this GridHandle
+    /// @throw Will throw and error with the buffer does not contain a valid NanoGrid!
+    template<typename T = BufferT, typename util::disable_if<BufferTraits<T>::hasDeviceDual, int>::type = 0>
+    GridHandle(T&& buffer);
+
+    /// @brief Constructs an empty GridHandle
+    GridHandle() = default;
+
+    /// @brief Disallow copy-construction
+    GridHandle(const GridHandle&) = delete;
+
+    /// @brief Move copy-constructor
+    GridHandle(GridHandle&& other) noexcept {
+        mBuffer   = std::move(other.mBuffer);
+        mMetaData = std::move(other.mMetaData);
+    }
+
+    /// @brief clear this GridHandle to an empty handle
+    void reset() {
+        mBuffer.clear();
+        mMetaData.clear();
+    }
+
+    /// @brief Disallow copy assignment operation
+    GridHandle& operator=(const GridHandle&) = delete;
+
+    /// @brief Move copy assignment operation
+    GridHandle& operator=(GridHandle&& other) noexcept {
+        mBuffer   = std::move(other.mBuffer);
+        mMetaData = std::move(other.mMetaData);
+        return *this;
+    }
+
+    /// @brief Performs a deep copy of the GridHandle, possibly templated on a different buffer type
+    /// @tparam OtherBufferT Buffer type of the deep copy
+    /// @param buffer optional buffer used for allocation
+    /// @return A new handle of the specified buffer type that contains a deep copy of the current handle
+    template <typename OtherBufferT = HostBuffer>
+    GridHandle<OtherBufferT> copy(const OtherBufferT& buffer = OtherBufferT()) const;
+
+    /// @brief Return a reference to the buffer
+    BufferT&       buffer() { return mBuffer; }
+
+    /// @brief Return a const reference to the buffer
+    const BufferT& buffer() const { return mBuffer; }
+
+    /// @brief Returns a non-const pointer to the data.
+    /// @warning Note that the return pointer can be NULL if the GridHandle was not initialized
+    void* data() { return mBuffer.data(); }
+
+    /// @brief Returns a const pointer to the data.
+    /// @warning Note that the return pointer can be NULL if the GridHandle was not initialized
+    const void* data() const { return mBuffer.data(); }
+
+    template<typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, const void*>::type
+    deviceData() const { return mBuffer.deviceData(); }
+    template<typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, void*>::type
+    deviceData() { return mBuffer.deviceData(); }
+
+    /// @brief Returns the size in bytes of the raw memory buffer managed by this GridHandle.
+    uint64_t size() const { return mBuffer.size(); }
+
+    //@{
+    /// @brief Return true if this handle is empty, i.e. has no allocated memory
+    bool empty()   const { return this->size() == 0; }
+    bool isEmpty() const { return this->size() == 0; }
+    //@}
+
+    /// @brief Return true if this handle contains any grids
+    operator bool() const { return !this->empty(); }
+
+    /// @brief Returns a const host pointer to the @a n'th NanoVDB grid encoded in this GridHandle.
+    /// @tparam ValueT Value type of the grid point to be returned
+    /// @param n Index of the (host) grid pointer to be returned
+    /// @warning Note that the return pointer can be NULL if the GridHandle no host grid, @a n is invalid
+    ///          or if the template parameter does not match the specified grid!
+    template<typename ValueT>
+    const NanoGrid<ValueT>* grid(uint32_t n = 0) const;
+
+    /// @brief Returns a host pointer to the @a n'th  NanoVDB grid encoded in this GridHandle.
+    /// @tparam ValueT Value type of the grid point to be returned
+    /// @param n Index of the (host) grid pointer to be returned
+    /// @warning Note that the return pointer can be NULL if the GridHandle no host grid, @a n is invalid
+    ///          or if the template parameter does not match the specified grid!
+    template<typename ValueT>
+    NanoGrid<ValueT>* grid(uint32_t n = 0) {return const_cast<NanoGrid<ValueT>*>(static_cast<const GridHandle*>(this)->template grid<ValueT>(n));}
+
+    /// @brief Return a const pointer to the @a n'th grid encoded in this GridHandle on the device, e.g. GPU
+    /// @tparam ValueT Value type of the grid point to be returned
+    /// @param n Index of the (device) grid pointer to be returned
+    /// @warning Note that the return pointer can be NULL if the GridHandle has no device grid, @a n is invalid,
+    ///          or if the template parameter does not match the specified grid.
+    template<typename ValueT, typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, const NanoGrid<ValueT>*>::type
+    deviceGrid(uint32_t n=0) const;
+
+    /// @brief Return a const pointer to the @a n'th grid encoded in this GridHandle on the device, e.g. GPU
+    /// @tparam ValueT Value type of the grid point to be returned
+    /// @param n Index if of the grid pointer to be returned
+    /// @param verbose if non-zero error messages will be printed in case something failed
+    /// @warning Note that the return pointer can be NULL if the GridHandle was not initialized, @a n is invalid,
+    ///          or if the template parameter does not match the specified grid.
+    template<typename ValueT, typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, NanoGrid<ValueT>*>::type
+    deviceGrid(uint32_t n=0){return const_cast<NanoGrid<ValueT>*>(static_cast<const GridHandle*>(this)->template deviceGrid<ValueT>(n));}
+
+    /// @brief Upload the grid to the device, e.g. from CPU to GPU
+    /// @note This method is only available if the buffer supports devices
+    template<typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, void>::type
+    deviceUpload(void* stream = nullptr, bool sync = true) { mBuffer.deviceUpload(stream, sync); }
+
+    /// @brief Download the grid to from the device, e.g. from GPU to CPU
+    /// @note This method is only available if the buffer supports devices
+    template<typename U = BufferT>
+    typename util::enable_if<BufferTraits<U>::hasDeviceDual, void>::type
+    deviceDownload(void* stream = nullptr, bool sync = true) { mBuffer.deviceDownload(stream, sync); }
+
+    /// @brief Check if the buffer is this handle has any padding, i.e. if the buffer is larger than the combined size of all its grids
+    /// @return true is the combined size of all grid is smaller than the buffer size
+    bool isPadded() const {return mMetaData.empty() ? false : mMetaData.back().offset + mMetaData.back().size != mBuffer.size();}
+
+    /// @brief Return the total number of grids contained in this buffer
+    uint32_t gridCount() const {return static_cast<uint32_t>(mMetaData.size());}
+
+    /// @brief Return the grid size of the @a n'th grid in this GridHandle
+    /// @param n index of the grid (assumed to be less than gridCount())
+    /// @return Return the byte size of the specified grid
+    uint64_t gridSize(uint32_t n = 0) const {return mMetaData[n].size; }
+
+    /// @brief Return the GridType of the @a n'th grid in this GridHandle
+    /// @param n index of the grid (assumed to be less than gridCount())
+    /// @return Return the GridType of the specified grid
+    GridType gridType(uint32_t n = 0) const {return mMetaData[n].gridType; }
+
+    /// @brief Access to the GridData of the n'th grid in the current handle
+    /// @param n zero-based ID of the grid
+    /// @return Const pointer to the n'th GridData in the current handle
+    const GridData* gridData(uint32_t n = 0) const;
+
+    /// @brief Returns a const point to the @a n'th grid meta data
+    /// @param n zero-based ID of the grid
+    /// @warning Note that the return pointer can be NULL if the GridHandle was not initialized
+    const GridMetaData* gridMetaData(uint32_t n = 0) const;
+
+    /// @brief Write a specific grid in this buffer to an output stream
+    /// @param os  output stream that the buffer will be written to
+    /// @param n zero-based index of the grid to be written to stream
+    void write(std::ostream& os, uint32_t n) const {
+        if (const GridData* data = this->gridData(n)) {
+            os.write((const char*)data, data->mGridSize);
+        } else {
+            throw std::runtime_error("GridHandle does not contain a #" + std::to_string(n) + " grid");
+        }
+    }
+
+    /// @brief Write the entire grid buffer to an output stream
+    /// @param os output stream that the buffer will be written to
+    void write(std::ostream& os) const {
+        for (uint32_t n=0; n<this->gridCount(); ++n) this->write(os, n);
+    }
+
+    /// @brief Write this entire grid buffer to a file
+    /// @param fileName string name of the output file
+    void write(const std::string &fileName) const {
+        std::ofstream os(fileName, std::ios::out | std::ios::binary | std::ios::trunc);
+        if (!os.is_open()) throw std::ios_base::failure("Unable to open file named \"" + fileName + "\" for output");
+        this->write(os);
+    }
+
+    /// @brief Write a specific grid to file
+    /// @param fileName string name of the output file
+    /// @param n zero-based index of the grid to be written to file
+    void write(const std::string &fileName, uint32_t n) const {
+        std::ofstream os(fileName, std::ios::out | std::ios::binary | std::ios::trunc);
+        if (!os.is_open()) throw std::ios_base::failure("Unable to open file named \"" + fileName + "\" for output");
+        this->write(os, n);
+    }
+
+    /// @brief Read an entire raw grid buffer from an input stream
+    /// @param is input stream containing a raw grid buffer
+    /// @param pool optional pool from which to allocate the new grid buffer
+    /// @throw Will throw a std::logic_error if the stream does not contain a valid raw grid
+    void read(std::istream& is, const BufferT& pool = BufferT());
+
+    /// @brief Read a specific grid from an input stream containing a raw grid buffer
+    /// @param is input stream containing a raw grid buffer
+    /// @param n zero-based index of the grid to be read
+    /// @param pool optional pool from which to allocate the new grid buffer
+    /// @throw Will throw a std::logic_error if the stream does not contain a valid raw grid
+    void read(std::istream& is, uint32_t n, const BufferT& pool = BufferT());
+
+    /// @brief Read a specific grid from an input stream containing a raw grid buffer
+    /// @param is input stream containing a raw grid buffer
+    /// @param gridName string name of the grid to be read
+    /// @param pool optional pool from which to allocate the new grid buffer
+    /// @throw Will throw a std::logic_error if the stream does not contain a valid raw grid with the speficied name
+    void read(std::istream& is, const std::string &gridName, const BufferT& pool = BufferT());
+
+    /// @brief Read a raw grid buffer from a file
+    /// @param filename string name of the input file containing a raw grid buffer
+    /// @param pool optional pool from which to allocate the new grid buffe
+    void read(const std::string &fileName, const BufferT& pool = BufferT()) {
+        std::ifstream is(fileName, std::ios::in | std::ios::binary);
+        if (!is.is_open()) throw std::ios_base::failure("Unable to open file named \"" + fileName + "\" for input");
+        this->read(is, pool);
+    }
+
+    /// @brief Read a specific grid from a file containing a raw grid buffer
+    /// @param filename string name of the input file containing a raw grid buffer
+    /// @param n zero-based index of the grid to be read
+    /// @param pool optional pool from which to allocate the new grid buffer
+    /// @throw Will throw a std::ios_base::failure if the file does not exist and a
+    ///        std::logic_error if the files does not contain a valid raw grid
+    void read(const std::string &fileName, uint32_t n, const BufferT& pool = BufferT()) {
+        std::ifstream is(fileName, std::ios::in | std::ios::binary);
+        if (!is.is_open()) throw std::ios_base::failure("Unable to open file named \"" + fileName + "\" for input");
+        this->read(is, n, pool);
+    }
+
+    /// @brief Read a specific grid from a file containing a raw grid buffer
+    /// @param filename string name of the input file containing a raw grid buffer
+    /// @param gridName string name of the grid to be read
+    /// @param pool optional pool from which to allocate the new grid buffer
+    /// @throw Will throw a std::ios_base::failure if the file does not exist and a
+    ///        std::logic_error if the files does not contain a valid raw grid withe the specified name
+    void read(const std::string &fileName, const std::string &gridName, const BufferT& pool = BufferT()) {
+        std::ifstream is(fileName, std::ios::in | std::ios::binary);
+        if (!is.is_open()) throw std::ios_base::failure("Unable to open file named \"" + fileName + "\" for input");
+        this->read(is, gridName, pool);
+    }
+}; // GridHandle
+
+// --------------------------> Implementation of private methods in GridHandle <------------------------------------
+
+template<typename BufferT>
+inline const GridData* GridHandle<BufferT>::gridData(uint32_t n) const
+{
+    const void *data = this->data();
+    if (data == nullptr || n >= mMetaData.size()) return nullptr;
+    return util::PtrAdd<GridData>(data, mMetaData[n].offset);
+}// const GridData* GridHandle<BufferT>::gridData(uint32_t n) const
+
+template<typename BufferT>
+inline const GridMetaData* GridHandle<BufferT>::gridMetaData(uint32_t n) const
+{
+    const auto *data = this->data();
+    if (data == nullptr || n >= mMetaData.size()) return nullptr;
+    return util::PtrAdd<GridMetaData>(data, mMetaData[n].offset);
+}// const GridMetaData* GridHandle<BufferT>::gridMetaData(uint32_t n) const
+
+inline __hostdev__ void cpyGridHandleMeta(const GridData *data, GridHandleMetaData *meta)
+{
+    uint64_t offset = 0;
+    for (auto *p=meta, *q=p+data->mGridCount; p!=q; ++p) {
+        *p = {offset,  data->mGridSize, data->mGridType};
+        offset += p->size;
+        data = util::PtrAdd<GridData>(data, p->size);
+    }
+}// void cpyGridHandleMeta(const GridData *data, GridHandleMetaData *meta)
+
+template<typename BufferT>
+template<typename T, typename util::disable_if<BufferTraits<T>::hasDeviceDual, int>::type>
+GridHandle<BufferT>::GridHandle(T&& buffer)
+{
+    static_assert(util::is_same<T,BufferT>::value, "Expected U==BufferT");
+    mBuffer = std::move(buffer);
+    if (auto *data = reinterpret_cast<const GridData*>(mBuffer.data())) {
+        if (!data->isValid()) throw std::runtime_error("GridHandle was constructed with an invalid host buffer");
+        mMetaData.resize(data->mGridCount);
+        cpyGridHandleMeta(data, mMetaData.data());
+    }
+}// GridHandle<BufferT>::GridHandle(T&& buffer)
+
+template<typename BufferT>
+template <typename OtherBufferT>
+inline GridHandle<OtherBufferT> GridHandle<BufferT>::copy(const OtherBufferT& other) const
+{
+    if (mBuffer.isEmpty()) return GridHandle<OtherBufferT>();// return an empty handle
+    auto buffer = OtherBufferT::create(mBuffer.size(), &other);
+    std::memcpy(buffer.data(), mBuffer.data(), mBuffer.size());// deep copy of buffer
+    return GridHandle<OtherBufferT>(std::move(buffer));
+}// GridHandle<OtherBufferT> GridHandle<BufferT>::copy(const OtherBufferT& other) const
+
+template<typename BufferT>
+template<typename ValueT>
+inline const NanoGrid<ValueT>* GridHandle<BufferT>::grid(uint32_t n) const
+{
+    const void *data = mBuffer.data();
+    if (data == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
+    return util::PtrAdd<NanoGrid<ValueT>>(data, mMetaData[n].offset);
+}// const NanoGrid<ValueT>* GridHandle<BufferT>::grid(uint32_t n) const
+
+template<typename BufferT>
+template<typename ValueT, typename U>
+inline typename util::enable_if<BufferTraits<U>::hasDeviceDual, const NanoGrid<ValueT>*>::type
+GridHandle<BufferT>::deviceGrid(uint32_t n) const
+{
+    const void *data = mBuffer.deviceData();
+    if (data == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
+    return util::PtrAdd<NanoGrid<ValueT>>(data, mMetaData[n].offset);
+}// GridHandle<BufferT>::deviceGrid(uint32_t n) cons
+
+
+} // namespace nanovdb
+
+#if defined(__CUDACC__)
+#include <nanovdb/cuda/GridHandle.cuh>
+#endif// defined(__CUDACC__)
+
+#endif // NANOVDB_GRID_HANDLE_H_HAS_BEEN_INCLUDED