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

warp/native/mesh.cpp

@@ -49,131 +49,156 @@ void mesh_rem_descriptor(uint64_t id)
 
 } // namespace wp
 
-uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities, array_t<int> indices, int num_points, int num_tris)
+void bvh_refit_with_solid_angle_recursive_host(BVH& bvh, int index, Mesh& mesh)
 {
-    Mesh* m = new Mesh(points, velocities, indices, num_points, num_tris);
+    BVHPackedNodeHalf& lower = bvh.node_lowers[index];
+    BVHPackedNodeHalf& upper = bvh.node_uppers[index];
 
-    m->bounds = new bounds3[num_tris];
+    if (lower.b)
+    {
+        // Leaf, compute properties
+        const int leaf_index = lower.i;
 
-    for (int i=0; i < num_tris; ++i)
+        precompute_triangle_solid_angle_props(mesh.points[mesh.indices[leaf_index*3+0]], mesh.points[mesh.indices[leaf_index*3+1]], mesh.points[mesh.indices[leaf_index*3+2]], mesh.solid_angle_props[index]);        
+        (vec3&)lower = mesh.solid_angle_props[index].box.lower;
+        (vec3&)upper = mesh.solid_angle_props[index].box.upper;        
+    }
+    else
     {
-        m->bounds[i].add_point(points[indices[i*3+0]]);
-        m->bounds[i].add_point(points[indices[i*3+1]]);
-        m->bounds[i].add_point(points[indices[i*3+2]]);
+        int left_index = lower.i;
+        int right_index = upper.i;
+
+        bvh_refit_with_solid_angle_recursive_host(bvh, left_index, mesh);
+        bvh_refit_with_solid_angle_recursive_host(bvh, right_index, mesh);
+
+        // combine
+        SolidAngleProps* left_child_data = &mesh.solid_angle_props[left_index];
+        SolidAngleProps* right_child_data = (left_index != right_index) ? &mesh.solid_angle_props[right_index] : NULL;
+        
+        combine_precomputed_solid_angle_props(mesh.solid_angle_props[index], left_child_data, right_child_data);
+
+        // compute union of children
+        const vec3& left_lower = (vec3&)bvh.node_lowers[left_index];
+        const vec3& left_upper = (vec3&)bvh.node_uppers[left_index];
+
+        const vec3& right_lower = (vec3&)bvh.node_lowers[right_index];
+        const vec3& right_upper = (vec3&)bvh.node_uppers[right_index];
+
+        // union of child bounds
+        vec3 new_lower = min(left_lower, right_lower);
+        vec3 new_upper = max(left_upper, right_upper);
+        
+        // write new BVH nodes
+        (vec3&)lower = new_lower;
+        (vec3&)upper = new_upper;        
     }
-
-    m->bvh = bvh_create(m->bounds, num_tris);
-
-    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)
+void bvh_refit_with_solid_angle_host(BVH& bvh, Mesh& mesh)
 {
-    ContextGuard guard(context);
-
-    Mesh mesh(points, velocities, indices, num_points, num_tris);
-
-    mesh.context = context ? context : cuda_context_get_current();
+    bvh_refit_with_solid_angle_recursive_host(bvh, 0, mesh);
+}
 
-    // 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);
+uint64_t mesh_create_host(array_t<wp::vec3> points, array_t<wp::vec3> velocities, array_t<int> indices, int num_points, int num_tris, int support_winding_number)
+{
+    Mesh* m = new Mesh(points, velocities, indices, num_points, num_tris);
 
-    // mesh.num_points = num_points;
-    // mesh.num_tris = 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)
     {
-        // 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);
-
-        for (int i=0; i < num_tris; ++i)
-        {
-            bounds_host[i] = bounds3();
-            bounds_host[i].add_point(points_host[indices_host[i*3+0]]);
-            bounds_host[i].add_point(points_host[indices_host[i*3+1]]);
-            bounds_host[i].add_point(points_host[indices_host[i*3+2]]);
-        }
-
-        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;
+        wp::vec3& p0 = points[indices[i*3+0]];
+        wp::vec3& p1 = points[indices[i*3+1]];
+        wp::vec3& p2 = points[indices[i*3+2]];
+        
+        // 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);
 
-    Mesh* mesh_device = (Mesh*)alloc_device(WP_CURRENT_CONTEXT, sizeof(Mesh));
-    memcpy_h2d(WP_CURRENT_CONTEXT, mesh_device, &mesh, sizeof(Mesh));
+    m->bvh = *(wp::BVH*)bvh_create_host(m->lowers, m->uppers, num_tris);
     
-    // save descriptor
-    uint64_t mesh_id = (uint64_t)mesh_device;
-    mesh_add_descriptor(mesh_id, mesh);
+    if (support_winding_number) 
+    {
+        // Let's first compute the sold
+        int num_bvh_nodes = 2*num_tris-1;
+        m->solid_angle_props = new SolidAngleProps[num_bvh_nodes];
+        bvh_refit_with_solid_angle_host(m->bvh, *m);
+    }
 
-    return mesh_id;
+    return (uint64_t)m;
 }
 
+
 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;
+    }
     bvh_destroy_host(m->bvh);
 
     delete m;
 }
 
-void mesh_destroy_device(uint64_t id)
+void mesh_refit_host(uint64_t id)
 {
-    Mesh mesh;
-    if (mesh_get_descriptor(id, mesh))
+    Mesh* m = (Mesh*)(id);
+
+    float sum = 0.0;
+    for (int i=0; i < m->num_tris; ++i)
     {
-        ContextGuard guard(mesh.context);
+        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]];
 
-        bvh_destroy_device(mesh.bvh);
+        // compute triangle bounds
+        bounds3 b;       
+        b.add_point(p0);
+        b.add_point(p1);
+        b.add_point(p2);
 
-        free_device(WP_CURRENT_CONTEXT, mesh.bounds);
-        free_device(WP_CURRENT_CONTEXT, (Mesh*)id);
+        m->lowers[i] = b.lower;
+        m->uppers[i] = b.upper;
 
-        mesh_rem_descriptor(id);
+        sum += length(p0-p1) + length(p0-p2) + length(p2-p1);
     }
-}
-
-void mesh_refit_host(uint64_t id)
-{
-    Mesh* m = (Mesh*)(id);
+    m->average_edge_length = sum / (m->num_tris*3);
 
-    for (int i=0; i < m->num_tris; ++i)
+    if (m->solid_angle_props)
     {
-        m->bounds[i] = bounds3();
-        m->bounds[i].add_point(m->points.data[m->indices.data[i*3+0]]);
-        m->bounds[i].add_point(m->points.data[m->indices.data[i*3+1]]);
-        m->bounds[i].add_point(m->points.data[m->indices.data[i*3+2]]);
+        // If solid angle were used, use refit solid angle
+        bvh_refit_with_solid_angle_host(m->bvh, *m);
+    }
+    else
+    {
+        bvh_refit_host(m->bvh);
     }
-
-    bvh_refit_host(m->bvh, m->bounds);
 }
 
 
 // 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,11 +10,12 @@
 #include "cuda_util.h"
 #include "mesh.h"
 #include "bvh.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;
 
@@ -32,25 +33,261 @@ __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;
     }
 }
 
+__global__ void compute_mesh_edge_lengths(int n, const vec3* points, const int* indices, float* edge_lengths)
+{
+    const int tid = blockIdx.x*blockDim.x + threadIdx.x;
+
+    if (tid < n)
+    {
+        // if leaf then update bounds
+        int i = indices[tid*3+0];
+        int j = indices[tid*3+1];
+        int k = indices[tid*3+2];
+
+        vec3 p = points[i];
+        vec3 q = points[j];
+        vec3 r = points[k];
+
+
+        edge_lengths[tid] = length(p-q) + length(p-r) + length(q-r);
+    }
+}
+
+__global__ void compute_average_mesh_edge_length(int n, float* sum_edge_lengths, Mesh* m)
+{
+    m->average_edge_length = sum_edge_lengths[n - 1] / (3*n);
+}
+
+__global__ void bvh_refit_with_solid_angle_kernel(int n, const int* __restrict__ parents, int* __restrict__ child_count, BVHPackedNodeHalf* __restrict__ lowers, BVHPackedNodeHalf* __restrict__ uppers, const vec3* points, const int* indices, SolidAngleProps* solid_angle_props)
+{
+    int index = blockDim.x*blockIdx.x + threadIdx.x;
+
+    if (index < n)
+    {
+        bool leaf = lowers[index].b;
+
+        if (leaf)
+        {
+            // update the leaf node
+            const int leaf_index = lowers[index].i;        
+            precompute_triangle_solid_angle_props(points[indices[leaf_index*3+0]], points[indices[leaf_index*3+1]], points[indices[leaf_index*3+2]], solid_angle_props[index]);        
+
+            make_node(lowers+index, solid_angle_props[index].box.lower, leaf_index, true);
+            make_node(uppers+index, solid_angle_props[index].box.upper, 0, false);
+        }
+        else
+        {
+            // only keep leaf threads
+            return;
+        }
+
+        // update hierarchy
+        for (;;)
+        {
+            int parent = parents[index];
+            
+            // reached root
+            if (parent == -1)
+                return;
+
+            // ensure all writes are visible
+            __threadfence();
+         
+            int finished = atomicAdd(&child_count[parent], 1);
+
+            // if we have are the last thread (such that the parent node is now complete)
+            // then update its bounds and move onto the the next parent in the hierarchy
+            if (finished == 1)
+            {
+                //printf("Compute non-leaf at %d\n", index);
+                const int left_child = lowers[parent].i;
+                const int right_child = uppers[parent].i;
+
+                vec3 left_lower = vec3(lowers[left_child].x,
+                                       lowers[left_child].y, 
+                                       lowers[left_child].z);
+
+                vec3 left_upper = vec3(uppers[left_child].x,
+                                       uppers[left_child].y, 
+                                       uppers[left_child].z);
+
+                vec3 right_lower = vec3(lowers[right_child].x,
+                                       lowers[right_child].y,
+                                       lowers[right_child].z);
+
+
+                vec3 right_upper = vec3(uppers[right_child].x, 
+                                       uppers[right_child].y, 
+                                       uppers[right_child].z);
+
+                // union of child bounds
+                vec3 lower = min(left_lower, right_lower);
+                vec3 upper = max(left_upper, right_upper);
+                
+                // write new BVH nodes
+                make_node(lowers+parent, lower, left_child, false);
+                make_node(uppers+parent, upper, right_child, false);
+
+                // combine
+                SolidAngleProps* left_child_data = &solid_angle_props[left_child];
+                SolidAngleProps* right_child_data = (left_child != right_child) ? &solid_angle_props[right_child] : NULL;
+        
+                combine_precomputed_solid_angle_props(solid_angle_props[parent], left_child_data, right_child_data);
+
+                // move onto processing the parent
+                index = parent;
+            }
+            else
+            {
+                // parent not ready (we are the first child), terminate thread
+                break;
+            }
+        }		
+    }
+}
+
+
+void bvh_refit_with_solid_angle_device(BVH& bvh, Mesh& mesh)
+{
+    ContextGuard guard(bvh.context);
+
+    // 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.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);
 
-        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));
 
-        bvh_refit_device(m.bvh, m.bounds);
-    }
+        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);
+        }
+    }
 }