warp-lang 0.10.1__py3-none-win_amd64.whl → 0.11.0__py3-none-win_amd64.whl

warp/native/mesh.cpp

@@ -103,7 +103,8 @@ uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities
 {
     Mesh* m = new Mesh(points, velocities, indices, num_points, num_tris);
 
-    m->bounds = new bounds3[num_tris];
+    m->lowers = new vec3[num_tris];
+    m->uppers = new vec3[num_tris];
 
     float sum = 0.0;
     for (int i=0; i < num_tris; ++i)
@@ -111,15 +112,23 @@ uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities
         wp::vec3& p0 = points[indices[i*3+0]];
         wp::vec3& p1 = points[indices[i*3+1]];
         wp::vec3& p2 = points[indices[i*3+2]];
-        m->bounds[i].add_point(p0);
-        m->bounds[i].add_point(p1);
-        m->bounds[i].add_point(p2);
+        
+        // compute triangle bounds
+        bounds3 b;       
+        b.add_point(p0);
+        b.add_point(p1);
+        b.add_point(p2);
+
+        m->lowers[i] = b.lower;
+        m->uppers[i] = b.upper;
+
+        // compute edge lengths
         sum += length(p0-p1) + length(p0-p2) + length(p2-p1);
     }
     m->average_edge_length = sum / (num_tris*3);
 
-    m->bvh = bvh_create(m->bounds, num_tris);
-
+    m->bvh = *(wp::BVH*)bvh_create_host(m->lowers, m->uppers, num_tris);
+    
     if (support_winding_number) 
     {
         // Let's first compute the sold
@@ -131,86 +140,14 @@ uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities
     return (uint64_t)m;
 }
 
-uint64_t mesh_create_device(void* context, array_t<wp::vec3> points, array_t<wp::vec3> velocities, array_t<int> indices, int num_points, int num_tris, int support_winding_number)
-{
-    ContextGuard guard(context);
-
-    Mesh mesh(points, velocities, indices, num_points, num_tris);
-
-    mesh.context = context ? context : cuda_context_get_current();
-
-    // mesh.points = array_t<vec3>(points, num_points, points_grad);
-    // mesh.velocities = array_t<vec3>(velocities, num_points, velocities_grad);
-    // mesh.indices = array_t<int>(indices, num_tris, 3);
-
-    // mesh.num_points = num_points;
-    // mesh.num_tris = num_tris;
-
-    {
-        // todo: BVH creation only on CPU at the moment so temporarily bring all the data back to host
-        vec3* points_host = (vec3*)alloc_host(sizeof(vec3)*num_points);
-        int* indices_host = (int*)alloc_host(sizeof(int)*num_tris*3);
-        bounds3* bounds_host = (bounds3*)alloc_host(sizeof(bounds3)*num_tris);
-
-        memcpy_d2h(WP_CURRENT_CONTEXT, points_host, points, sizeof(vec3)*num_points);
-        memcpy_d2h(WP_CURRENT_CONTEXT, indices_host, indices, sizeof(int)*num_tris*3);
-        cuda_context_synchronize(WP_CURRENT_CONTEXT);
-
-        float sum = 0.0;
-        for (int i=0; i < num_tris; ++i)
-        {
-            bounds_host[i] = bounds3();
-            wp::vec3 p0 = points_host[indices_host[i*3+0]];
-            wp::vec3 p1 = points_host[indices_host[i*3+1]];
-            wp::vec3 p2 = points_host[indices_host[i*3+2]];
-            bounds_host[i].add_point(p0);
-            bounds_host[i].add_point(p1);
-            bounds_host[i].add_point(p2);
-            sum += length(p0-p1) + length(p0-p2) + length(p2-p1);
-        }
-        mesh.average_edge_length = sum / (num_tris*3);
-
-        BVH bvh_host = bvh_create(bounds_host, num_tris);
-        BVH bvh_device = bvh_clone(WP_CURRENT_CONTEXT, bvh_host);
-
-        bvh_destroy_host(bvh_host);
-
-        // save gpu-side copy of bounds
-        mesh.bounds = (bounds3*)alloc_device(WP_CURRENT_CONTEXT, sizeof(bounds3)*num_tris);
-        memcpy_h2d(WP_CURRENT_CONTEXT, mesh.bounds, bounds_host, sizeof(bounds3)*num_tris);
-
-        free_host(points_host);
-        free_host(indices_host);
-        free_host(bounds_host);
-
-        mesh.bvh = bvh_device;
-
-        if (support_winding_number)
-        {
-            int num_bvh_nodes = 2*num_tris-1;
-            mesh.solid_angle_props = (SolidAngleProps*)alloc_device(WP_CURRENT_CONTEXT, sizeof(SolidAngleProps)*num_bvh_nodes);
-        }        
-    }
-
-    Mesh* mesh_device = (Mesh*)alloc_device(WP_CURRENT_CONTEXT, sizeof(Mesh));
-    memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &mesh, sizeof(Mesh));
-    
-    // save descriptor
-    uint64_t mesh_id = (uint64_t)mesh_device;
-    mesh_add_descriptor(mesh_id, mesh);
-
-    if (support_winding_number) 
-    {
-        mesh_refit_device(mesh_id);
-    }
-    return mesh_id;
-}
 
 void mesh_destroy_host(uint64_t id)
 {
     Mesh* m = (Mesh*)(id);
 
-    delete[] m->bounds;
+    delete[] m->lowers;
+    delete[] m->uppers;
+
     if (m->solid_angle_props) {
         delete [] m->solid_angle_props;
     }
@@ -219,25 +156,6 @@ void mesh_destroy_host(uint64_t id)
     delete m;
 }
 
-void mesh_destroy_device(uint64_t id)
-{
-    Mesh mesh;
-    if (mesh_get_descriptor(id, mesh))
-    {
-        ContextGuard guard(mesh.context);
-
-        bvh_destroy_device(mesh.bvh);
-
-        free_device(WP_CURRENT_CONTEXT, mesh.bounds);
-        free_device(WP_CURRENT_CONTEXT, (Mesh*)id);
-
-        if (mesh.solid_angle_props) {
-            free_device(WP_CURRENT_CONTEXT, mesh.solid_angle_props);
-        }
-        mesh_rem_descriptor(id);
-    }
-}
-
 void mesh_refit_host(uint64_t id)
 {
     Mesh* m = (Mesh*)(id);
@@ -245,13 +163,19 @@ void mesh_refit_host(uint64_t id)
     float sum = 0.0;
     for (int i=0; i < m->num_tris; ++i)
     {
-        m->bounds[i] = bounds3();
         wp::vec3 p0 = m->points.data[m->indices.data[i*3+0]];
         wp::vec3 p1 = m->points.data[m->indices.data[i*3+1]];
         wp::vec3 p2 = m->points.data[m->indices.data[i*3+2]];
-        m->bounds[i].add_point(p0);
-        m->bounds[i].add_point(p1);
-        m->bounds[i].add_point(p2);
+
+        // compute triangle bounds
+        bounds3 b;       
+        b.add_point(p0);
+        b.add_point(p1);
+        b.add_point(p2);
+
+        m->lowers[i] = b.lower;
+        m->uppers[i] = b.upper;
+
         sum += length(p0-p1) + length(p0-p2) + length(p2-p1);
     }
     m->average_edge_length = sum / (m->num_tris*3);
@@ -263,7 +187,7 @@ void mesh_refit_host(uint64_t id)
     }
     else
     {
-        bvh_refit_host(m->bvh, m->bounds);
+        bvh_refit_host(m->bvh);
     }
 }
 
@@ -271,9 +195,10 @@ void mesh_refit_host(uint64_t id)
 // stubs for non-CUDA platforms
 #if !WP_ENABLE_CUDA
 
-void mesh_refit_device(uint64_t id)
-{
-}
+
+WP_API uint64_t mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, wp::array_t<int> tris, int num_points, int num_tris, int support_winding_number) { return 0; }
+WP_API void mesh_destroy_device(uint64_t id) {}
+WP_API void mesh_refit_device(uint64_t id) {}
 
 
 #endif // !WP_ENABLE_CUDA

warp/native/mesh.cu

@@ -10,13 +10,12 @@
 #include "cuda_util.h"
 #include "mesh.h"
 #include "bvh.h"
-#include "thrust/device_ptr.h"
-#include <thrust/scan.h>
+#include "scan.h"
 
 namespace wp
 {
 
-__global__ void compute_triangle_bounds(int n, const vec3* points, const int* indices, bounds3* b)
+__global__ void compute_triangle_bounds(int n, const vec3* points, const int* indices, vec3* lowers, vec3* uppers)
 {
     const int tid = blockIdx.x*blockDim.x + threadIdx.x;
 
@@ -34,7 +33,8 @@ __global__ void compute_triangle_bounds(int n, const vec3* points, const int* in
         vec3 lower = min(min(p, q), r);
         vec3 upper = max(max(p, q), r);
 
-        b[tid] = bounds3(lower, upper);
+        lowers[tid] = lower;
+        uppers[tid] = upper;
     }
 }
 
@@ -159,44 +159,135 @@ void bvh_refit_with_solid_angle_device(BVH& bvh, Mesh& mesh)
     // clear child counters
     memset_device(WP_CURRENT_CONTEXT, bvh.node_counts, 0, sizeof(int)*bvh.max_nodes);
 
-    wp_launch_device(WP_CURRENT_CONTEXT, bvh_refit_with_solid_angle_kernel, bvh.max_nodes, (bvh.max_nodes, bvh.node_parents, bvh.node_counts, bvh.node_lowers, bvh.node_uppers, mesh.points, mesh.indices, mesh.solid_angle_props));
+    wp_launch_device(WP_CURRENT_CONTEXT, bvh_refit_with_solid_angle_kernel, bvh.num_items, (bvh.num_items, bvh.node_parents, bvh.node_counts, bvh.node_lowers, bvh.node_uppers, mesh.points, mesh.indices, mesh.solid_angle_props));
 }
+
 } // namespace wp
 
-void mesh_refit_device(uint64_t id)
+
+uint64_t mesh_create_device(void* context, wp::array_t<wp::vec3> points, wp::array_t<wp::vec3> velocities, wp::array_t<int> indices, int num_points, int num_tris, int support_winding_number)
+{
+    ContextGuard guard(context);
+
+    wp::Mesh mesh(points, velocities, indices, num_points, num_tris);
+
+    mesh.context = context ? context : cuda_context_get_current();
+
+    {
+        // // todo: BVH creation only on CPU at the moment so temporarily bring all the data back to host
+        // vec3* points_host = (vec3*)alloc_host(sizeof(vec3)*num_points);
+        // int* indices_host = (int*)alloc_host(sizeof(int)*num_tris*3);
+        // bounds3* bounds_host = (bounds3*)alloc_host(sizeof(bounds3)*num_tris);
+
+        // memcpy_d2h(WP_CURRENT_CONTEXT, points_host, points, sizeof(vec3)*num_points);
+        // memcpy_d2h(WP_CURRENT_CONTEXT, indices_host, indices, sizeof(int)*num_tris*3);
+        // cuda_context_synchronize(WP_CURRENT_CONTEXT);
+
+        // float sum = 0.0;
+        // for (int i=0; i < num_tris; ++i)
+        // {
+        //     bounds_host[i] = bounds3();
+        //     wp::vec3 p0 = points_host[indices_host[i*3+0]];
+        //     wp::vec3 p1 = points_host[indices_host[i*3+1]];
+        //     wp::vec3 p2 = points_host[indices_host[i*3+2]];
+        //     bounds_host[i].add_point(p0);
+        //     bounds_host[i].add_point(p1);
+        //     bounds_host[i].add_point(p2);
+        //     sum += length(p0-p1) + length(p0-p2) + length(p2-p1);
+        // }
+        // mesh.average_edge_length = sum / (num_tris*3);
+
+        // BVH bvh_host = bvh_create(bounds_host, num_tris);
+        // BVH bvh_device = bvh_clone(WP_CURRENT_CONTEXT, bvh_host);
+
+        // bvh_destroy_host(bvh_host);
+
+        // create lower upper arrays expected by GPU BVH builder
+        mesh.lowers = (wp::vec3*)alloc_temp_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
+        mesh.uppers = (wp::vec3*)alloc_temp_device(WP_CURRENT_CONTEXT, sizeof(wp::vec3)*num_tris);
+
+        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);
+
+        if (support_winding_number)
+        {
+            int num_bvh_nodes = 2*num_tris;
+            mesh.solid_angle_props = (wp::SolidAngleProps*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::SolidAngleProps)*num_bvh_nodes);
+        }        
+    }
+
+    wp::Mesh* mesh_device = (wp::Mesh*)alloc_device(WP_CURRENT_CONTEXT, sizeof(wp::Mesh));
+    memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &mesh, sizeof(wp::Mesh));
+    
+    // save descriptor
+    uint64_t mesh_id = (uint64_t)mesh_device;
+    mesh_add_descriptor(mesh_id, mesh);
+
+    if (support_winding_number) 
+        mesh_refit_device(mesh_id);
+
+    return mesh_id;
+}
+
+void mesh_destroy_device(uint64_t id)
 {
+    wp::Mesh mesh;
+    if (wp::mesh_get_descriptor(id, mesh))
+    {
+        ContextGuard guard(mesh.context);
+
+        wp::bvh_destroy_device(mesh.bvh);
+
+        free_device(WP_CURRENT_CONTEXT, mesh.lowers);
+        free_device(WP_CURRENT_CONTEXT, mesh.uppers);
+        free_device(WP_CURRENT_CONTEXT, (wp::Mesh*)id);
 
+        if (mesh.solid_angle_props) {
+            free_device(WP_CURRENT_CONTEXT, mesh.solid_angle_props);
+        }
+        wp::mesh_rem_descriptor(id);
+    }
+}
+
+void mesh_update_stats(uint64_t id)
+{
+    
+}
+
+void mesh_refit_device(uint64_t id)
+{
     // recompute triangle bounds
     wp::Mesh m;
     if (mesh_get_descriptor(id, m))
     {
         ContextGuard guard(m.context);
 
-        // we compute mesh the average edge length
-        // for use in mesh_query_point_sign_normal()
-        // since it relies on an epsilon for welding
-        
-        // re-use bounds memory temporarily for computing edge lengths
-        float* length_tmp_ptr = (float*)m.bounds;
-        wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_mesh_edge_lengths, m.num_tris, (m.num_tris, m.points, m.indices, length_tmp_ptr));
-        
-        thrust::inclusive_scan(
-            thrust::device_ptr<float>(length_tmp_ptr),
-            thrust::device_ptr<float>(length_tmp_ptr + m.num_tris),
-            thrust::device_ptr<float>(length_tmp_ptr));
-            
-        wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_average_mesh_edge_length, 1, (m.num_tris, length_tmp_ptr, (wp::Mesh*)id));
-        wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_triangle_bounds, m.num_tris, (m.num_tris, m.points, m.indices, m.bounds));
+        wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_triangle_bounds, m.num_tris, (m.num_tris, m.points, m.indices, m.lowers, m.uppers));
 
         if (m.solid_angle_props) 
         {
+            // we compute mesh the average edge length
+            // for use in mesh_query_point_sign_normal()
+            // since it relies on an epsilon for welding
+
+            // reuse bounds memory temporarily for computing edge lengths
+            float* length_tmp_ptr = (float*)m.lowers;
+            wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_mesh_edge_lengths, m.num_tris, (m.num_tris, m.points, m.indices, length_tmp_ptr));
+            
+            scan_device(length_tmp_ptr, length_tmp_ptr, m.num_tris, true);
+                
+            wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_average_mesh_edge_length, 1, (m.num_tris, length_tmp_ptr, (wp::Mesh*)id));
+            wp_launch_device(WP_CURRENT_CONTEXT, wp::compute_triangle_bounds, m.num_tris, (m.num_tris, m.points, m.indices, m.lowers, m.uppers));
+
+            // update solid angle data
             bvh_refit_with_solid_angle_device(m.bvh, m);            
         }
         else 
         {
-            bvh_refit_device(m.bvh, m.bounds);
+            bvh_refit_device(m.bvh);
         }
     }
-
 }