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

warp/native/fabric.h

@@ -0,0 +1,228 @@
+#pragma once
+
+#include "builtin.h"
+
+namespace wp
+{
+
+struct fabricbucket_t
+{
+    size_t index_start;
+    size_t index_end;
+    void* ptr;
+    size_t* lengths;
+};
+
+
+template <typename T>
+struct fabricarray_t
+{
+    CUDA_CALLABLE inline fabricarray_t()
+        : nbuckets(0),
+          size(0)
+    {}
+
+    CUDA_CALLABLE inline bool empty() const { return !size; }
+
+    fabricbucket_t* buckets;  // array of fabricbucket_t on the correct device
+
+    size_t nbuckets;
+    size_t size;
+};
+
+
+template <typename T>
+struct indexedfabricarray_t
+{
+    CUDA_CALLABLE inline indexedfabricarray_t()
+        : indices(),
+          size(0)
+    {}
+
+    CUDA_CALLABLE inline bool empty() const { return !size; }
+
+    fabricarray_t<T> fa;
+
+    // TODO: we use 32-bit indices for consistency with other Warp indexed arrays,
+    // but Fabric uses 64-bit indexing.
+    int* indices;
+    size_t size;
+};
+
+
+#ifndef FABRICARRAY_USE_BINARY_SEARCH
+#define FABRICARRAY_USE_BINARY_SEARCH 1
+#endif
+
+template <typename T>
+CUDA_CALLABLE inline const fabricbucket_t* fabricarray_find_bucket(const fabricarray_t<T>& fa, size_t i)
+{
+#if FABRICARRAY_USE_BINARY_SEARCH
+    // use binary search to find the right bucket
+    const fabricbucket_t* bucket = nullptr;
+    size_t lo = 0;
+    size_t hi = fa.nbuckets - 1;
+    while (hi >= lo)
+    {
+        size_t mid = (lo + hi) >> 1;
+        bucket = fa.buckets + mid;
+        if (i >= bucket->index_end)
+            lo = mid + 1;
+        else if (i < bucket->index_start)
+            hi = mid - 1;
+        else
+            return bucket;
+    }
+    return nullptr;
+#else
+    // use linear search to find the right bucket
+    const fabricbucket_t* bucket = fa.buckets;
+    const fabricbucket_t* bucket_end = bucket + fa.nbuckets;
+    for (; bucket < bucket_end; ++bucket)
+    {
+        if (i < bucket->index_end)
+            return bucket;
+    }
+    return nullptr;
+#endif
+}
+
+
+// Compute the pointer to a fabricarray element at index i.
+// This function is similar to wp::index(), but the array data type doesn't need to be known at compile time.
+CUDA_CALLABLE inline void* fabricarray_element_ptr(const fabricarray_t<void>& fa, size_t i, size_t elem_size)
+{
+    const fabricbucket_t* bucket = fabricarray_find_bucket(fa, i);
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    return (char*)bucket->ptr + index_in_bucket * elem_size;
+}
+
+
+template <typename T>
+CUDA_CALLABLE inline T& index(const fabricarray_t<T>& fa, size_t i)
+{
+    const fabricbucket_t* bucket = fabricarray_find_bucket(fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    T& result = *((T*)bucket->ptr + index_in_bucket);
+
+    FP_VERIFY_FWD_1(result)
+
+    return result;
+}
+
+
+// indexing for fabric array of arrays
+template <typename T>
+CUDA_CALLABLE inline T& index(const fabricarray_t<T>& fa, size_t i, size_t j)
+{
+    const fabricbucket_t* bucket = fabricarray_find_bucket(fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    assert(bucket->lengths && "Missing inner array lengths");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    void* ptr = *((void**)bucket->ptr + index_in_bucket);
+    size_t length = *((size_t*)bucket->lengths + index_in_bucket);
+
+    assert(j < length && "Fabric array inner index out of range");
+
+    T& result = *((T*)ptr + j);
+
+    FP_VERIFY_FWD_1(result)
+
+    return result;
+}
+
+
+template <typename T>
+CUDA_CALLABLE inline array_t<T> view(fabricarray_t<T>& fa, size_t i)
+{
+    const fabricbucket_t* bucket = fabricarray_find_bucket(fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    assert(bucket->lengths && "Missing inner array lengths");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    void* ptr = *((void**)bucket->ptr + index_in_bucket);
+    size_t length = *((size_t*)bucket->lengths + index_in_bucket);
+
+    return array_t<T>((T*)ptr, int(length));
+}
+
+
+template <typename T>
+CUDA_CALLABLE inline T& index(const indexedfabricarray_t<T>& ifa, size_t i)
+{
+    // index lookup
+    assert(i < ifa.size);
+    i = size_t(ifa.indices[i]);
+
+    const fabricbucket_t* bucket = fabricarray_find_bucket(ifa.fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    T& result = *((T*)bucket->ptr + index_in_bucket);
+
+    FP_VERIFY_FWD_1(result)
+
+    return result;
+}
+
+
+// indexing for fabric array of arrays
+template <typename T>
+CUDA_CALLABLE inline T& index(const indexedfabricarray_t<T>& ifa, size_t i, size_t j)
+{
+    // index lookup
+    assert(i < ifa.size);
+    i = size_t(ifa.indices[i]);
+
+    const fabricbucket_t* bucket = fabricarray_find_bucket(ifa.fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    assert(bucket->lengths && "Missing inner array lengths");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    void* ptr = *((void**)bucket->ptr + index_in_bucket);
+    size_t length = *((size_t*)bucket->lengths + index_in_bucket);
+
+    assert(j < length && "Fabric array inner index out of range");
+
+    T& result = *((T*)ptr + j);
+
+    FP_VERIFY_FWD_1(result)
+
+    return result;
+}
+
+
+template <typename T>
+CUDA_CALLABLE inline array_t<T> view(indexedfabricarray_t<T>& ifa, size_t i)
+{
+    // index lookup
+    assert(i < ifa.size);
+    i = size_t(ifa.indices[i]);
+
+    const fabricbucket_t* bucket = fabricarray_find_bucket(ifa.fa, i);
+    assert(bucket && "Fabric array index out of range");
+
+    assert(bucket->lengths && "Missing inner array lengths");
+
+    size_t index_in_bucket = i - bucket->index_start;
+
+    void* ptr = *((void**)bucket->ptr + index_in_bucket);
+    size_t length = *((size_t*)bucket->lengths + index_in_bucket);
+
+    return array_t<T>((T*)ptr, int(length));
+}
+
+} // namespace wp

warp/native/hashgrid.cpp

@@ -93,8 +93,8 @@ void hash_grid_reserve_host(uint64_t id, int num_points)
         free_host(grid->point_ids);
         
         const int num_to_alloc = num_points*3/2;
-        grid->point_cells = (int*)alloc_host(2*num_to_alloc*sizeof(int));  // *2 for auxilliary radix buffers
-        grid->point_ids = (int*)alloc_host(2*num_to_alloc*sizeof(int));    // *2 for auxilliary radix buffers
+        grid->point_cells = (int*)alloc_host(2*num_to_alloc*sizeof(int));  // *2 for auxiliary radix buffers
+        grid->point_ids = (int*)alloc_host(2*num_to_alloc*sizeof(int));    // *2 for auxiliary radix buffers
 
         grid->max_points = num_to_alloc;
     }
@@ -212,8 +212,8 @@ void hash_grid_reserve_device(uint64_t id, int num_points)
             free_device(WP_CURRENT_CONTEXT, grid.point_ids);
             
             const int num_to_alloc = num_points*3/2;
-            grid.point_cells = (int*)alloc_device(WP_CURRENT_CONTEXT, 2*num_to_alloc*sizeof(int));  // *2 for auxilliary radix buffers
-            grid.point_ids = (int*)alloc_device(WP_CURRENT_CONTEXT, 2*num_to_alloc*sizeof(int));    // *2 for auxilliary radix buffers
+            grid.point_cells = (int*)alloc_device(WP_CURRENT_CONTEXT, 2*num_to_alloc*sizeof(int));  // *2 for auxiliary radix buffers
+            grid.point_ids = (int*)alloc_device(WP_CURRENT_CONTEXT, 2*num_to_alloc*sizeof(int));    // *2 for auxiliary radix buffers
             grid.max_points = num_to_alloc;
 
             // ensure we pre-size our sort routine to avoid

warp/native/hashgrid.h

@@ -75,8 +75,28 @@ CUDA_CALLABLE inline int hash_grid_index(const HashGrid& grid, const vec3& p)
 // stores state required to traverse neighboring cells of a point
 struct hash_grid_query_t
 {
-    CUDA_CALLABLE hash_grid_query_t() {}
-    CUDA_CALLABLE hash_grid_query_t(int) {} // for backward pass
+    CUDA_CALLABLE hash_grid_query_t()
+        : x_start(0),
+          y_start(0),
+          z_start(0),
+          x_end(0),
+          y_end(0),
+          z_end(0),
+          x(0),
+          y(0),
+          z(0),
+          cell(0),
+          cell_index(0),
+          cell_end(0),
+          current(0),
+          grid()
+    {}
+
+    // Required for adjoint computations.
+    CUDA_CALLABLE inline hash_grid_query_t& operator+=(const hash_grid_query_t& other)
+    {
+        return *this;
+    }
 
     int x_start;
     int y_start;

warp/native/initializer_array.h

@@ -18,12 +18,12 @@ struct initializer_array
 {
     const Type storage[Length];
 
-    const Type operator[](unsigned i)
+    CUDA_CALLABLE const Type operator[](unsigned i)
     {
         return storage[i];
     }
 
-    const Type operator[](unsigned i) const
+    CUDA_CALLABLE const Type operator[](unsigned i) const
     {
         return storage[i];
     }

warp/native/intersect.h

@@ -114,6 +114,21 @@ CUDA_CALLABLE inline vec2 closest_point_to_triangle(const vec3& a, const vec3& b
 	return vec2(u, v);
 }
 
+CUDA_CALLABLE inline vec2 furthest_point_to_triangle(const vec3& a, const vec3& b, const vec3& c, const vec3& p)
+{
+    vec3 pa = p-a;
+    vec3 pb = p-b;
+    vec3 pc = p-c;
+    float dist_a = dot(pa, pa);
+    float dist_b = dot(pb, pb);
+    float dist_c = dot(pc, pc);
+
+    if (dist_a > dist_b && dist_a > dist_c) 
+        return vec2(1.0f, 0.0f); // a is furthest
+    if (dist_b > dist_c)
+        return vec2(0.0f, 1.0f); // b is furthest
+    return vec2(0.0f, 0.0f); // c is furthest
+}
 
 CUDA_CALLABLE inline bool intersect_ray_aabb(const vec3& pos, const vec3& rcp_dir, const vec3& lower, const vec3& upper, float& t)
 {
@@ -357,8 +372,8 @@ CUDA_CALLABLE inline bool intersect_ray_tri_woop(const vec3& p, const vec3& dir,
 }
 
 CUDA_CALLABLE inline void adj_intersect_ray_tri_woop(
-    const vec3& p, const vec3& dir, const vec3& a, const vec3& b, const vec3& c, float& t, float& u, float& v, float& sign, vec3* normal,
-    vec3& adj_p, vec3& adj_dir, vec3& adj_a, vec3& adj_b, vec3& adj_c, float& adj_t, float& adj_u, float& adj_v, float& adj_sign, vec3* adj_normal, bool& adj_ret)
+    const vec3& p, const vec3& dir, const vec3& a, const vec3& b, const vec3& c, float t, float u, float v, float sign, const vec3& normal,
+    vec3& adj_p, vec3& adj_dir, vec3& adj_a, vec3& adj_b, vec3& adj_c, float& adj_t, float& adj_u, float& adj_v, float& adj_sign, vec3& adj_normal, bool& adj_ret)
 {
 
 	// todo: precompute for ray
@@ -854,7 +869,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     wp::adj_sub(var_9, var_71, adj_9, adj_71, adj_73);
     wp::adj_mul(var_21, var_70, adj_21, adj_70, adj_72);
     wp::adj_mul(var_41, var_70, adj_41, adj_70, adj_71);
-    wp::adj_div(var_9, var_69, adj_9, adj_69, adj_70);
+    wp::adj_div(var_9, var_69, var_70, adj_9, adj_69, adj_70);
     wp::adj_add(var_68, var_21, adj_68, adj_21, adj_69);
     wp::adj_add(var_53, var_41, adj_53, adj_41, adj_68);
     wp::adj_select(var_64, var_50, var_66, adj_64, adj_50, adj_66, adj_67);
@@ -866,7 +881,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     }
     wp::adj_sub(var_32, var_33, adj_32, adj_33, adj_62);
     wp::adj_sub(var_13, var_12, adj_13, adj_12, adj_60);
-    wp::adj_div(var_54, var_57, adj_54, adj_57, adj_58);
+    wp::adj_div(var_54, var_57, var_58, adj_54, adj_57, adj_58);
     wp::adj_add(var_55, var_56, adj_55, adj_56, adj_57);
     wp::adj_sub(var_32, var_33, adj_32, adj_33, adj_56);
     wp::adj_sub(var_13, var_12, adj_13, adj_12, adj_55);
@@ -881,7 +896,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     	wp::adj_vec2(var_48, var_5, adj_48, adj_5, adj_49);
     	wp::adj_sub(var_9, var_43, adj_9, adj_43, adj_48);
     }
-    wp::adj_div(var_4, var_42, adj_4, adj_42, adj_43);
+    wp::adj_div(var_4, var_42, var_43, adj_4, adj_42, adj_43);
     wp::adj_sub(var_4, var_33, adj_4, adj_33, adj_42);
     wp::adj_sub(var_39, var_40, adj_39, adj_40, adj_41);
     wp::adj_mul(var_3, var_33, adj_3, adj_33, adj_40);
@@ -902,7 +917,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     	wp::adj_vec2(var_28, var_23, adj_28, adj_23, adj_29);
     	wp::adj_sub(var_9, var_23, adj_9, adj_23, adj_28);
     }
-    wp::adj_div(var_3, var_22, adj_3, adj_22, adj_23);
+    wp::adj_div(var_3, var_22, var_23, adj_3, adj_22, adj_23);
     wp::adj_sub(var_3, var_12, adj_3, adj_12, adj_22);
     wp::adj_sub(var_19, var_20, adj_19, adj_20, adj_21);
     wp::adj_mul(var_12, var_4, adj_12, adj_4, adj_20);
@@ -974,7 +989,7 @@ def closest_point_edge_edge(
     else:
         c = wp.dot(d1, r)
         if e <= epsilon:
-            # second segment genereates into a point
+            # second segment generates into a point
             s = wp.clamp(-c / a, 0.0, 1.0)  # t = 0 => s = (b*t-c)/a = -c/a
             t = float(0.0)
         else:

warp/native/intersect_adj.h

@@ -276,7 +276,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     label1:;
     adj_71 += adj_ret;
     wp::adj_vec3(var_61, var_62, var_70, adj_61, adj_62, adj_70, adj_71);
-    wp::adj_length(var_69, adj_69, adj_70);
+    wp::adj_length(var_69, var_70, adj_69, adj_70);
     wp::adj_sub(var_68, var_65, adj_68, adj_65, adj_69);
     wp::adj_add(var_p2, var_67, adj_p2, adj_67, adj_68);
     wp::adj_mul(var_66, var_62, adj_66, adj_62, adj_67);
@@ -297,7 +297,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     			wp::adj_select(var_51, var_49, var_54, adj_51, adj_49, adj_54, adj_55);
     			if (var_51) {
     				wp::adj_clamp(var_53, var_6, var_25, adj_53, adj_6, adj_25, adj_54);
-    				wp::adj_div(var_52, var_3, adj_52, adj_3, adj_53);
+    				wp::adj_div(var_52, var_3, var_53, adj_52, adj_3, adj_53);
     				wp::adj_sub(var_30, var_21, adj_30, adj_21, adj_52);
     			}
     		}
@@ -305,10 +305,10 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     		wp::adj_select(var_45, var_41, var_48, adj_45, adj_41, adj_48, adj_49);
     		if (var_45) {
     			wp::adj_clamp(var_47, var_6, var_25, adj_47, adj_6, adj_25, adj_48);
-    			wp::adj_div(var_46, var_3, adj_46, adj_3, adj_47);
+    			wp::adj_div(var_46, var_3, var_47, adj_46, adj_3, adj_47);
     			wp::adj_neg(var_21, adj_21, adj_46);
     		}
-    		wp::adj_div(var_43, var_4, adj_43, adj_4, adj_44);
+    		wp::adj_div(var_43, var_4, var_44, adj_43, adj_4, adj_44);
     		wp::adj_add(var_42, var_5, adj_42, adj_5, adj_43);
     		wp::adj_mul(var_30, var_41, adj_30, adj_41, adj_42);
     		wp::adj_select(var_34, var_6, var_40, adj_34, adj_6, adj_40, adj_41);
@@ -317,7 +317,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     		wp::adj_select(var_34, var_28, var_39, adj_34, adj_28, adj_39, adj_40);
     		if (var_34) {
     			wp::adj_clamp(var_38, var_6, var_25, adj_38, adj_6, adj_25, adj_39);
-    			wp::adj_div(var_37, var_33, adj_37, adj_33, adj_38);
+    			wp::adj_div(var_37, var_33, var_38, adj_37, adj_33, adj_38);
     			wp::adj_sub(var_35, var_36, adj_35, adj_36, adj_37);
     			wp::adj_mul(var_21, var_4, adj_21, adj_4, adj_36);
     			wp::adj_mul(var_30, var_5, adj_30, adj_5, adj_35);
@@ -332,7 +332,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     	if (var_22) {
     		wp::adj_cast_float(var_6, adj_6, adj_27);
     		wp::adj_clamp(var_24, var_6, var_25, adj_24, adj_6, adj_25, adj_26);
-    		wp::adj_div(var_23, var_3, adj_23, adj_3, adj_24);
+    		wp::adj_div(var_23, var_3, var_24, adj_23, adj_3, adj_24);
     		wp::adj_neg(var_21, adj_21, adj_23);
     	}
     	wp::adj_dot(var_0, var_2, adj_0, adj_2, adj_21);
@@ -341,7 +341,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     wp::adj_select(var_15, var_7, var_16, adj_15, adj_7, adj_16, adj_19);
     if (var_15) {
     	wp::adj_cast_float(var_17, adj_17, adj_18);
-    	wp::adj_div(var_5, var_4, adj_5, adj_4, adj_17);
+    	wp::adj_div(var_5, var_4, var_17, adj_5, adj_4, adj_17);
     	wp::adj_cast_float(var_6, adj_6, adj_16);
     }
     if (var_13) {
@@ -349,7 +349,7 @@ static CUDA_CALLABLE void adj_closest_point_edge_edge(vec3 var_p1,
     	adj_14 += adj_ret;
     	wp::adj_vec3(var_7, var_8, var_10, adj_7, adj_8, adj_10, adj_14);
     }
-    wp::adj_length(var_9, adj_9, adj_10);
+    wp::adj_length(var_9, var_10, adj_9, adj_10);
     wp::adj_sub(var_p2, var_p1, adj_p2, adj_p1, adj_9);
     wp::adj_cast_float(var_6, adj_6, adj_8);
     wp::adj_cast_float(var_6, adj_6, adj_7);

warp/native/intersect_tri.h

@@ -32,9 +32,6 @@
  OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
-#define FABS(x) (float(fabs(x)))        /* implement as is fastest on your machine */
-
 /* if USE_EPSILON_TEST is true then we do a check:
          if |dv|<EPSILON then dv=0.0;
    else no check is done (which is less robust)
@@ -106,7 +103,7 @@
 #define POINT_IN_TRI(V0,U0,U1,U2)           \
 {                                           \
   float a,b,c,d0,d1,d2;                     \
-  /* is T1 completly inside T2? */          \
+  /* is T1 completely inside T2? */          \
   /* check if V0 is inside tri(U0,U1,U2) */ \
   a=U1[i1]-U0[i1];                          \
   b=-(U1[i0]-U0[i0]);                       \
@@ -135,9 +132,9 @@ CUDA_CALLABLE inline int coplanar_tri_tri(float N[3],float V0[3],float V1[3],flo
    short i0,i1;
    /* first project onto an axis-aligned plane, that maximizes the area */
    /* of the triangles, compute indices: i0,i1. */
-   A[0]=FABS(N[0]);
-   A[1]=FABS(N[1]);
-   A[2]=FABS(N[2]);
+   A[0]=fabsf(N[0]);
+   A[1]=fabsf(N[1]);
+   A[2]=fabsf(N[2]);
    if(A[0]>A[1])
    {
       if(A[0]>A[2])
@@ -242,9 +239,9 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
 
   /* coplanarity robustness check */
 #if USE_EPSILON_TEST==TRUE
-  if(FABS(du0)<EPSILON) du0=0.0;
-  if(FABS(du1)<EPSILON) du1=0.0;
-  if(FABS(du2)<EPSILON) du2=0.0;
+  if(fabsf(du0)<EPSILON) du0=0.0;
+  if(fabsf(du1)<EPSILON) du1=0.0;
+  if(fabsf(du2)<EPSILON) du2=0.0;
 #endif
   du0du1=du0*du1;
   du0du2=du0*du2;
@@ -265,9 +262,9 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
   dv2=DOT(N2,V2)+d2;
 
 #if USE_EPSILON_TEST==TRUE
-  if(FABS(dv0)<EPSILON) dv0=0.0;
-  if(FABS(dv1)<EPSILON) dv1=0.0;
-  if(FABS(dv2)<EPSILON) dv2=0.0;
+  if(fabsf(dv0)<EPSILON) dv0=0.0;
+  if(fabsf(dv1)<EPSILON) dv1=0.0;
+  if(fabsf(dv2)<EPSILON) dv2=0.0;
 #endif
 
   dv0dv1=dv0*dv1;
@@ -280,10 +277,10 @@ CUDA_CALLABLE inline int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
   CROSS(D,N1,N2);
 
   /* compute and index to the largest component of D */
-  max=(float)FABS(D[0]);
+  max=fabsf(D[0]);
   index=0;
-  bb=(float)FABS(D[1]);
-  cc=(float)FABS(D[2]);
+  bb=fabsf(D[1]);
+  cc=fabsf(D[2]);
   if(bb>max) max=bb,index=1;
   if(cc>max) max=cc,index=2;