warp-lang 1.9.0__py3-none-win_amd64.whl → 1.9.1__py3-none-win_amd64.whl

warp/render/render_opengl.py

@@ -390,9 +390,9 @@ def compute_gfx_vertices(
     gfx_vertices: wp.array(dtype=float, ndim=2),
 ):
     tid = wp.tid()
-    v0 = vertices[indices[tid, 0]] * scale[0]
-    v1 = vertices[indices[tid, 1]] * scale[1]
-    v2 = vertices[indices[tid, 2]] * scale[2]
+    v0 = wp.cw_mul(vertices[indices[tid, 0]], scale)
+    v1 = wp.cw_mul(vertices[indices[tid, 1]], scale)
+    v2 = wp.cw_mul(vertices[indices[tid, 2]], scale)
     i = tid * 3
     j = i + 1
     k = i + 2
@@ -421,6 +421,7 @@ def compute_gfx_vertices(
 def compute_average_normals(
     indices: wp.array(dtype=int, ndim=2),
     vertices: wp.array(dtype=wp.vec3),
+    scale: wp.vec3,
     # outputs
     normals: wp.array(dtype=wp.vec3),
     faces_per_vertex: wp.array(dtype=int),
@@ -429,9 +430,9 @@ def compute_average_normals(
     i = indices[tid, 0]
     j = indices[tid, 1]
     k = indices[tid, 2]
-    v0 = vertices[i]
-    v1 = vertices[j]
-    v2 = vertices[k]
+    v0 = wp.cw_mul(vertices[i], scale)
+    v1 = wp.cw_mul(vertices[j], scale)
+    v2 = wp.cw_mul(vertices[k], scale)
     n = wp.normalize(wp.cross(v1 - v0, v2 - v0))
     wp.atomic_add(normals, i, n)
     wp.atomic_add(faces_per_vertex, i, 1)
@@ -446,15 +447,16 @@ def assemble_gfx_vertices(
     vertices: wp.array(dtype=wp.vec3, ndim=1),
     normals: wp.array(dtype=wp.vec3),
     faces_per_vertex: wp.array(dtype=int),
+    scale: wp.vec3,
     # outputs
     gfx_vertices: wp.array(dtype=float, ndim=2),
 ):
     tid = wp.tid()
     v = vertices[tid]
     n = normals[tid] / float(faces_per_vertex[tid])
-    gfx_vertices[tid, 0] = v[0]
-    gfx_vertices[tid, 1] = v[1]
-    gfx_vertices[tid, 2] = v[2]
+    gfx_vertices[tid, 0] = v[0] * scale[0]
+    gfx_vertices[tid, 1] = v[1] * scale[1]
+    gfx_vertices[tid, 2] = v[2] * scale[2]
     gfx_vertices[tid, 3] = n[0]
     gfx_vertices[tid, 4] = n[1]
     gfx_vertices[tid, 5] = n[2]
@@ -3130,7 +3132,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     compute_average_normals,
                     dim=idx_count,
-                    inputs=[wp.array(indices, dtype=int), vertices],
+                    inputs=[wp.array(indices, dtype=int), vertices, scale],
                     outputs=[normals, faces_per_vertex],
                     record_tape=False,
                 )
@@ -3138,7 +3140,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     assemble_gfx_vertices,
                     dim=point_count,
-                    inputs=[vertices, normals, faces_per_vertex],
+                    inputs=[vertices, normals, faces_per_vertex, scale],
                     outputs=[gfx_vertices],
                     record_tape=False,
                 )
@@ -3149,7 +3151,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     compute_gfx_vertices,
                     dim=idx_count,
-                    inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3)],
+                    inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3), scale],
                     outputs=[gfx_vertices],
                     record_tape=False,
                 )

warp/render/render_usd.py

@@ -647,6 +647,7 @@ class UsdRenderer:
             mesh.GetDisplayColorAttr().Set(colors, self.time)
 
         self._shape_constructors[name] = UsdGeom.Mesh
+        self._shape_custom_scale[name] = scale
 
         if not is_template:
             _usd_set_xform(mesh, pos, rot, scale, self.time)

warp/tests/geometry/test_hash_grid.py

@@ -191,7 +191,44 @@ def test_hashgrid_inputs(test, device):
             assert_array_equal(counts_ndim, counts_ref)
 
 
+def test_hashgrid_multiple_streams(test, device):
+    with wp.ScopedDevice(device):
+        points = particle_grid(16, 32, 16, (0.0, 0.3, 0.0), cell_radius * 0.25, 0.1)
+        points_ref = wp.array(points, dtype=wp.vec3)
+        counts_ref = wp.zeros(len(points), dtype=int)
+
+        grid_dim = 64
+        grid_ref = wp.HashGrid(grid_dim, grid_dim, grid_dim)
+        grid_ref.build(points_ref, cell_radius)
+
+        # get reference counts
+        wp.launch(kernel=count_neighbors, dim=len(points), inputs=[grid_ref.id, query_radius, points_ref, counts_ref])
+
+        # create multiple streams
+        num_streams = 10
+        streams = [wp.Stream(device=device) for _ in range(num_streams)]
+        counts_per_stream = [wp.zeros(len(points), dtype=int) for _ in range(num_streams)]
+
+        # test whether HashGrid and radix sort work with multiple streams without race conditions
+        for i in range(num_streams):
+            with wp.ScopedStream(streams[i]):
+                grid = wp.HashGrid(grid_dim, grid_dim, grid_dim)
+                grid.build(points_ref, cell_radius)
+
+                # get counts for this stream
+                wp.launch(
+                    kernel=count_neighbors,
+                    dim=len(points),
+                    inputs=[grid.id, query_radius, points_ref, counts_per_stream[i]],
+                )
+
+        # run this loop after all streams are scheduled to ensure asynchronous behaviour above
+        for i in range(num_streams):
+            assert_array_equal(counts_per_stream[i], counts_ref)
+
+
 devices = get_test_devices()
+cuda_devices = get_cuda_test_devices()
 
 
 class TestHashGrid(unittest.TestCase):
@@ -214,6 +251,7 @@ class TestHashGrid(unittest.TestCase):
 
 add_function_test(TestHashGrid, "test_hashgrid_query", test_hashgrid_query, devices=devices)
 add_function_test(TestHashGrid, "test_hashgrid_inputs", test_hashgrid_inputs, devices=devices)
+add_function_test(TestHashGrid, "test_hashgrid_multiple_streams", test_hashgrid_multiple_streams, devices=cuda_devices)
 
 
 if __name__ == "__main__":