warp-lang 1.6.1__py3-none-win_amd64.whl → 1.7.0__py3-none-win_amd64.whl

warp/sim/integrator_xpbd.py

@@ -1,9 +1,17 @@
-# Copyright (c) 2022 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 import warp as wp
 
@@ -587,7 +595,7 @@ def solve_tetrahedra(
     x20 = x2 - x0
     x30 = x3 - x0
 
-    Ds = wp.mat33(x10, x20, x30)
+    Ds = wp.matrix_from_cols(x10, x20, x30)
     Dm = rest_matrix[tid]
     inv_QT = wp.transpose(Dm)
 
@@ -619,7 +627,7 @@ def solve_tetrahedra(
         elif term == 1:
             # volume conservation
             C = wp.determinant(F) - 1.0
-            dC = wp.mat33(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))
+            dC = wp.matrix_from_cols(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))
             compliance = volume_compliance
 
         if C != 0.0:
@@ -683,7 +691,7 @@ def solve_tetrahedra(
     # J = wp.determinant(F)
 
     # C_vol = J - alpha
-    # # dCdx = wp.mat33(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))*wp.transpose(Dm)
+    # # dCdx = wp.matrix_from_cols(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))*wp.transpose(Dm)
 
     # # grad1 = wp.vec3(dCdx[0,0], dCdx[1,0], dCdx[2,0])
     # # grad2 = wp.vec3(dCdx[0,1], dCdx[1,1], dCdx[2,1])
@@ -758,7 +766,7 @@ def solve_tetrahedra2(
     x20 = x2 - x0
     x30 = x3 - x0
 
-    Ds = wp.mat33(x10, x20, x30)
+    Ds = wp.matrix_from_cols(x10, x20, x30)
     Dm = pose[tid]
 
     inv_rest_volume = wp.determinant(Dm) * 6.0
@@ -829,7 +837,7 @@ def solve_tetrahedra2(
     J = wp.determinant(F)
 
     C_vol = J - alpha
-    # dCdx = wp.mat33(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))*wp.transpose(Dm)
+    # dCdx = wp.matrix_from_cols(wp.cross(f2, f3), wp.cross(f3, f1), wp.cross(f1, f2))*wp.transpose(Dm)
 
     # grad1 = wp.vec3(dCdx[0,0], dCdx[1,0], dCdx[2,0])
     # grad2 = wp.vec3(dCdx[0,1], dCdx[1,1], dCdx[2,1])

warp/sim/model.py

@@ -1,9 +1,17 @@
-# Copyright (c) 2022 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 """A module for building simulation models and state."""
 
@@ -364,9 +372,14 @@ class Control:
     should generally be created using the :func:`Model.control()` function.
     """
 
-    def __init__(self, model: Model):
-        self.model: Model = model
-        """Model to use as a reference for the control inputs."""
+    def __init__(self, model: Model = None):
+        if model:
+            wp.utils.warn(
+                "Passing arguments to Control's __init__ is deprecated\n"
+                "and will be disallowed in a future version. Use Control() without arguments\ninstead.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
 
         self.joint_act: Optional[wp.array] = None
         """Array of joint control inputs with shape ``(joint_axis_count,)`` and type ``float``."""
@@ -380,17 +393,28 @@ class Control:
         self.muscle_activations: Optional[wp.array] = None
         """Array of muscle activations with shape ``(muscle_count,)`` and type ``float``."""
 
-    def reset(self) -> None:
-        """Reset the control inputs to their initial state defined in :attr:`model`."""
+    def clear(self) -> None:
+        """Reset the control inputs to zero."""
 
         if self.joint_act is not None:
-            self.joint_act.assign(self.model.joint_act)
+            self.joint_act.zero_()
         if self.tri_activations is not None:
-            self.tri_activations.assign(self.model.tri_activations)
+            self.tri_activations.zero_()
         if self.tet_activations is not None:
-            self.tet_activations.assign(self.model.tet_activations)
+            self.tet_activations.zero_()
         if self.muscle_activations is not None:
-            self.muscle_activations.assign(self.model.muscle_activations)
+            self.muscle_activations.zero_()
+
+    def reset(self) -> None:
+        """Reset the control inputs to zero."""
+
+        wp.utils.warn(
+            "Control.reset() is deprecated and will be removed\nin a future version. Use Control.clear() instead.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
+        self.clear()
 
 
 def compute_shape_mass(type, scale, src, density, is_solid, thickness):
@@ -535,6 +559,7 @@ class Model:
 
         edge_indices (array): Bending edge indices, shape [edge_count*4], int, each row is [o0, o1, v1, v2], where v1, v2 are on the edge
         edge_rest_angle (array): Bending edge rest angle, shape [edge_count], float
+        edge_rest_length (array): Bending edge rest length, shape [edge_count], float
         edge_bending_properties (array): Bending edge stiffness and damping parameters, shape [edge_count, 2], float
 
         tet_indices (array): Tetrahedral element indices, shape [tet_count*4], int
@@ -708,6 +733,7 @@ class Model:
 
         self.edge_indices = None
         self.edge_rest_angle = None
+        self.edge_rest_length = None
         self.edge_bending_properties = None
         self.edge_constraint_lambdas = None
 
@@ -870,7 +896,7 @@ class Model:
         Returns:
             Control: The control object
         """
-        c = Control(self)
+        c = Control()
         if requires_grad is None:
             requires_grad = self.requires_grad
         if clone_variables:
@@ -1197,6 +1223,7 @@ class ModelBuilder:
         # edges (bending)
         self.edge_indices = []
         self.edge_rest_angle = []
+        self.edge_rest_length = []
         self.edge_bending_properties = []
 
         # tetrahedra
@@ -1376,7 +1403,11 @@ class ModelBuilder:
         if builder.spring_count:
             self.spring_indices.extend((np.array(builder.spring_indices, dtype=np.int32) + start_particle_idx).tolist())
         if builder.edge_count:
-            self.edge_indices.extend((np.array(builder.edge_indices, dtype=np.int32) + start_particle_idx).tolist())
+            # Update edge indices by adding offset, preserving -1 values
+            edge_indices = np.array(builder.edge_indices, dtype=np.int32)
+            mask = edge_indices != -1
+            edge_indices[mask] += start_particle_idx
+            self.edge_indices.extend(edge_indices.tolist())
         if builder.tri_count:
             self.tri_indices.extend((np.array(builder.tri_indices, dtype=np.int32) + start_particle_idx).tolist())
         if builder.tet_count:
@@ -1510,6 +1541,7 @@ class ModelBuilder:
             "particle_radius",
             "particle_flags",
             "edge_rest_angle",
+            "edge_rest_length",
             "edge_bending_properties",
             "spring_rest_length",
             "spring_stiffness",
@@ -3749,11 +3781,11 @@ class ModelBuilder:
         edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
 
         # compute rest angle
+        x3 = self.particle_q[k]
+        x4 = self.particle_q[l]
         if rest is None:
             x1 = self.particle_q[i]
             x2 = self.particle_q[j]
-            x3 = self.particle_q[k]
-            x4 = self.particle_q[l]
 
             n1 = wp.normalize(wp.cross(x3 - x1, x4 - x1))
             n2 = wp.normalize(wp.cross(x4 - x2, x3 - x2))
@@ -3768,6 +3800,7 @@ class ModelBuilder:
 
         self.edge_indices.append((i, j, k, l))
         self.edge_rest_angle.append(rest)
+        self.edge_rest_length.append(wp.length(x4 - x3))
         self.edge_bending_properties.append((edge_ke, edge_kd))
 
     def add_edges(
@@ -3799,6 +3832,8 @@ class ModelBuilder:
             winding: (i, k, l), (j, l, k).
 
         """
+        x3 = np.array(self.particle_q)[k]
+        x4 = np.array(self.particle_q)[l]
         if rest is None:
             # compute rest angle
             x1 = np.array(self.particle_q)[i]
@@ -3829,6 +3864,7 @@ class ModelBuilder:
 
         self.edge_indices.extend(inds.tolist())
         self.edge_rest_angle.extend(rest.tolist())
+        self.edge_rest_length.extend(np.linalg.norm(x4 - x3, axis=1).tolist())
 
         def init_if_none(arr, defaultValue):
             if arr is None:
@@ -4620,6 +4656,7 @@ class ModelBuilder:
 
             m.edge_indices = wp.array(self.edge_indices, dtype=wp.int32)
             m.edge_rest_angle = wp.array(self.edge_rest_angle, dtype=wp.float32, requires_grad=requires_grad)
+            m.edge_rest_length = wp.array(self.edge_rest_length, dtype=wp.float32, requires_grad=requires_grad)
             m.edge_bending_properties = wp.array(
                 self.edge_bending_properties, dtype=wp.float32, requires_grad=requires_grad
             )

warp/sim/particles.py

@@ -1,9 +1,17 @@
-# Copyright (c) 2022 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 import warp as wp
 

warp/sim/render.py

@@ -1,9 +1,17 @@
-# Copyright (c) 2022 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.
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 from collections import defaultdict
 

warp/sim/utils.py

@@ -1,3 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from typing import List, Tuple
 
 import numpy as np
@@ -50,7 +65,7 @@ def quat_decompose(q: wp.quat):
     Decompose a quaternion into a sequence of 3 rotations around x,y',z' respectively, i.e.: q = q_z''q_y'q_x.
     """
 
-    R = wp.mat33(
+    R = wp.matrix_from_cols(
         wp.quat_rotate(q, wp.vec3(1.0, 0.0, 0.0)),
         wp.quat_rotate(q, wp.vec3(0.0, 1.0, 0.0)),
         wp.quat_rotate(q, wp.vec3(0.0, 0.0, 1.0)),
@@ -234,7 +249,7 @@ def transform_inertia(t: wp.transform, I: wp.spatial_matrix):
     r2 = wp.quat_rotate(q, wp.vec3(0.0, 1.0, 0.0))
     r3 = wp.quat_rotate(q, wp.vec3(0.0, 0.0, 1.0))
 
-    R = wp.mat33(r1, r2, r3)
+    R = wp.matrix_from_cols(r1, r2, r3)
     S = wp.mul(wp.skew(p), R)
 
     T = wp.spatial_adjoint(R, S)