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

warp/native/mesh.h

@@ -26,7 +26,9 @@ struct Mesh
 
     array_t<int> indices;
 
-    bounds3* bounds;
+    vec3* lowers;
+    vec3* uppers;
+
     SolidAngleProps* solid_angle_props;
 
     int num_points;
@@ -40,7 +42,8 @@ struct Mesh
     inline CUDA_CALLABLE Mesh(int id = 0) 
     {
         // for backward a = 0 initialization syntax
-        bounds = nullptr;
+        lowers = nullptr;
+        uppers = nullptr;
         num_points = 0;
         num_tris = 0;
         context = nullptr;
@@ -57,7 +60,8 @@ struct Mesh
         void* context = nullptr
     ) : points(points), velocities(velocities), indices(indices), num_points(num_points), num_tris(num_tris), context(context)
     {
-        bounds = nullptr;
+        lowers = nullptr;
+        uppers = nullptr;
         solid_angle_props = nullptr;
         average_edge_length = 0.0f;
     }
@@ -81,6 +85,55 @@ CUDA_CALLABLE inline float distance_to_aabb_sq(const vec3& p, const vec3& lower,
     return length_sq(p-cp);
 }
 
+CUDA_CALLABLE inline float furthest_distance_to_aabb_sq(const vec3& p, const vec3& lower, const vec3& upper)
+{
+    vec3 c0 = vec3(lower[0], lower[1], lower[2]);
+    vec3 c1 = vec3(lower[0], lower[1], upper[2]);
+    vec3 c2 = vec3(lower[0], upper[1], lower[2]);
+    vec3 c3 = vec3(lower[0], upper[1], upper[2]);
+    vec3 c4 = vec3(upper[0], lower[1], lower[2]);
+    vec3 c5 = vec3(upper[0], lower[1], upper[2]);
+    vec3 c6 = vec3(upper[0], upper[1], lower[2]);
+    vec3 c7 = vec3(upper[0], upper[1], upper[2]);
+    
+    float max_dist_sq = 0.0;
+    float d;
+
+    d = length_sq(p-c0);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c1);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c2);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c3);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c4);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c5);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c6);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    d = length_sq(p-c7);
+    if (d > max_dist_sq)
+        max_dist_sq = d;
+
+    return max_dist_sq;
+}
+
 CUDA_CALLABLE inline float mesh_query_inside(uint64_t id, const vec3& p);
 
 // returns true if there is a point (strictly) < distance max_dist
@@ -88,11 +141,8 @@ CUDA_CALLABLE inline bool mesh_query_point(uint64_t id, const vec3& point, float
 {
     Mesh mesh = mesh_get(id);
 
-    if (mesh.bvh.num_nodes == 0)
-        return false;
-
     int stack[32];
-    stack[0] = mesh.bvh.root;
+    stack[0] = *mesh.bvh.root;
 
     int count = 1;
 
@@ -276,11 +326,8 @@ CUDA_CALLABLE inline bool mesh_query_point_no_sign(uint64_t id, const vec3& poin
 {
     Mesh mesh = mesh_get(id);
 
-    if (mesh.bvh.num_nodes == 0)
-        return false;
-
     int stack[32];
-    stack[0] = mesh.bvh.root;
+    stack[0] = *mesh.bvh.root;
 
     int count = 1;
 
@@ -456,14 +503,197 @@ CUDA_CALLABLE inline bool mesh_query_point_no_sign(uint64_t id, const vec3& poin
     }
 }
 
+// returns true if there is a point (strictly) > distance min_dist
+CUDA_CALLABLE inline bool mesh_query_furthest_point_no_sign(uint64_t id, const vec3& point, float min_dist, int& face, float& u, float& v)
+{
+    Mesh mesh = mesh_get(id);
+
+    int stack[32];
+    stack[0] = *mesh.bvh.root;
+
+    int count = 1;
+
+    float max_dist_sq = min_dist*min_dist;
+    int min_face;
+    float min_v;
+    float min_w;
+
+#if BVH_DEBUG
+    int tests = 0;
+    int secondary_culls = 0;
+
+    std::vector<int> test_history;
+    std::vector<vec3> test_centers;
+    std::vector<vec3> test_extents;
+#endif
+
+    while (count)
+    {
+        const int nodeIndex = stack[--count];
+
+        BVHPackedNodeHalf lower = mesh.bvh.node_lowers[nodeIndex];
+        BVHPackedNodeHalf upper = mesh.bvh.node_uppers[nodeIndex];
+    
+        // re-test distance
+        float node_dist_sq = furthest_distance_to_aabb_sq(point, vec3(lower.x, lower.y, lower.z), vec3(upper.x, upper.y, upper.z));
+        
+        // if maximum distance to this node is less than our existing furthest max then skip
+        if (node_dist_sq < max_dist_sq)
+        {
+#if BVH_DEBUG			
+            secondary_culls++;
+#endif			
+            continue;
+        }
+
+        const int left_index = lower.i;
+        const int right_index = upper.i;
+
+        if (lower.b)
+        {	
+            // compute closest point on tri
+            int i = mesh.indices[left_index*3+0];
+            int j = mesh.indices[left_index*3+1];
+            int k = mesh.indices[left_index*3+2];
+
+            vec3 p = mesh.points[i];
+            vec3 q = mesh.points[j];
+            vec3 r = mesh.points[k];
+            
+            vec3 e0 = q-p;
+            vec3 e1 = r-p;
+            vec3 e2 = r-q;
+            vec3 normal = cross(e0, e1);
+            
+            // sliver detection
+            if (length(normal)/(dot(e0,e0) + dot(e1,e1) + dot(e2,e2)) < 1.e-6f)
+                continue;
+
+            vec2 barycentric = furthest_point_to_triangle(p, q, r, point);
+            float u = barycentric[0];
+            float v = barycentric[1];
+            float w = 1.f - u - v;
+            vec3 c = u*p + v*q + w*r;
+
+            float dist_sq = length_sq(c-point);
+
+            if (dist_sq > max_dist_sq)
+            {
+                max_dist_sq = dist_sq;
+                min_v = v;
+                min_w = w;
+                min_face = left_index;
+            }
+
+#if BVH_DEBUG
+
+            tests++;
+
+            bounds3 b;
+            b = bounds_union(b, p);
+            b = bounds_union(b, q);
+            b = bounds_union(b, r);
+
+            if (distance_to_aabb_sq(point, b.lower, b.upper) > max_dist*max_dist)
+            {
+                //if (dist_sq < max_dist*max_dist)
+                test_history.push_back(left_index);
+                test_centers.push_back(b.center());
+                test_extents.push_back(b.edges());
+            }
+#endif
+
+        }
+        else
+        {
+            BVHPackedNodeHalf left_lower = mesh.bvh.node_lowers[left_index];
+            BVHPackedNodeHalf left_upper = mesh.bvh.node_uppers[left_index];
+
+            BVHPackedNodeHalf right_lower = mesh.bvh.node_lowers[right_index];
+            BVHPackedNodeHalf right_upper = mesh.bvh.node_uppers[right_index];
+
+            float left_dist_sq = furthest_distance_to_aabb_sq(point, vec3(left_lower.x, left_lower.y, left_lower.z), vec3(left_upper.x, left_upper.y, left_upper.z));
+            float right_dist_sq = furthest_distance_to_aabb_sq(point, vec3(right_lower.x, right_lower.y, right_lower.z), vec3(right_upper.x, right_upper.y, right_upper.z));
+
+            float left_score = left_dist_sq;
+            float right_score = right_dist_sq;
+
+            if (left_score > right_score)
+            {
+                // put left on top of the stack
+                if (right_dist_sq > max_dist_sq)
+                    stack[count++] = right_index;
+
+                if (left_dist_sq > max_dist_sq)
+                    stack[count++] = left_index;
+            }
+            else
+            {
+                // put right on top of the stack
+                if (left_dist_sq > max_dist_sq)
+                    stack[count++] = left_index;
+
+                if (right_dist_sq > max_dist_sq)
+                    stack[count++] = right_index;
+            }
+        }
+    }
+
+
+#if BVH_DEBUG
+    printf("%d\n", tests);
+
+    static int max_tests = 0;
+    static vec3 max_point;
+    static float max_point_dist = 0.0f;
+    static int max_secondary_culls = 0;
+
+    if (secondary_culls > max_secondary_culls)
+        max_secondary_culls = secondary_culls;
+
+    if (tests > max_tests)
+    {
+        max_tests = tests;
+        max_point = point;
+        max_point_dist = sqrtf(max_dist_sq);
+
+        printf("max_tests: %d max_point: %f %f %f max_point_dist: %f max_second_culls: %d\n", max_tests, max_point[0], max_point[1], max_point[2], max_point_dist, max_secondary_culls);
+
+        FILE* f = fopen("test_history.txt", "w");
+        for (int i=0; i < test_history.size(); ++i)
+        {
+            fprintf(f, "%d, %f, %f, %f, %f, %f, %f\n", 
+            test_history[i], 
+            test_centers[i][0], test_centers[i][1], test_centers[i][2],
+            test_extents[i][0], test_extents[i][1], test_extents[i][2]);
+        }
+
+        fclose(f);
+    }
+#endif
+
+    // check if we found a point, and write outputs
+    if (max_dist_sq > min_dist*min_dist)
+    {
+        u = 1.0f - min_v - min_w;
+        v = min_v;
+        face = min_face;
+        
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
 // returns true if there is a point (strictly) < distance max_dist
 CUDA_CALLABLE inline bool mesh_query_point_sign_normal(uint64_t id, const vec3& point, float max_dist, float& inside, int& face, float& u, float& v, const float epsilon = 1e-3f)
 {
     Mesh mesh = mesh_get(id);
-    if (mesh.bvh.num_nodes == 0)
-        return false;
+
     int stack[32];
-    stack[0] = mesh.bvh.root;
+    stack[0] = *mesh.bvh.root;
     int count = 1;
     float min_dist = max_dist;
     int min_face;
@@ -685,12 +915,11 @@ CUDA_CALLABLE inline bool mesh_query_point_sign_normal(uint64_t id, const vec3&
 CUDA_CALLABLE inline float solid_angle_iterative(uint64_t id, const vec3& p, const float accuracy_sq)
 {
     Mesh mesh = mesh_get(id);
-    if (mesh.bvh.num_nodes == 0)
-        return 0.0f;
+
     int stack[32];
     int at_child[32]; // 0 for left, 1 for right, 2 for done	
     float angle[32]; 
-    stack[0] = mesh.bvh.root;	
+    stack[0] = *mesh.bvh.root;	
     at_child[0] = 0;
 
     int count = 1;
@@ -766,11 +995,8 @@ CUDA_CALLABLE inline bool mesh_query_point_sign_winding_number(uint64_t id, cons
 {
     Mesh mesh = mesh_get(id);
 
-    if (mesh.bvh.num_nodes == 0)
-        return false;
-
     int stack[32];
-    stack[0] = mesh.bvh.root;
+    stack[0] = *mesh.bvh.root;
 
     int count = 1;
 
@@ -955,7 +1181,7 @@ CUDA_CALLABLE inline bool mesh_query_point_sign_winding_number(uint64_t id, cons
     }
 }
 
-CUDA_CALLABLE inline void adj_mesh_query_point_no_sign(uint64_t id, const vec3& point, float max_dist, int& face, float& u, float& v, 
+CUDA_CALLABLE inline void adj_mesh_query_point_no_sign(uint64_t id, const vec3& point, float max_dist, const int& face, const float& u, const float& v,
                                                uint64_t adj_id, vec3& adj_point, float& adj_max_dist, int& adj_face, float& adj_u, float& adj_v, bool& adj_ret)
 {
     Mesh mesh = mesh_get(id);
@@ -976,33 +1202,143 @@ CUDA_CALLABLE inline void adj_mesh_query_point_no_sign(uint64_t id, const vec3&
     adj_closest_point_to_triangle(p, q, r, point, adj_p, adj_q, adj_r, adj_point, adj_uv);	
 }
 
-CUDA_CALLABLE inline void adj_mesh_query_point(uint64_t id, const vec3& point, float max_dist, float& inside, int& face, float& u, float& v,
+CUDA_CALLABLE inline void adj_mesh_query_furthest_point_no_sign(uint64_t id, const vec3& point, float min_dist, const int& face, const float& u, const float& v,
+                                               uint64_t adj_id, vec3& adj_point, float& adj_min_dist, int& adj_face, float& adj_u, float& adj_v, bool& adj_ret)
+{
+    Mesh mesh = mesh_get(id);
+    
+    // face is determined by BVH in forward pass
+    int i = mesh.indices[face*3+0];
+    int j = mesh.indices[face*3+1];
+    int k = mesh.indices[face*3+2];
+
+    vec3 p = mesh.points[i];
+    vec3 q = mesh.points[j];
+    vec3 r = mesh.points[k];
+
+    vec3 adj_p, adj_q, adj_r;
+
+    vec2 adj_uv(adj_u, adj_v);
+
+    adj_closest_point_to_triangle(p, q, r, point, adj_p, adj_q, adj_r, adj_point, adj_uv);	 // Todo for Miles :>
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_point(uint64_t id, const vec3& point, float max_dist, const float& inside, const int& face, const float& u, const float& v,
                                                uint64_t adj_id, vec3& adj_point, float& adj_max_dist, float& adj_inside, int& adj_face, float& adj_u, float& adj_v, bool& adj_ret)
 {
     adj_mesh_query_point_no_sign(id, point, max_dist, face, u, v, adj_id, adj_point, adj_max_dist, adj_face, adj_u, adj_v, adj_ret);
 }
 
-CUDA_CALLABLE inline void adj_mesh_query_point_sign_normal(uint64_t id, const vec3& point, float max_dist, float& inside, int& face, float& u, float& v, const float epsilon,
+CUDA_CALLABLE inline void adj_mesh_query_point_sign_normal(uint64_t id, const vec3& point, float max_dist, const float& inside, const int& face, const float& u, const float& v, const float epsilon,
                                                uint64_t adj_id, vec3& adj_point, float& adj_max_dist, float& adj_inside, int& adj_face, float& adj_u, float& adj_v, float& adj_epsilon, bool& adj_ret)
 {
     adj_mesh_query_point_no_sign(id, point, max_dist, face, u, v, adj_id, adj_point, adj_max_dist, adj_face, adj_u, adj_v, adj_ret);
 }
 
-CUDA_CALLABLE inline void adj_mesh_query_point_sign_winding_number(uint64_t id, const vec3& point, float max_dist, float& inside, int& face, float& u, float& v, const float accuracy, const float winding_number_threshold,
+CUDA_CALLABLE inline void adj_mesh_query_point_sign_winding_number(uint64_t id, const vec3& point, float max_dist, const float& inside, const int& face, const float& u, const float& v, const float accuracy, const float winding_number_threshold,
                                                uint64_t adj_id, vec3& adj_point, float& adj_max_dist, float& adj_inside, int& adj_face, float& adj_u, float& adj_v, float& adj_accuracy, float& adj_winding_number_threshold, bool& adj_ret)
 {
     adj_mesh_query_point_no_sign(id, point, max_dist, face, u, v, adj_id, adj_point, adj_max_dist, adj_face, adj_u, adj_v, adj_ret);
 }
 
+
+// Stores the result of querying the closest point on a mesh.
+struct mesh_query_point_t
+{
+    CUDA_CALLABLE mesh_query_point_t()
+    {
+    }
+
+    CUDA_CALLABLE mesh_query_point_t(int)
+    {
+        // For backward pass.
+    }
+
+    bool result;
+    float sign;
+    int face;
+    float u;
+    float v;
+};
+
+CUDA_CALLABLE inline mesh_query_point_t mesh_query_point(uint64_t id, const vec3& point, float max_dist)
+{
+    mesh_query_point_t query;
+    query.result = mesh_query_point(id, point, max_dist, query.sign, query.face, query.u, query.v);
+    return query;
+}
+
+CUDA_CALLABLE inline mesh_query_point_t mesh_query_point_no_sign(uint64_t id, const vec3& point, float max_dist)
+{
+    mesh_query_point_t query;
+    query.sign = 0.0;
+    query.result = mesh_query_point_no_sign(id, point, max_dist, query.face, query.u, query.v);
+    return query;
+}
+
+CUDA_CALLABLE inline mesh_query_point_t mesh_query_furthest_point_no_sign(uint64_t id, const vec3& point, float min_dist)
+{
+    mesh_query_point_t query;
+    query.sign = 0.0;
+    query.result = mesh_query_furthest_point_no_sign(id, point, min_dist, query.face, query.u, query.v);
+    return query;
+}
+
+CUDA_CALLABLE inline mesh_query_point_t mesh_query_point_sign_normal(uint64_t id, const vec3& point, float max_dist, const float epsilon = 1e-3f)
+{
+    mesh_query_point_t query;
+    query.result = mesh_query_point_sign_normal(id, point, max_dist, query.sign, query.face, query.u, query.v, epsilon);
+    return query;
+}
+
+CUDA_CALLABLE inline mesh_query_point_t mesh_query_point_sign_winding_number(uint64_t id, const vec3& point, float max_dist, float accuracy, float winding_number_threshold)
+{
+    mesh_query_point_t query;
+    query.result = mesh_query_point_sign_winding_number(id, point, max_dist, query.sign, query.face, query.u, query.v, accuracy, winding_number_threshold);
+    return query;
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_point(uint64_t id, const vec3& point, float max_dist, const mesh_query_point_t& ret,
+                                               uint64_t adj_id, vec3& adj_point, float& adj_max_dist, mesh_query_point_t& adj_ret)
+{
+    adj_mesh_query_point(id, point, max_dist, ret.sign, ret.face, ret.u, ret.v,
+                         adj_id, adj_point, adj_max_dist, adj_ret.sign, adj_ret.face, adj_ret.u, adj_ret.v, adj_ret.result);
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_point_no_sign(uint64_t id, const vec3& point, float max_dist, const mesh_query_point_t& ret,
+                                                       uint64_t adj_id, vec3& adj_point, float& adj_max_dist, mesh_query_point_t& adj_ret)
+{
+    adj_mesh_query_point_no_sign(id, point, max_dist, ret.face, ret.u, ret.v,
+                                adj_id, adj_point, adj_max_dist, adj_ret.face, adj_ret.u, adj_ret.v, adj_ret.result);
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_furthest_point_no_sign(uint64_t id, const vec3& point, float min_dist, const mesh_query_point_t& ret,
+                                                                uint64_t adj_id, vec3& adj_point, float& adj_min_dist, mesh_query_point_t& adj_ret)
+{
+    adj_mesh_query_furthest_point_no_sign(id, point, min_dist, ret.face, ret.u, ret.v,
+                                          adj_id, adj_point, adj_min_dist, adj_ret.face, adj_ret.u, adj_ret.v, adj_ret.result);
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_point_sign_normal(uint64_t id, const vec3& point, float max_dist, float epsilon, const mesh_query_point_t& ret,
+                                                           uint64_t adj_id, vec3& adj_point, float& adj_max_dist, float& adj_epsilon, mesh_query_point_t& adj_ret)
+{
+    adj_mesh_query_point_sign_normal(id, point, max_dist, ret.sign, ret.face, ret.u, ret.v, epsilon,
+                                     adj_id, adj_point, adj_max_dist, adj_ret.sign, adj_ret.face, adj_ret.u, adj_ret.v, epsilon, adj_ret.result);
+}
+
+CUDA_CALLABLE inline void adj_mesh_query_point_sign_winding_number(uint64_t id, const vec3& point, float max_dist, float accuracy, float winding_number_threshold, const mesh_query_point_t& ret,
+                                                                   uint64_t adj_id, vec3& adj_point, float& adj_max_dist, float& adj_accuracy, float& adj_winding_number_threshold, mesh_query_point_t& adj_ret)
+{
+    adj_mesh_query_point_sign_winding_number(id, point, max_dist, ret.sign, ret.face, ret.u, ret.v, accuracy, winding_number_threshold,
+                                             adj_id, adj_point, adj_max_dist, adj_ret.sign, adj_ret.face, adj_ret.u, adj_ret.v, adj_accuracy, adj_winding_number_threshold, adj_ret.result);
+}
+
 CUDA_CALLABLE inline bool mesh_query_ray(uint64_t id, const vec3& start, const vec3& dir, float max_t, float& t, float& u, float& v, float& sign, vec3& normal, int& face)
 {
     Mesh mesh = mesh_get(id);
 
-    if (mesh.bvh.num_nodes == 0)
-        return false;
-
     int stack[32];
-    stack[0] = mesh.bvh.root;
+    stack[0] = *mesh.bvh.root;
     int count = 1;
 
     vec3 rcp_dir = vec3(1.0f/dir[0], 1.0f/dir[1], 1.0f/dir[2]);
@@ -1109,6 +1445,35 @@ CUDA_CALLABLE inline void adj_mesh_query_ray(
 }
 
 
+// Stores the result of querying the closest point on a mesh.
+struct mesh_query_ray_t
+{
+    CUDA_CALLABLE mesh_query_ray_t()
+    {
+    }
+
+    CUDA_CALLABLE mesh_query_ray_t(int)
+    {
+        // For backward pass.
+    }
+
+    bool result;
+    float sign;
+    int face;
+    float t;
+    float u;
+    float v;
+    vec3 normal;
+};
+
+CUDA_CALLABLE inline mesh_query_ray_t mesh_query_ray(uint64_t id, const vec3& start, const vec3& dir, float max_t)
+{
+    mesh_query_ray_t query;
+    query.result = mesh_query_ray(id, start, dir, max_t, query.t, query.u, query.v, query.sign, query.normal, query.face);
+    return query;
+}
+
+
 // determine if a point is inside (ret < 0 ) or outside the mesh (ret > 0)
 CUDA_CALLABLE inline float mesh_query_inside(uint64_t id, const vec3& p)
 {
@@ -1170,19 +1535,9 @@ CUDA_CALLABLE inline mesh_query_aabb_t mesh_query_aabb(
     query.face = -1;
 
     Mesh mesh = mesh_get(id);
-
     query.mesh = mesh;
     
-    // if no bvh nodes, return empty query.
-    if (mesh.bvh.num_nodes == 0)
-    {
-        query.count = 0;
-        return query;
-    }
-
-    // optimization: make the latest
-    
-    query.stack[0] = mesh.bvh.root;
+    query.stack[0] = *mesh.bvh.root;
     query.count = 1;
     query.input_lower = lower;
     query.input_upper = upper;