warp-lang 1.0.0b2__py3-none-win_amd64.whl → 1.0.0b6__py3-none-win_amd64.whl

warp/native/mesh.cu

@@ -15,7 +15,7 @@
 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;
 
@@ -33,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;
     }
 }
 
@@ -158,40 +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));
-        
-        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.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
+
+            // re-use 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);
         }
     }
-
 }
+