warp-lang 1.5.1__py3-none-macosx_10_13_universal2.whl → 1.6.1__py3-none-macosx_10_13_universal2.whl

warp/native/bvh.h

@@ -11,6 +11,14 @@
 #include "builtin.h"
 #include "intersect.h"
 
+#define BVH_LEAF_SIZE (4)
+#define SAH_NUM_BUCKETS (16)
+#define USE_LOAD4
+
+#define BVH_CONSTRUCTOR_SAH (0)
+#define BVH_CONSTRUCTOR_MEDIAN (1)
+#define BVH_CONSTRUCTOR_LBVH (2)
+
 namespace wp
 {
 
@@ -72,12 +80,38 @@ struct bounds3
 		}
 	}
 
+	CUDA_CALLABLE inline bool overlaps(const vec3& b_lower, const vec3& b_upper) const
+	{
+		if (lower[0] > b_upper[0] ||
+			lower[1] > b_upper[1] ||
+			lower[2] > b_upper[2] ||
+			upper[0] < b_lower[0] ||
+			upper[1] < b_lower[1] ||
+			upper[2] < b_lower[2])
+		{
+			return false;
+		}
+		else
+		{
+			return true;
+		}
+	}
+
 	CUDA_CALLABLE inline void add_point(const vec3& p)
 	{
 		lower = min(lower, p);
 		upper = max(upper, p);
 	}
 
+	CUDA_CALLABLE inline void add_bounds(const vec3& lower_other, const vec3& upper_other)
+	{
+		// lower_other will only impact the lower of the new bounds
+		// upper_other will only impact the upper of the new bounds
+		// this costs only half of the computation of adding lower_other and upper_other separately
+		lower = min(lower, lower_other);
+		upper = max(upper, upper_other);
+	}
+
 	CUDA_CALLABLE inline float area() const
 	{
 		vec3 e = upper-lower;
@@ -108,6 +142,13 @@ struct BVHPackedNodeHalf
 	float x;
 	float y;
 	float z;
+	// For non-leaf nodes:
+	// - 'lower.i' represents the index of the left child node.
+	// - 'upper.i' represents the index of the right child node.
+	//
+	// For leaf nodes:
+	// - 'lower.i' indicates the start index of the primitives in 'primitive_indices'.
+	// - 'upper.i' indicates the index just after the last primitive in 'primitive_indices'
 	unsigned int i : 31;
 	unsigned int b : 1;
 };
@@ -120,11 +161,15 @@ struct BVH
 	// used for fast refits
 	int* node_parents;
 	int* node_counts;
+	// reordered primitive indices corresponds to the ordering of leaf nodes
+	int* primitive_indices;
 	
 	int max_depth;
 	int max_nodes;
 	int num_nodes;
-	
+	// since we use packed leaf nodes, the number of them is no longer the number of items, but variable
+	int num_leaf_nodes;
+
 	// pointer (CPU or GPU) to a single integer index in node_lowers, node_uppers
 	// representing the root of the tree, this is not always the first node
 	// for bottom-up builders
@@ -161,6 +206,24 @@ CUDA_CALLABLE inline void make_node(volatile BVHPackedNodeHalf* n, const vec3& b
     n->b = (unsigned int)(leaf?1:0);
 }
 
+#ifdef __CUDA_ARCH__
+__device__ inline wp::BVHPackedNodeHalf bvh_load_node(const wp::BVHPackedNodeHalf* nodes, int index)
+{
+#ifdef USE_LOAD4
+	//return  (const wp::BVHPackedNodeHalf&)(__ldg((const float4*)(nodes)+index));
+	return  (const wp::BVHPackedNodeHalf&)(*((const float4*)(nodes)+index));
+#else
+	return  nodes[index];
+#endif // USE_LOAD4
+
+}
+#else
+inline wp::BVHPackedNodeHalf bvh_load_node(const wp::BVHPackedNodeHalf* nodes, int index)
+{
+	return  nodes[index];
+}
+#endif // __CUDACC__
+
 CUDA_CALLABLE inline int clz(int x)
 {
     int n;
@@ -215,7 +278,8 @@ struct bvh_query_t
           is_ray(false),
           input_lower(),
           input_upper(),
-          bounds_nr(0)
+          bounds_nr(0),
+		  primitive_counter(-1)
     {}
 
     // Required for adjoint computations.
@@ -230,22 +294,37 @@ struct bvh_query_t
 	int stack[32];
 	int count;
 
+	// >= 0 if currently in a packed leaf node
+	int primitive_counter;
+	
     // inputs
-	bool is_ray;
     wp::vec3 input_lower;	// start for ray
     wp::vec3 input_upper;	// dir for ray
 
 	int bounds_nr;
+	bool is_ray;
 };
 
+CUDA_CALLABLE inline bool bvh_query_intersection_test(const bvh_query_t& query, const vec3& node_lower, const vec3& node_upper)
+{
+	if (query.is_ray)
+	{
+		float t = 0.0f;
+		return intersect_ray_aabb(query.input_lower, query.input_upper, node_lower, node_upper, t);
+	}
+	else
+	{
+		return intersect_aabb_aabb(query.input_lower, query.input_upper, node_lower, node_upper);
+	}
+}
 
 CUDA_CALLABLE inline bvh_query_t bvh_query(
-    uint64_t id, bool is_ray, const vec3& lower, const vec3& upper)
+	uint64_t id, bool is_ray, const vec3& lower, const vec3& upper)
 {
-    // This routine traverses the BVH tree until it finds
+	// This routine traverses the BVH tree until it finds
 	// the first overlapping bound. 
 
-    // initialize empty
+	// initialize empty
 	bvh_query_t query;
 
 	query.bounds_nr = -1;
@@ -255,57 +334,41 @@ CUDA_CALLABLE inline bvh_query_t bvh_query(
 	query.bvh = bvh;
 	query.is_ray = is_ray;
 
-    // optimization: make the latest	
+	// optimization: make the latest	
 	query.stack[0] = *bvh.root;
 	query.count = 1;
-    query.input_lower = lower;
-    query.input_upper = upper;
+	query.input_lower = lower;
+	query.input_upper = upper;
 
-    wp::bounds3 input_bounds(query.input_lower, query.input_upper);
-
-    // Navigate through the bvh, find the first overlapping leaf node.
-    while (query.count)
-    {
+	// Navigate through the bvh, find the first overlapping leaf node.
+	while (query.count)
+	{
 		const int node_index = query.stack[--query.count];
+		BVHPackedNodeHalf node_lower = bvh_load_node(bvh.node_lowers, node_index);
+		BVHPackedNodeHalf node_upper = bvh_load_node(bvh.node_uppers, node_index);
 
-		BVHPackedNodeHalf node_lower = bvh.node_lowers[node_index];
-		BVHPackedNodeHalf node_upper = bvh.node_uppers[node_index];
-
-		wp::vec3 lower_pos(node_lower.x, node_lower.y, node_lower.z);
-		wp::vec3 upper_pos(node_upper.x, node_upper.y, node_upper.z);
-        wp::bounds3 current_bounds(lower_pos, upper_pos);
-
-		if (query.is_ray) 
-		{
-			float t = 0.0f;
-			if (!intersect_ray_aabb(query.input_lower, query.input_upper, current_bounds.lower, current_bounds.upper, t))
-			// Skip this box, it doesn't overlap with our ray.
-				continue;
-		}
-		else 
+		if (!bvh_query_intersection_test(query, (vec3&)node_lower, (vec3&)node_upper))
 		{
-	        if (!input_bounds.overlaps(current_bounds))
-				// Skip this box, it doesn't overlap with our target box.
-				continue;
+			continue;
 		}
 
 		const int left_index = node_lower.i;
 		const int right_index = node_upper.i;
-
-        // Make bounds from this AABB
-        if (node_lower.b)
-        {
-			// found very first leaf index.
+		// Make bounds from this AABB
+		if (node_lower.b)
+		{
+			// Reached a leaf node, point to its first primitive
 			// Back up one level and return 
+			query.primitive_counter = left_index;
 			query.stack[query.count++] = node_index;
 			return query;
-        }
-        else
-        {	
-		  query.stack[query.count++] = left_index;
-		  query.stack[query.count++] = right_index;
 		}
-	}	
+		else
+		{
+			query.stack[query.count++] = left_index;
+			query.stack[query.count++] = right_index;
+		}
+	}
 
 	return query;
 }
@@ -338,52 +401,100 @@ CUDA_CALLABLE inline void adj_bvh_query_ray(uint64_t id, const vec3& start, cons
 
 CUDA_CALLABLE inline bool bvh_query_next(bvh_query_t& query, int& index)
 {
-    BVH bvh = query.bvh;
-	
-	wp::bounds3 input_bounds(query.input_lower, query.input_upper);
-
-    // Navigate through the bvh, find the first overlapping leaf node.
-    while (query.count)
-    {
-        const int node_index = query.stack[--query.count];
-        BVHPackedNodeHalf node_lower = bvh.node_lowers[node_index];
-        BVHPackedNodeHalf node_upper = bvh.node_uppers[node_index];
+	BVH bvh = query.bvh;
 
-        wp::vec3 lower_pos(node_lower.x, node_lower.y, node_lower.z);
-        wp::vec3 upper_pos(node_upper.x, node_upper.y, node_upper.z);
-        wp::bounds3 current_bounds(lower_pos, upper_pos);
+	if (query.primitive_counter != -1)
+		// currently in a leaf node which is the last node in the stack
+	{
+		const int node_index = query.stack[query.count - 1];
+		BVHPackedNodeHalf node_lower = bvh_load_node(bvh.node_lowers, node_index);
+		BVHPackedNodeHalf node_upper = bvh_load_node(bvh.node_uppers, node_index);
 
-		if (query.is_ray) 
+		const int end = node_upper.i;
+		for (int primitive_counter = query.primitive_counter; primitive_counter < end; primitive_counter++)
 		{
-			float t = 0.0f;
-			if (!intersect_ray_aabb(query.input_lower, query.input_upper, current_bounds.lower, current_bounds.upper, t))
-			// Skip this box, it doesn't overlap with our ray.
-				continue;
+			int primitive_index = bvh.primitive_indices[primitive_counter];
+			if (bvh_query_intersection_test(query, bvh.item_lowers[primitive_index], bvh.item_uppers[primitive_index]))
+			{
+				if (primitive_counter < end - 1)
+					// still need to come back to this leaf node for the leftover primitives
+				{
+					query.primitive_counter = primitive_counter + 1;
+				}
+				else
+					// no need to come back to this leaf node
+				{
+					query.count--;
+					query.primitive_counter = -1;
+				}
+				index = primitive_index;
+				query.bounds_nr = primitive_index;
+
+				return true;
+			}
 		}
-		else {
-	        if (!input_bounds.overlaps(current_bounds))
-				// Skip this box, it doesn't overlap with our target box.
-				continue;
+		// if we reach here that means we have finished the current leaf node without finding intersections
+		query.primitive_counter = -1;
+		// remove the leaf node from the back of the stack because it is finished
+		// and continue the bvh traversal
+		query.count--;
+	}
+
+	// Navigate through the bvh, find the first overlapping leaf node.
+	while (query.count)
+	{
+		const int node_index = query.stack[--query.count];
+		BVHPackedNodeHalf node_lower = bvh_load_node(bvh.node_lowers, node_index);
+		BVHPackedNodeHalf node_upper = bvh_load_node(bvh.node_uppers, node_index);
+
+		const int left_index = node_lower.i;
+		const int right_index = node_upper.i;
+
+		wp::vec3 lower_pos(node_lower.x, node_lower.y, node_lower.z);
+		wp::vec3 upper_pos(node_upper.x, node_upper.y, node_upper.z);
+		wp::bounds3 current_bounds(lower_pos, upper_pos);
+
+		if (!bvh_query_intersection_test(query, (vec3&)node_lower, (vec3&)node_upper))
+		{
+			continue;
 		}
 
-        const int left_index = node_lower.i;
-        const int right_index = node_upper.i;
-
-        if (node_lower.b)
-        {
-            // found leaf
-            query.bounds_nr = left_index;
-			index = left_index;
-            return true;
-        }
-        else
-        {
-
-            query.stack[query.count++] = left_index;
-            query.stack[query.count++] = right_index;
-        }
-    }
-    return false;
+		if (node_lower.b)
+		{
+			// found leaf, loop through its content primitives
+			const int start = left_index;
+			const int end = right_index;
+
+			for (int primitive_counter = start; primitive_counter < end; primitive_counter++)
+			{
+				int primitive_index = bvh.primitive_indices[primitive_counter];
+				if (bvh_query_intersection_test(query, bvh.item_lowers[primitive_index], bvh.item_uppers[primitive_index]))
+				{
+					if (primitive_counter < end - 1)
+						// still need to come back to this leaf node for the leftover primitives
+					{
+						query.primitive_counter = primitive_counter + 1;
+						query.stack[query.count++] = node_index;
+					}
+					else
+						// no need to come back to this leaf node
+					{
+						query.primitive_counter = -1;
+					}
+					index = primitive_index;
+					query.bounds_nr = primitive_index;
+
+					return true;
+				}
+			}
+		}
+		else
+		{
+			query.stack[query.count++] = left_index;
+			query.stack[query.count++] = right_index;
+		}
+	}
+	return false;
 }
 
 
@@ -421,7 +532,7 @@ CUDA_CALLABLE void bvh_rem_descriptor(uint64_t id);
 
 #if !__CUDA_ARCH__
 
-void bvh_create_host(vec3* lowers, vec3* uppers, int num_items, BVH& bvh);
+void bvh_create_host(vec3* lowers, vec3* uppers, int num_items,  int constructor_type, BVH& bvh);
 void bvh_destroy_host(wp::BVH& bvh);
 void bvh_refit_host(wp::BVH& bvh);
 
@@ -431,4 +542,3 @@ void bvh_refit_device(uint64_t id);
 #endif
 
 } // namespace wp
-

warp/native/clang/clang.cpp

@@ -218,7 +218,7 @@ static std::unique_ptr<llvm::Module> cuda_to_llvm(const std::string& input_file,
 
 extern "C" {
 
-WP_API int compile_cpp(const char* cpp_src, const char *input_file, const char* include_dir, const char* output_file, bool debug, bool verify_fp)
+WP_API int compile_cpp(const char* cpp_src, const char *input_file, const char* include_dir, const char* output_file, bool debug, bool verify_fp, bool fuse_fp)
 {
     initialize_llvm();
 
@@ -236,6 +236,10 @@ WP_API int compile_cpp(const char* cpp_src, const char *input_file, const char*
     const char* CPU = "generic";
     const char* features = "";
     llvm::TargetOptions target_options;
+    if (fuse_fp)
+        target_options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
+    else
+        target_options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
     llvm::Reloc::Model relocation_model = llvm::Reloc::PIC_;  // Position Independent Code
     llvm::CodeModel::Model code_model = llvm::CodeModel::Large;  // Don't make assumptions about displacement sizes
     llvm::TargetMachine* target_machine = target->createTargetMachine(target_triple, CPU, features, target_options, relocation_model, code_model);
@@ -409,7 +413,7 @@ WP_API int load_obj(const char* object_file, const char* module_name)
             SYMBOL(sinhf), SYMBOL_T(sinh, double(*)(double)),
             SYMBOL(coshf), SYMBOL_T(cosh, double(*)(double)),
             SYMBOL(tanhf), SYMBOL_T(tanh, double(*)(double)),
-            SYMBOL(fmaf),
+            SYMBOL(fmaf), SYMBOL_T(fma, double(*)(double, double, double)),
             SYMBOL(memcpy), SYMBOL(memset), SYMBOL(memmove),
             SYMBOL(_wp_assert),
             SYMBOL(_wp_isfinite),

warp/native/crt.h

@@ -303,6 +303,7 @@ double cosh(double);
 float tanhf(float);
 double tanh(double);
 float fmaf(float, float, float);
+double fma(double, double, double);
 
 // stddef.h
 #if defined(_WIN32)

warp/native/cuda_util.cpp

@@ -102,6 +102,11 @@ static PFN_cuGraphicsGLRegisterBuffer_v3000 pfn_cuGraphicsGLRegisterBuffer;
 static PFN_cuGraphicsUnregisterResource_v3000 pfn_cuGraphicsUnregisterResource;
 static PFN_cuModuleGetGlobal_v3020 pfn_cuModuleGetGlobal;
 static PFN_cuFuncSetAttribute_v9000 pfn_cuFuncSetAttribute;
+static PFN_cuIpcGetEventHandle_v4010 pfn_cuIpcGetEventHandle;
+static PFN_cuIpcOpenEventHandle_v4010 pfn_cuIpcOpenEventHandle;
+static PFN_cuIpcGetMemHandle_v4010 pfn_cuIpcGetMemHandle;
+static PFN_cuIpcOpenMemHandle_v11000 pfn_cuIpcOpenMemHandle;
+static PFN_cuIpcCloseMemHandle_v4010 pfn_cuIpcCloseMemHandle;
 
 static bool cuda_driver_initialized = false;
 
@@ -238,6 +243,11 @@ bool init_cuda_driver()
     get_driver_entry_point("cuGraphicsUnregisterResource", 3000, &(void*&)pfn_cuGraphicsUnregisterResource);
     get_driver_entry_point("cuModuleGetGlobal", 3020, &(void*&)pfn_cuModuleGetGlobal);
     get_driver_entry_point("cuFuncSetAttribute", 9000, &(void*&)pfn_cuFuncSetAttribute);
+    get_driver_entry_point("cuIpcGetEventHandle", 4010, &(void*&)pfn_cuIpcGetEventHandle);
+    get_driver_entry_point("cuIpcOpenEventHandle", 4010, &(void*&)pfn_cuIpcOpenEventHandle);
+    get_driver_entry_point("cuIpcGetMemHandle", 4010, &(void*&)pfn_cuIpcGetMemHandle);
+    get_driver_entry_point("cuIpcOpenMemHandle", 11000, &(void*&)pfn_cuIpcOpenMemHandle);
+    get_driver_entry_point("cuIpcCloseMemHandle", 4010, &(void*&)pfn_cuIpcCloseMemHandle);
 
     if (pfn_cuInit)
         cuda_driver_initialized = check_cu(pfn_cuInit(0));
@@ -585,4 +595,29 @@ CUresult cuFuncSetAttribute_f(CUfunction hfunc, CUfunction_attribute attrib, int
     return pfn_cuFuncSetAttribute ? pfn_cuFuncSetAttribute(hfunc, attrib, value) : DRIVER_ENTRY_POINT_ERROR;
 }
 
+CUresult cuIpcGetEventHandle_f(CUipcEventHandle *pHandle, CUevent event)
+{
+    return pfn_cuIpcGetEventHandle ? pfn_cuIpcGetEventHandle(pHandle, event) : DRIVER_ENTRY_POINT_ERROR;
+}
+
+CUresult cuIpcOpenEventHandle_f(CUevent *phEvent, CUipcEventHandle handle)
+{
+    return pfn_cuIpcOpenEventHandle ? pfn_cuIpcOpenEventHandle(phEvent, handle) : DRIVER_ENTRY_POINT_ERROR;
+}
+
+CUresult cuIpcGetMemHandle_f(CUipcMemHandle *pHandle, CUdeviceptr dptr)
+{
+    return pfn_cuIpcGetMemHandle ? pfn_cuIpcGetMemHandle(pHandle, dptr) : DRIVER_ENTRY_POINT_ERROR;
+}
+
+CUresult cuIpcOpenMemHandle_f(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int flags)
+{
+    return pfn_cuIpcOpenMemHandle ? pfn_cuIpcOpenMemHandle(pdptr, handle, flags) : DRIVER_ENTRY_POINT_ERROR;
+}
+
+CUresult cuIpcCloseMemHandle_f(CUdeviceptr dptr)
+{
+    return pfn_cuIpcCloseMemHandle ? pfn_cuIpcCloseMemHandle(dptr) : DRIVER_ENTRY_POINT_ERROR;
+}
+
 #endif // WP_ENABLE_CUDA

warp/native/cuda_util.h

@@ -101,6 +101,11 @@ CUresult cuGraphicsGLRegisterBuffer_f(CUgraphicsResource *pCudaResource, unsigne
 CUresult cuGraphicsUnregisterResource_f(CUgraphicsResource resource);
 CUresult cuModuleGetGlobal_f(CUdeviceptr* dptr, size_t* bytes, CUmodule hmod, const char* name );
 CUresult cuFuncSetAttribute_f(CUfunction hfunc, CUfunction_attribute attrib, int value);
+CUresult cuIpcGetEventHandle_f(CUipcEventHandle *pHandle, CUevent event);
+CUresult cuIpcOpenEventHandle_f(CUevent *phEvent, CUipcEventHandle handle);
+CUresult cuIpcGetMemHandle_f(CUipcMemHandle *pHandle, CUdeviceptr dptr);
+CUresult cuIpcOpenMemHandle_f(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int flags);
+CUresult cuIpcCloseMemHandle_f(CUdeviceptr dptr);
 
 bool init_cuda_driver();
 bool is_cuda_driver_initialized();

warp/native/exports.h

@@ -1001,46 +1001,6 @@ WP_API void builtin_spatial_top_spatial_vectord(spatial_vectord& svec, vec3d* re
 WP_API void builtin_spatial_bottom_spatial_vectorh(spatial_vectorh& svec, vec3h* ret) { *ret = wp::spatial_bottom(svec); }
 WP_API void builtin_spatial_bottom_spatial_vectorf(spatial_vectorf& svec, vec3f* ret) { *ret = wp::spatial_bottom(svec); }
 WP_API void builtin_spatial_bottom_spatial_vectord(spatial_vectord& svec, vec3d* ret) { *ret = wp::spatial_bottom(svec); }
-WP_API void builtin_volume_sample_f_uint64_vec3f_int32(uint64 id, vec3f& uvw, int32 sampling_mode, float* ret) { *ret = wp::volume_sample_f(id, uvw, sampling_mode); }
-WP_API void builtin_volume_sample_grad_f_uint64_vec3f_int32_vec3f(uint64 id, vec3f& uvw, int32 sampling_mode, vec3f& grad, float* ret) { *ret = wp::volume_sample_grad_f(id, uvw, sampling_mode, grad); }
-WP_API void builtin_volume_lookup_f_uint64_int32_int32_int32(uint64 id, int32 i, int32 j, int32 k, float* ret) { *ret = wp::volume_lookup_f(id, i, j, k); }
-WP_API void builtin_volume_sample_v_uint64_vec3f_int32(uint64 id, vec3f& uvw, int32 sampling_mode, vec3f* ret) { *ret = wp::volume_sample_v(id, uvw, sampling_mode); }
-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); }
-WP_API void builtin_volume_world_to_index_dir_uint64_vec3f(uint64 id, vec3f& xyz, vec3f* ret) { *ret = wp::volume_world_to_index_dir(id, xyz); }
-WP_API void builtin_rand_init_int32(int32 seed, uint32* ret) { *ret = wp::rand_init(seed); }
-WP_API void builtin_rand_init_int32_int32(int32 seed, int32 offset, uint32* ret) { *ret = wp::rand_init(seed, offset); }
-WP_API void builtin_randi_uint32(uint32 state, int* ret) { *ret = wp::randi(state); }
-WP_API void builtin_randi_uint32_int32_int32(uint32 state, int32 low, int32 high, int* ret) { *ret = wp::randi(state, low, high); }
-WP_API void builtin_randf_uint32(uint32 state, float* ret) { *ret = wp::randf(state); }
-WP_API void builtin_randf_uint32_float32_float32(uint32 state, float32 low, float32 high, float* ret) { *ret = wp::randf(state, low, high); }
-WP_API void builtin_randn_uint32(uint32 state, float* ret) { *ret = wp::randn(state); }
-WP_API void builtin_sample_triangle_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_triangle(state); }
-WP_API void builtin_sample_unit_ring_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_ring(state); }
-WP_API void builtin_sample_unit_disk_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_disk(state); }
-WP_API void builtin_sample_unit_sphere_surface_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_sphere_surface(state); }
-WP_API void builtin_sample_unit_sphere_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_sphere(state); }
-WP_API void builtin_sample_unit_hemisphere_surface_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_hemisphere_surface(state); }
-WP_API void builtin_sample_unit_hemisphere_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_hemisphere(state); }
-WP_API void builtin_sample_unit_square_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_square(state); }
-WP_API void builtin_sample_unit_cube_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_cube(state); }
-WP_API void builtin_poisson_uint32_float32(uint32 state, float32 lam, uint32* ret) { *ret = wp::poisson(state, lam); }
-WP_API void builtin_noise_uint32_float32(uint32 state, float32 x, float* ret) { *ret = wp::noise(state, x); }
-WP_API void builtin_noise_uint32_vec2f(uint32 state, vec2f& xy, float* ret) { *ret = wp::noise(state, xy); }
-WP_API void builtin_noise_uint32_vec3f(uint32 state, vec3f& xyz, float* ret) { *ret = wp::noise(state, xyz); }
-WP_API void builtin_noise_uint32_vec4f(uint32 state, vec4f& xyzt, float* ret) { *ret = wp::noise(state, xyzt); }
-WP_API void builtin_pnoise_uint32_float32_int32(uint32 state, float32 x, int32 px, float* ret) { *ret = wp::pnoise(state, x, px); }
-WP_API void builtin_pnoise_uint32_vec2f_int32_int32(uint32 state, vec2f& xy, int32 px, int32 py, float* ret) { *ret = wp::pnoise(state, xy, px, py); }
-WP_API void builtin_pnoise_uint32_vec3f_int32_int32_int32(uint32 state, vec3f& xyz, int32 px, int32 py, int32 pz, float* ret) { *ret = wp::pnoise(state, xyz, px, py, pz); }
-WP_API void builtin_pnoise_uint32_vec4f_int32_int32_int32_int32(uint32 state, vec4f& xyzt, int32 px, int32 py, int32 pz, int32 pt, float* ret) { *ret = wp::pnoise(state, xyzt, px, py, pz, pt); }
-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_assign_vec2h_int32_float16(vec2h& a, int32 i, float16 value, vec2h* ret) { *ret = wp::assign(a, i, value); }
 WP_API void builtin_assign_vec3h_int32_float16(vec3h& a, int32 i, float16 value, vec3h* ret) { *ret = wp::assign(a, i, value); }
 WP_API void builtin_assign_vec4h_int32_float16(vec4h& a, int32 i, float16 value, vec4h* ret) { *ret = wp::assign(a, i, value); }
@@ -1104,6 +1064,46 @@ WP_API void builtin_assign_mat22d_int32_vec2d(mat22d& a, int32 i, vec2d& value,
 WP_API void builtin_assign_mat33d_int32_vec3d(mat33d& a, int32 i, vec3d& value, mat33d* ret) { *ret = wp::assign(a, i, value); }
 WP_API void builtin_assign_mat44d_int32_vec4d(mat44d& a, int32 i, vec4d& value, mat44d* ret) { *ret = wp::assign(a, i, value); }
 WP_API void builtin_assign_spatial_matrixd_int32_spatial_vectord(spatial_matrixd& a, int32 i, spatial_vectord& value, spatial_matrixd* ret) { *ret = wp::assign(a, i, value); }
+WP_API void builtin_volume_sample_f_uint64_vec3f_int32(uint64 id, vec3f& uvw, int32 sampling_mode, float* ret) { *ret = wp::volume_sample_f(id, uvw, sampling_mode); }
+WP_API void builtin_volume_sample_grad_f_uint64_vec3f_int32_vec3f(uint64 id, vec3f& uvw, int32 sampling_mode, vec3f& grad, float* ret) { *ret = wp::volume_sample_grad_f(id, uvw, sampling_mode, grad); }
+WP_API void builtin_volume_lookup_f_uint64_int32_int32_int32(uint64 id, int32 i, int32 j, int32 k, float* ret) { *ret = wp::volume_lookup_f(id, i, j, k); }
+WP_API void builtin_volume_sample_v_uint64_vec3f_int32(uint64 id, vec3f& uvw, int32 sampling_mode, vec3f* ret) { *ret = wp::volume_sample_v(id, uvw, sampling_mode); }
+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); }
+WP_API void builtin_volume_world_to_index_dir_uint64_vec3f(uint64 id, vec3f& xyz, vec3f* ret) { *ret = wp::volume_world_to_index_dir(id, xyz); }
+WP_API void builtin_rand_init_int32(int32 seed, uint32* ret) { *ret = wp::rand_init(seed); }
+WP_API void builtin_rand_init_int32_int32(int32 seed, int32 offset, uint32* ret) { *ret = wp::rand_init(seed, offset); }
+WP_API void builtin_randi_uint32(uint32 state, int* ret) { *ret = wp::randi(state); }
+WP_API void builtin_randi_uint32_int32_int32(uint32 state, int32 low, int32 high, int* ret) { *ret = wp::randi(state, low, high); }
+WP_API void builtin_randf_uint32(uint32 state, float* ret) { *ret = wp::randf(state); }
+WP_API void builtin_randf_uint32_float32_float32(uint32 state, float32 low, float32 high, float* ret) { *ret = wp::randf(state, low, high); }
+WP_API void builtin_randn_uint32(uint32 state, float* ret) { *ret = wp::randn(state); }
+WP_API void builtin_sample_triangle_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_triangle(state); }
+WP_API void builtin_sample_unit_ring_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_ring(state); }
+WP_API void builtin_sample_unit_disk_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_disk(state); }
+WP_API void builtin_sample_unit_sphere_surface_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_sphere_surface(state); }
+WP_API void builtin_sample_unit_sphere_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_sphere(state); }
+WP_API void builtin_sample_unit_hemisphere_surface_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_hemisphere_surface(state); }
+WP_API void builtin_sample_unit_hemisphere_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_hemisphere(state); }
+WP_API void builtin_sample_unit_square_uint32(uint32 state, vec2f* ret) { *ret = wp::sample_unit_square(state); }
+WP_API void builtin_sample_unit_cube_uint32(uint32 state, vec3f* ret) { *ret = wp::sample_unit_cube(state); }
+WP_API void builtin_poisson_uint32_float32(uint32 state, float32 lam, uint32* ret) { *ret = wp::poisson(state, lam); }
+WP_API void builtin_noise_uint32_float32(uint32 state, float32 x, float* ret) { *ret = wp::noise(state, x); }
+WP_API void builtin_noise_uint32_vec2f(uint32 state, vec2f& xy, float* ret) { *ret = wp::noise(state, xy); }
+WP_API void builtin_noise_uint32_vec3f(uint32 state, vec3f& xyz, float* ret) { *ret = wp::noise(state, xyz); }
+WP_API void builtin_noise_uint32_vec4f(uint32 state, vec4f& xyzt, float* ret) { *ret = wp::noise(state, xyzt); }
+WP_API void builtin_pnoise_uint32_float32_int32(uint32 state, float32 x, int32 px, float* ret) { *ret = wp::pnoise(state, x, px); }
+WP_API void builtin_pnoise_uint32_vec2f_int32_int32(uint32 state, vec2f& xy, int32 px, int32 py, float* ret) { *ret = wp::pnoise(state, xy, px, py); }
+WP_API void builtin_pnoise_uint32_vec3f_int32_int32_int32(uint32 state, vec3f& xyz, int32 px, int32 py, int32 pz, float* ret) { *ret = wp::pnoise(state, xyz, px, py, pz); }
+WP_API void builtin_pnoise_uint32_vec4f_int32_int32_int32_int32(uint32 state, vec4f& xyzt, int32 px, int32 py, int32 pz, int32 pt, float* ret) { *ret = wp::pnoise(state, xyzt, px, py, pz, pt); }
+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_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); }

warp/native/intersect.h

@@ -156,6 +156,23 @@ CUDA_CALLABLE inline bool intersect_ray_aabb(const vec3& pos, const vec3& rcp_di
     return hit;
 }
 
+CUDA_CALLABLE inline bool intersect_aabb_aabb(const vec3& a_lower, const vec3& a_upper, const vec3& b_lower, const vec3& b_upper)
+{
+    if (a_lower[0] > b_upper[0] ||
+        a_lower[1] > b_upper[1] ||
+        a_lower[2] > b_upper[2] ||
+        a_upper[0] < b_lower[0] ||
+        a_upper[1] < b_lower[1] ||
+        a_upper[2] < b_lower[2])
+    {
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
 
 // Moller and Trumbore's method
 CUDA_CALLABLE inline bool intersect_ray_tri_moller(const vec3& p, const vec3& dir, const vec3& a, const vec3& b, const vec3& c, float& t, float& u, float& v, float& w, float& sign, vec3* normal)