warp-lang 1.3.1__py3-none-manylinux2014_aarch64.whl → 1.3.3__py3-none-manylinux2014_aarch64.whl

warp/tests/test_bvh.py

@@ -45,19 +45,19 @@ def aabb_overlap(a_lower, a_upper, b_lower, b_upper):
         return 1
 
 
-def intersect_ray_aabb(start, dir, lower, upper):
-    l1 = (lower[0] - start[0]) * dir[0]
-    l2 = (upper[0] - start[0]) * dir[0]
+def intersect_ray_aabb(start, rcp_dir, lower, upper):
+    l1 = (lower[0] - start[0]) * rcp_dir[0]
+    l2 = (upper[0] - start[0]) * rcp_dir[0]
     lmin = min(l1, l2)
     lmax = max(l1, l2)
 
-    l1 = (lower[1] - start[1]) * dir[1]
-    l2 = (upper[1] - start[1]) * dir[1]
+    l1 = (lower[1] - start[1]) * rcp_dir[1]
+    l2 = (upper[1] - start[1]) * rcp_dir[1]
     lmin = max(min(l1, l2), lmin)
     lmax = min(max(l1, l2), lmax)
 
-    l1 = (lower[2] - start[2]) * dir[2]
-    l2 = (upper[2] - start[2]) * dir[2]
+    l1 = (lower[2] - start[2]) * rcp_dir[2]
+    l2 = (upper[2] - start[2]) * rcp_dir[2]
     lmin = max(min(l1, l2), lmin)
     lmax = min(max(l1, l2), lmax)
 
@@ -108,7 +108,7 @@ def test_bvh(test, type, device):
             if type == "AABB":
                 host_intersected = aabb_overlap(lower, upper, query_lower, query_upper)
             else:
-                host_intersected = intersect_ray_aabb(query_start, query_dir, lower, upper)
+                host_intersected = intersect_ray_aabb(query_start, 1.0 / query_dir, lower, upper)
 
             test.assertEqual(host_intersected, device_intersected[i])
 
@@ -129,6 +129,30 @@ def test_bvh_query_ray(test, device):
     test_bvh(test, "ray", device)
 
 
+def test_gh_288(test, device):
+    num_bounds = 1
+    lowers = ((0.5, -1.0, -1.0),) * num_bounds
+    uppers = ((1.0, 1.0, 1.0),) * num_bounds
+
+    device_lowers = wp.array(lowers, dtype=wp.vec3f, device=device)
+    device_uppers = wp.array(uppers, dtype=wp.vec3f, device=device)
+
+    bvh = wp.Bvh(device_lowers, device_uppers)
+
+    bounds_intersected = wp.zeros(shape=num_bounds, dtype=int, device=device)
+
+    for x in (0.0, 0.75):
+        query_start = wp.vec3(x, 0.0, 0.0)
+        query_dir = wp.vec3(1.0, 0.0, 0.0)
+
+        wp.launch(
+            kernel=bvh_query_ray, dim=1, inputs=[bvh.id, query_start, query_dir, bounds_intersected], device=device
+        )
+
+        device_intersected = bounds_intersected.numpy()
+        test.assertEqual(device_intersected.sum(), num_bounds)
+
+
 devices = get_test_devices()
 
 
@@ -161,6 +185,7 @@ class TestBvh(unittest.TestCase):
 
 add_function_test(TestBvh, "test_bvh_aabb", test_bvh_query_aabb, devices=devices)
 add_function_test(TestBvh, "test_bvh_ray", test_bvh_query_ray, devices=devices)
+add_function_test(TestBvh, "test_gh_288", test_gh_288, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

warp/tests/test_compile_consts.py

@@ -18,6 +18,8 @@ UNIT_VEC = wp.constant(wp.vec3(SQRT3_OVER_3, SQRT3_OVER_3, SQRT3_OVER_3))
 ONE_FP16 = wp.constant(wp.float16(1.0))
 TEST_BOOL = wp.constant(True)
 
+SHADOWED_GLOBAL = wp.constant(17)
+
 
 class Foobar:
     ONE = wp.constant(1)
@@ -68,6 +70,18 @@ def test_closure_capture(test, device):
     wp.launch(two_closure, dim=(1), inputs=[2], device=device)
 
 
+def test_closure_precedence(test, device):
+    """Verifies that closure constants take precedence over globals"""
+
+    SHADOWED_GLOBAL = wp.constant(42)
+
+    @wp.kernel
+    def closure_kernel():
+        wp.expect_eq(SHADOWED_GLOBAL, 42)
+
+    wp.launch(closure_kernel, dim=1, device=device)
+
+
 def test_hash_global_capture(test, device):
     """Verifies that global variables are included in the module hash"""
 
@@ -206,6 +220,7 @@ add_kernel_test(TestConstants, test_int, dim=1, inputs=[a], devices=devices)
 add_kernel_test(TestConstants, test_float, dim=1, inputs=[x], devices=devices)
 
 add_function_test(TestConstants, "test_closure_capture", test_closure_capture, devices=devices)
+add_function_test(TestConstants, "test_closure_precedence", test_closure_precedence, devices=devices)
 add_function_test(TestConstants, "test_hash_global_capture", test_hash_global_capture, devices=devices)
 add_function_test(TestConstants, "test_hash_redefine_kernel", test_hash_redefine_kernel, devices=devices)
 add_function_test(TestConstants, "test_hash_redefine_constant_only", test_hash_redefine_constant_only, devices=devices)

warp/tests/test_examples.py

@@ -250,7 +250,11 @@ add_example_test(
     test_options_cpu={"num_frames": 10},
 )
 add_example_test(
-    TestOptimExamples, name="optim.example_cloth_throw", devices=test_devices, test_options_cpu={"train_iters": 3}
+    TestOptimExamples,
+    name="optim.example_cloth_throw",
+    devices=test_devices,
+    test_options={"test_timeout": 600},
+    test_options_cpu={"train_iters": 3},
 )
 add_example_test(
     TestOptimExamples,
@@ -390,6 +394,7 @@ add_example_test(
     name="fem.example_mixed_elasticity",
     devices=test_devices,
     test_options={"nonconforming_stresses": True, "mesh": "quad", "headless": True},
+    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples, name="fem.example_stokes_transfer", devices=test_devices, test_options={"headless": True}

warp/tests/test_fem.py

@@ -1252,6 +1252,8 @@ def test_particle_quadratures(test, device):
     geo = fem.Grid2D(res=wp.vec2i(2))
 
     domain = fem.Cells(geo)
+
+    # Explicit quadrature
     points, weights = domain.reference_element().instantiate_quadrature(order=4, family=fem.Polynomial.GAUSS_LEGENDRE)
     points_per_cell = len(points)
 
@@ -1266,9 +1268,16 @@ def test_particle_quadratures(test, device):
     test.assertEqual(explicit_quadrature.max_points_per_element(), points_per_cell)
     test.assertEqual(explicit_quadrature.total_point_count(), points_per_cell * geo.cell_count())
 
+    # test integration accuracy
     val = fem.integrate(_bicubic, quadrature=explicit_quadrature)
     test.assertAlmostEqual(val, 1.0 / 16, places=5)
 
+    # test indexing validity
+    arr = wp.empty(explicit_quadrature.total_point_count(), dtype=float)
+    fem.interpolate(_piecewise_constant, dest=arr, quadrature=explicit_quadrature)
+    assert_np_equal(arr.numpy(), np.arange(geo.cell_count()).repeat(points_per_cell))
+
+    # PIC quadrature
     element_indices = wp.array([3, 3, 2], dtype=int, device=device)
     element_coords = wp.array(
         [
@@ -1286,6 +1295,7 @@ def test_particle_quadratures(test, device):
     test.assertEqual(pic_quadrature.total_point_count(), 3)
     test.assertEqual(pic_quadrature.active_cell_count(), 2)
 
+    # Test integration accuracy
     val = fem.integrate(_piecewise_constant, quadrature=pic_quadrature)
     test.assertAlmostEqual(val, 1.25, places=5)
 
@@ -1305,6 +1315,46 @@ def test_particle_quadratures(test, device):
     assert_np_equal(measures.grad.numpy(), np.full(3, 4.0))  # == 1.0 / cell_area
 
 
+@fem.integrand
+def _value_at_node(s: fem.Sample, f: fem.Field, values: wp.array(dtype=float)):
+    node_index = fem.operator.node_partition_index(f, s.qp_index)
+    return values[node_index]
+
+
+def test_nodal_quadrature(test, device):
+    geo = fem.Grid2D(res=wp.vec2i(2))
+
+    domain = fem.Cells(geo)
+
+    space = fem.make_polynomial_space(geo, degree=2, discontinuous=True, family=fem.Polynomial.GAUSS_LEGENDRE)
+    nodal_quadrature = fem.NodalQuadrature(domain, space)
+
+    test.assertEqual(nodal_quadrature.max_points_per_element(), 9)
+    test.assertEqual(nodal_quadrature.total_point_count(), 9 * geo.cell_count())
+
+    val = fem.integrate(_bicubic, quadrature=nodal_quadrature)
+    test.assertAlmostEqual(val, 1.0 / 16, places=5)
+
+    # test accessing data associated to a given node
+
+    piecewise_constant_space = fem.make_polynomial_space(geo, degree=0)
+    geo_partition = fem.LinearGeometryPartition(geo, 3, 4)
+    space_partition = fem.make_space_partition(piecewise_constant_space, geo_partition)
+    field = fem.make_discrete_field(piecewise_constant_space, space_partition=space_partition)
+
+    partition_domain = fem.Cells(geo_partition)
+    partition_nodal_quadrature = fem.NodalQuadrature(partition_domain, piecewise_constant_space)
+
+    partition_node_values = wp.array([5.0], dtype=float)
+    val = fem.integrate(
+        _value_at_node,
+        quadrature=partition_nodal_quadrature,
+        fields={"f": field},
+        values={"values": partition_node_values},
+    )
+    test.assertAlmostEqual(val, 5.0 / geo.cell_count(), places=5)
+
+
 @wp.func
 def aniso_bicubic_fn(x: wp.vec2, scale: wp.vec2):
     return wp.pow(x[0] * scale[0], 3.0) * wp.pow(x[1] * scale[1], 3.0)
@@ -1485,6 +1535,7 @@ add_function_test(TestFem, "test_deformed_geometry", test_deformed_geometry, dev
 add_function_test(TestFem, "test_dof_mapper", test_dof_mapper)
 add_function_test(TestFem, "test_point_basis", test_point_basis)
 add_function_test(TestFem, "test_particle_quadratures", test_particle_quadratures)
+add_function_test(TestFem, "test_nodal_quadrature", test_nodal_quadrature)
 add_function_test(TestFem, "test_implicit_fields", test_implicit_fields)
 add_kernel_test(TestFem, test_qr_eigenvalues, dim=1, devices=devices)
 add_kernel_test(TestFem, test_qr_inverse, dim=100, devices=devices)

warp/tests/test_grad_debug.py

@@ -93,7 +93,8 @@ def test_gradcheck_3d(test, device):
         inputs=[a_3d, b_3d, c_3d],
         outputs=[out1_3d, out2_3d],
         max_inputs_per_var=4,
-        input_output_mask=[("a", "out1"), ("b", "out2")],
+        # use integer indices instead of variable names
+        input_output_mask=[(0, 0), (1, 1)],
         eps=1e-4,
     )
 

warp/tests/test_model.py

@@ -102,6 +102,61 @@ class TestModel(unittest.TestCase):
         assert_np_equal(np.array(builder1.edge_rest_angle), np.array(builder2.edge_rest_angle), tol=1.0e-4)
         assert_np_equal(np.array(builder1.edge_bending_properties), np.array(builder2.edge_bending_properties))
 
+    def test_collapse_fixed_joints(self):
+        def add_three_cubes(builder: ModelBuilder, parent_body=-1):
+            unit_cube = {"hx": 0.5, "hy": 0.5, "hz": 0.5, "density": 1.0}
+            b0 = builder.add_body()
+            builder.add_shape_box(body=b0, **unit_cube)
+            builder.add_joint_fixed(parent=parent_body, child=b0, parent_xform=wp.transform(wp.vec3(1.0, 0.0, 0.0)))
+            b1 = builder.add_body()
+            builder.add_shape_box(body=b1, **unit_cube)
+            builder.add_joint_fixed(parent=parent_body, child=b1, parent_xform=wp.transform(wp.vec3(0.0, 1.0, 0.0)))
+            b2 = builder.add_body()
+            builder.add_shape_box(body=b2, **unit_cube)
+            builder.add_joint_fixed(parent=parent_body, child=b2, parent_xform=wp.transform(wp.vec3(0.0, 0.0, 1.0)))
+            return b2
+
+        builder = ModelBuilder()
+        # only fixed joints
+        builder.add_articulation()
+        add_three_cubes(builder)
+        assert builder.joint_count == 3
+        assert builder.body_count == 3
+
+        # fixed joints followed by a non-fixed joint
+        builder.add_articulation()
+        last_body = add_three_cubes(builder)
+        assert builder.joint_count == 6
+        assert builder.body_count == 6
+        assert builder.articulation_count == 2
+        b3 = builder.add_body()
+        builder.add_shape_box(body=b3, hx=0.5, hy=0.5, hz=0.5, density=1.0, pos=wp.vec3(1.0, 2.0, 3.0))
+        builder.add_joint_revolute(parent=last_body, child=b3, axis=wp.vec3(0.0, 1.0, 0.0))
+
+        # a non-fixed joint followed by fixed joints
+        builder.add_articulation()
+        b4 = builder.add_body()
+        builder.add_shape_box(body=b4, hx=0.5, hy=0.5, hz=0.5, density=1.0)
+        builder.add_joint_free(parent=-1, child=b4, parent_xform=wp.transform(wp.vec3(0.0, -1.0, 0.0)))
+        assert builder.joint_count == 8
+        assert builder.body_count == 8
+        assert builder.articulation_count == 3
+        add_three_cubes(builder, parent_body=b4)
+
+        builder.collapse_fixed_joints()
+
+        assert builder.joint_count == 2
+        assert builder.articulation_count == 2
+        assert builder.articulation_start == [0, 1]
+        assert builder.joint_type == [wp.sim.JOINT_REVOLUTE, wp.sim.JOINT_FREE]
+        assert builder.shape_count == 11
+        assert builder.shape_body == [-1, -1, -1, -1, -1, -1, 0, 1, 1, 1, 1]
+        assert builder.body_count == 2
+        assert builder.body_com[0] == wp.vec3(1.0, 2.0, 3.0)
+        assert builder.body_com[1] == wp.vec3(0.25, 0.25, 0.25)
+        assert builder.body_mass == [1.0, 4.0]
+        assert builder.body_inv_mass == [1.0, 0.25]
+
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

warp/tests/test_point_triangle_closest_point.py

@@ -0,0 +1,143 @@
+# Copyright (c) 2024 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import unittest
+
+from warp.sim.collide import triangle_closest_point_barycentric
+from warp.tests.unittest_utils import *
+
+
+# a-b is the edge where the closest point is located at
+@wp.func
+def check_edge_feasible_region(p: wp.vec3, a: wp.vec3, b: wp.vec3, c: wp.vec3, eps: float):
+    ap = p - a
+    bp = p - b
+    ab = b - a
+
+    if wp.dot(ap, ab) < -eps:
+        return False
+
+    if wp.dot(bp, ab) > eps:
+        return False
+
+    ab_sqr_norm = wp.dot(ab, ab)
+    if ab_sqr_norm < eps:
+        return False
+
+    t = wp.dot(ab, c - a) / ab_sqr_norm
+
+    perpendicular_foot = a + t * ab
+
+    if wp.dot(c - perpendicular_foot, p - perpendicular_foot) > eps:
+        return False
+
+    return True
+
+
+# closest point is a
+@wp.func
+def check_vertex_feasible_region(p: wp.vec3, a: wp.vec3, b: wp.vec3, c: wp.vec3, eps: float):
+    ap = p - a
+    ba = a - b
+    ca = a - c
+
+    if wp.dot(ap, ba) < -eps:
+        return False
+
+    if wp.dot(p, ca) < -eps:
+        return False
+
+    return True
+
+
+@wp.func
+def return_true():
+    return True
+
+
+def test_point_triangle_closest_point(test, device):
+    passed = wp.array([True], dtype=wp.bool, device=device)
+
+    @wp.kernel
+    def test_point_triangle_closest_point_kernel(tri: wp.array(dtype=wp.vec3), passed: wp.array(dtype=wp.bool)):
+        state = wp.uint32(wp.rand_init(wp.int32(123), wp.int32(0)))
+        eps = 1e-5
+
+        for _i in range(1000):
+            l = wp.float32(0.0)
+            while l < eps:
+                p = wp.vec3(wp.randn(state), wp.randn(state), wp.randn(state))
+                l = wp.length(p)
+
+            # project to a sphere with r=2
+            p = 2.0 * p / l
+
+            bary = triangle_closest_point_barycentric(tri[0], tri[1], tri[2], p)
+
+            for dim in range(3):
+                v1_index = (dim + 1) % 3
+                v2_index = (dim + 2) % 3
+                v1 = tri[v1_index]
+                v2 = tri[v2_index]
+                v3 = tri[dim]
+
+                # on edge
+                if bary[dim] == 0.0 and bary[v1_index] != 0.0 and bary[v2_index] != 0.0:
+                    if not check_edge_feasible_region(p, v1, v2, v3, eps):
+                        passed[0] = False
+                        return
+
+                    # p-closest_p must be perpendicular to v1-v2
+                    closest_p = a * bary[0] + b * bary[1] + c * bary[2]
+                    e = v1 - v2
+                    err = wp.dot(e, closest_p - p)
+                    if wp.abs(err) > eps:
+                        passed[0] = False
+                        return
+
+                if bary[v1_index] == 0.0 and bary[v2_index] == 0.0:
+                    if not check_vertex_feasible_region(p, v3, v1, v2, eps):
+                        passed[0] = False
+                        return
+
+                if bary[dim] != 0.0 and bary[v1_index] != 0.0 and bary[v2_index] != 0.0:
+                    closest_p = a * bary[0] + b * bary[1] + c * bary[2]
+                    e1 = v1 - v2
+                    e2 = v1 - v3
+                    if wp.abs(wp.dot(e1, closest_p - p)) > eps or wp.abs(wp.dot(e2, closest_p - p)) > eps:
+                        passed[0] = False
+                        return
+
+    a = wp.vec3(1.0, 0.0, 0.0)
+    b = wp.vec3(0.0, 0.0, 0.0)
+    c = wp.vec3(0.0, 1.0, 0.0)
+
+    tri = wp.array([a, b, c], dtype=wp.vec3, device=device)
+    wp.launch(test_point_triangle_closest_point_kernel, dim=1, inputs=[tri, passed], device=device)
+    passed = passed.numpy()
+
+    test.assertTrue(passed.all())
+
+
+devices = get_test_devices()
+
+
+class TestTriangleClosestPoint(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestTriangleClosestPoint,
+    "test_point_triangle_closest_point",
+    test_point_triangle_closest_point,
+    devices=devices,
+    check_output=True,
+)
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_reload.py

@@ -189,7 +189,32 @@ def test_reload_references(test, device):
     test_dependent.run(expect=4.0, device=device)  # 2 * 2 = 4
 
 
+def test_graph_launch_after_module_reload(test, device):
+    @wp.kernel
+    def foo(a: wp.array(dtype=int)):
+        a[0] = 42
+
+    with wp.ScopedDevice(device):
+        a = wp.zeros(1, dtype=int)
+
+        # preload module before graph capture
+        wp.load_module(device=device)
+
+        # capture a launch
+        with wp.ScopedCapture(force_module_load=False) as capture:
+            wp.launch(foo, dim=1, inputs=[a])
+
+        # unload the module
+        foo.module.unload()
+
+        # launch previously captured graph
+        wp.capture_launch(capture.graph)
+
+        test.assertEqual(a.numpy()[0], 42)
+
+
 devices = get_test_devices()
+cuda_devices = get_cuda_test_devices()
 
 
 class TestReload(unittest.TestCase):
@@ -200,6 +225,9 @@ add_function_test(TestReload, "test_redefine", test_redefine, devices=devices)
 add_function_test(TestReload, "test_reload", test_reload, devices=devices)
 add_function_test(TestReload, "test_reload_class", test_reload_class, devices=devices)
 add_function_test(TestReload, "test_reload_references", test_reload_references, devices=devices)
+add_function_test(
+    TestReload, "test_graph_launch_after_module_reload", test_graph_launch_after_module_reload, devices=cuda_devices
+)
 
 
 if __name__ == "__main__":

warp/tests/test_struct.py

@@ -589,6 +589,52 @@ def test_dependent_module_import(c: DependentModuleImport_C):
     wp.tid()  # nop, we're just testing codegen
 
 
+def test_struct_array_content_hash(test, device):
+    # Ensure that the memory address of the struct does not affect the content hash
+
+    @wp.struct
+    class ContentHashStruct:
+        i: int
+
+    @wp.kernel
+    def dummy_kernel(a: wp.array(dtype=ContentHashStruct)):
+        i = wp.tid()
+
+    module_hash_0 = wp.get_module(dummy_kernel.__module__).hash_module()
+
+    # Redefine ContentHashStruct to have the same members as before but a new memory address
+    @wp.struct
+    class ContentHashStruct:
+        i: int
+
+    @wp.kernel
+    def dummy_kernel(a: wp.array(dtype=ContentHashStruct)):
+        i = wp.tid()
+
+    module_hash_1 = wp.get_module(dummy_kernel.__module__).hash_module(recompute_content_hash=True)
+
+    test.assertEqual(
+        module_hash_1,
+        module_hash_0,
+        "Module hash should be unchanged when ContentHashStruct is redefined but unchanged.",
+    )
+
+    # Redefine ContentHashStruct to have different members. This time we should get a new hash.
+    @wp.struct
+    class ContentHashStruct:
+        i: float
+
+    @wp.kernel
+    def dummy_kernel(a: wp.array(dtype=ContentHashStruct)):
+        i = wp.tid()
+
+    module_hash_2 = wp.get_module(dummy_kernel.__module__).hash_module(recompute_content_hash=True)
+
+    test.assertNotEqual(
+        module_hash_2, module_hash_0, "Module hash should be different when ContentHashStruct redefined and changed."
+    )
+
+
 devices = get_test_devices()
 
 
@@ -636,36 +682,6 @@ add_kernel_test(
     devices=devices,
 )
 
-add_kernel_test(
-    TestStruct,
-    name="test_struct_mutate_attributes",
-    kernel=test_struct_mutate_attributes_kernel,
-    dim=1,
-    inputs=[],
-    devices=devices,
-)
-add_kernel_test(
-    TestStruct,
-    kernel=test_uninitialized,
-    name="test_uninitialized",
-    dim=1,
-    inputs=[Uninitialized()],
-    devices=devices,
-)
-add_kernel_test(TestStruct, kernel=test_return, name="test_return", dim=1, inputs=[], devices=devices)
-add_function_test(TestStruct, "test_nested_struct", test_nested_struct, devices=devices)
-add_function_test(TestStruct, "test_nested_array_struct", test_nested_array_struct, devices=devices)
-add_function_test(TestStruct, "test_nested_empty_struct", test_nested_empty_struct, devices=devices)
-add_function_test(TestStruct, "test_struct_math_conversions", test_struct_math_conversions, devices=devices)
-add_kernel_test(
-    TestStruct,
-    name="test_struct_default_attributes",
-    kernel=test_struct_default_attributes_kernel,
-    dim=1,
-    inputs=[],
-    devices=devices,
-)
-
 add_kernel_test(
     TestStruct,
     name="test_struct_mutate_attributes",
@@ -702,6 +718,8 @@ add_kernel_test(
     devices=devices,
 )
 
+add_function_test(TestStruct, "test_struct_array_content_hash", test_struct_array_content_hash, devices=None)
+
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()

warp/tests/test_volume.py

@@ -843,6 +843,33 @@ def test_volume_from_numpy(test, device):
     test.assertIsNone(sphere_vdb_array.deleter)
 
 
+def test_volume_from_numpy_3d(test, device):
+    # Volume.allocate_from_tiles() is only available with CUDA
+    mins = np.array([-3.0, -3.0, -3.0])
+    voxel_size = 0.2
+    maxs = np.array([3.0, 3.0, 3.0])
+    nums = np.ceil((maxs - mins) / (voxel_size)).astype(dtype=int)
+    centers = np.array([[-1.0, -1.0, -1.0], [0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])
+    rad = 2.5
+    sphere_sdf_np = np.zeros(tuple(nums) + (3,))
+    for x in range(nums[0]):
+        for y in range(nums[1]):
+            for z in range(nums[2]):
+                for k in range(3):
+                    pos = mins + voxel_size * np.array([x, y, z])
+                    dis = np.linalg.norm(pos - centers[k])
+                    sphere_sdf_np[x, y, z, k] = dis - rad
+    sphere_vdb = wp.Volume.load_from_numpy(
+        sphere_sdf_np, mins, voxel_size, (rad + 3.0 * voxel_size,) * 3, device=device
+    )
+
+    test.assertNotEqual(sphere_vdb.id, 0)
+
+    sphere_vdb_array = sphere_vdb.array()
+    test.assertEqual(sphere_vdb_array.dtype, wp.uint8)
+    test.assertIsNone(sphere_vdb_array.deleter)
+
+
 def test_volume_aniso_transform(test, device):
     # XY-rotation + z scale
     transform = [
@@ -894,6 +921,9 @@ add_function_test(TestVolume, "test_volume_introspection", test_volume_introspec
 add_function_test(
     TestVolume, "test_volume_from_numpy", test_volume_from_numpy, devices=get_selected_cuda_test_devices()
 )
+add_function_test(
+    TestVolume, "test_volume_from_numpy_3d", test_volume_from_numpy_3d, devices=get_selected_cuda_test_devices()
+)
 add_function_test(
     TestVolume, "test_volume_aniso_transform", test_volume_aniso_transform, devices=get_selected_cuda_test_devices()
 )

warp/types.py

@@ -1576,7 +1576,7 @@ class array(Array):
 
         Args:
             data (Union[list, tuple, ndarray]): An object to construct the array from, can be a Tuple, List, or generally any type convertible to an np.array
-            dtype (Union): One of the built-in types, e.g.: :class:`warp.mat33`, if dtype is Any and data an ndarray then it will be inferred from the array data type
+            dtype (Union): One of the available `data types <#data-types>`_, such as :class:`warp.float32`, :class:`warp.mat33`, or a custom `struct <#structs>`_. If dtype is ``Any`` and data is an ndarray, then it will be inferred from the array data type
             shape (tuple): Dimensions of the array
             strides (tuple): Number of bytes in each dimension between successive elements of the array
             length (int): Number of elements of the data type (deprecated, users should use `shape` argument)
@@ -1601,6 +1601,9 @@ class array(Array):
         self._array_interface = None
         self.is_transposed = False
 
+        # reference to other array
+        self._ref = None
+
         # canonicalize dtype
         if dtype == int:
             dtype = int32
@@ -1614,7 +1617,9 @@ class array(Array):
             if isinstance(shape, int):
                 shape = (shape,)
             else:
-                shape = tuple(shape)
+                # The type of shape's elements are eventually passed onto capacity which is used to allocate memory. We
+                # explicitly enforce that shape is a tuple of (64-bit) ints to ensure that capacity is 64-bit.
+                shape = tuple(int(x) for x in shape)
                 if len(shape) > ARRAY_MAX_DIMS:
                     raise RuntimeError(
                         f"Failed to create array with shape {shape}, the maximum number of dimensions is {ARRAY_MAX_DIMS}"
@@ -1650,9 +1655,6 @@ class array(Array):
                 if requires_grad:
                     self._alloc_grad()
 
-        # reference to other array
-        self._ref = None
-
     def _init_from_data(self, data, dtype, shape, device, copy, pinned):
         if not hasattr(data, "__len__"):
             raise RuntimeError(f"Data must be a sequence or array, got scalar {data}")
@@ -2989,7 +2991,7 @@ class Mesh:
 
         Args:
             points (:class:`warp.array`): Array of vertex positions of type :class:`warp.vec3`
-            indices (:class:`warp.array`): Array of triangle indices of type :class:`warp.int32`, should be a 1d array with shape (num_tris, 3)
+            indices (:class:`warp.array`): Array of triangle indices of type :class:`warp.int32`, should be a 1d array with shape (num_tris * 3)
             velocities (:class:`warp.array`): Array of vertex velocities of type :class:`warp.vec3` (optional)
             support_winding_number (bool): If true the mesh will build additional datastructures to support `wp.mesh_query_point_sign_winding_number()` queries
         """
@@ -3527,8 +3529,9 @@ class Volume:
         )
         if hasattr(bg_value, "__len__"):
             # vec3, assuming the numpy array is 4D
-            padded_array = np.array((target_shape[0], target_shape[1], target_shape[2], 3), dtype=np.single)
-            padded_array[:, :, :, :] = np.array(bg_value)
+            padded_array = np.full(
+                shape=(target_shape[0], target_shape[1], target_shape[2], 3), fill_value=bg_value, dtype=np.single
+            )
             padded_array[0 : ndarray.shape[0], 0 : ndarray.shape[1], 0 : ndarray.shape[2], :] = ndarray
         else:
             padded_amount = (