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

warp/sim/model.py

@@ -7,6 +7,8 @@
 
 """A module for building simulation models and state."""
 
+from __future__ import annotations
+
 import copy
 import math
 from typing import List, Optional, Tuple
@@ -262,47 +264,51 @@ class Mesh:
 
 
 class State:
-    """The State object holds all *time-varying* data for a model.
+    """Time-varying state data for a :class:`Model`.
 
-    Time-varying data includes particle positions, velocities, rigid body states, and
+    Time-varying state data includes particle positions, velocities, rigid body states, and
     anything that is output from the integrator as derived data, e.g.: forces.
 
     The exact attributes depend on the contents of the model. State objects should
     generally be created using the :func:`Model.state()` function.
+    """
 
-    Attributes:
+    def __init__(self):
+        self.particle_q: Optional[wp.array] = None
+        """Array of 3D particle positions with shape ``(particle_count,)`` and type :class:`vec3`."""
 
-        particle_q (array): Array of 3D particle positions, shape [particle_count], :class:`vec3`
-        particle_qd (array): Array of 3D particle velocities, shape [particle_count], :class:`vec3`
-        particle_f (array): Array of 3D particle forces, shape [particle_count], :class:`vec3`
+        self.particle_qd: Optional[wp.array] = None
+        """Array of 3D particle velocities with shape ``(particle_count,)`` and type :class:`vec3`."""
 
-        body_q (array): Array of body coordinates (7-dof transforms) in maximal coordinates, shape [body_count], :class:`transform`
-        body_qd (array): Array of body velocities in maximal coordinates (first 3 entries represent angular velocity, last 3 entries represent linear velocity), shape [body_count], :class:`spatial_vector`
-        body_f (array): Array of body forces in maximal coordinates (first 3 entries represent torque, last 3 entries represent linear force), shape [body_count], :class:`spatial_vector`
+        self.particle_f: Optional[wp.array] = None
+        """Array of 3D particle forces with shape ``(particle_count,)`` and type :class:`vec3`."""
 
-            Note:
+        self.body_q: Optional[wp.array] = None
+        """Array of body coordinates (7-dof transforms) in maximal coordinates with shape ``(body_count,)`` and type :class:`transform`."""
 
-                :attr:`body_f` represents external wrenches in world frame and denotes wrenches measured w.r.t. to the body's center of mass for all integrators except :class:`FeatherstoneIntegrator` which assumes the wrenches are measured w.r.t. world origin.
+        self.body_qd: Optional[wp.array] = None
+        """Array of body velocities in maximal coordinates (first three entries represent angular velocity,
+        last three entries represent linear velocity) with shape ``(body_count,)`` and type :class:`spatial_vector`.
+        """
 
-        joint_q (array): Array of generalized joint coordinates, shape [joint_coord_count], float
-        joint_qd (array): Array of generalized joint velocities, shape [joint_dof_count], float
+        self.body_f: Optional[wp.array] = None
+        """Array of body forces in maximal coordinates (first three entries represent torque, last three
+        entries represent linear force) with shape ``(body_count,)`` and type :class:`spatial_vector`.
 
-    """
-
-    def __init__(self):
-        self.particle_q = None
-        self.particle_qd = None
-        self.particle_f = None
+        .. note::
+            :attr:`body_f` represents external wrenches in world frame and denotes wrenches measured w.r.t.
+            to the body's center of mass for all integrators except :class:`FeatherstoneIntegrator`, which
+            assumes the wrenches are measured w.r.t. world origin.
+        """
 
-        self.body_q = None
-        self.body_qd = None
-        self.body_f = None
+        self.joint_q: Optional[wp.array] = None
+        """Array of generalized joint coordinates with shape ``(joint_coord_count,)`` and type ``float``."""
 
-        self.joint_q = None
-        self.joint_qd = None
+        self.joint_qd: Optional[wp.array] = None
+        """Array of generalized joint velocities with shape ``(joint_dof_count,)`` and type ``float``."""
 
-    def clear_forces(self):
-        """Clears all forces (for particles and bodies) in the state object."""
+    def clear_forces(self) -> None:
+        """Clear all forces (for particles and bodies) in the state object."""
         with wp.ScopedTimer("clear_forces", False):
             if self.particle_count:
                 self.particle_f.zero_()
@@ -311,7 +317,7 @@ class State:
                 self.body_f.zero_()
 
     @property
-    def requires_grad(self):
+    def requires_grad(self) -> bool:
         """Indicates whether the state arrays have gradient computation enabled."""
         if self.particle_q:
             return self.particle_q.requires_grad
@@ -320,28 +326,28 @@ class State:
         return False
 
     @property
-    def body_count(self):
+    def body_count(self) -> int:
         """The number of bodies represented in the state."""
         if self.body_q is None:
             return 0
         return len(self.body_q)
 
     @property
-    def particle_count(self):
+    def particle_count(self) -> int:
         """The number of particles represented in the state."""
         if self.particle_q is None:
             return 0
         return len(self.particle_q)
 
     @property
-    def joint_coord_count(self):
+    def joint_coord_count(self) -> int:
         """The number of generalized joint position coordinates represented in the state."""
         if self.joint_q is None:
             return 0
         return len(self.joint_q)
 
     @property
-    def joint_dof_count(self):
+    def joint_dof_count(self) -> int:
         """The number of generalized joint velocity coordinates represented in the state."""
         if self.joint_qd is None:
             return 0
@@ -349,37 +355,34 @@ class State:
 
 
 class Control:
+    """Time-varying control data for a :class:`Model`.
+
+    Time-varying control data includes joint control inputs, muscle activations,
+    and activation forces for triangle and tetrahedral elements.
+
+    The exact attributes depend on the contents of the model. Control objects
+    should generally be created using the :func:`Model.control()` function.
     """
-    The Control object holds all *time-varying* control data for a model.
 
-    Time-varying control data includes joint control inputs, muscle activations, and activation forces for triangle and tetrahedral elements.
+    def __init__(self, model: Model):
+        self.model: Model = model
+        """Model to use as a reference for the control inputs."""
 
-    The exact attributes depend on the contents of the model. Control objects should generally be created using the :func:`Model.control()` function.
+        self.joint_act: Optional[wp.array] = None
+        """Array of joint control inputs with shape ``(joint_axis_count,)`` and type ``float``."""
 
-    Attributes:
+        self.tri_activations: Optional[wp.array] = None
+        """Array of triangle element activations with shape ``(tri_count,)`` and type ``float``."""
 
-        joint_act (array): Array of joint control inputs, shape [joint_axis_count], float
-        tri_activations (array): Array of triangle element activations, shape [tri_count], float
-        tet_activations (array): Array of tetrahedral element activations, shape [tet_count], float
-        muscle_activations (array): Array of muscle activations, shape [muscle_count], float
+        self.tet_activations: Optional[wp.array] = None
+        """Array of tetrahedral element activations with shape with shape ``(tet_count,) and type ``float``."""
 
-    """
+        self.muscle_activations: Optional[wp.array] = None
+        """Array of muscle activations with shape ``(muscle_count,)`` and type ``float``."""
 
-    def __init__(self, model):
-        """
-        Args:
-            model (Model): The model to use as a reference for the control inputs
-        """
-        self.model = model
-        self.joint_act = None
-        self.tri_activations = None
-        self.tet_activations = None
-        self.muscle_activations = None
+    def reset(self) -> None:
+        """Reset the control inputs to their initial state defined in :attr:`model`."""
 
-    def reset(self):
-        """
-        Resets the control inputs to their initial state defined in :class:`Model`.
-        """
         if self.joint_act is not None:
             self.joint_act.assign(self.model.joint_act)
         if self.tri_activations is not None:
@@ -591,6 +594,7 @@ class Model:
         joint_attach_ke (float): Joint attachment force stiffness (used by :class:`SemiImplicitIntegrator`)
         joint_attach_kd (float): Joint attachment force damping (used by :class:`SemiImplicitIntegrator`)
 
+        soft_contact_radius (float): Contact radius used for self-collisions in the VBD integrator.
         soft_contact_margin (float): Contact margin for generation of soft contacts
         soft_contact_ke (float): Stiffness of soft contacts (used by the Euler integrators)
         soft_contact_kd (float): Damping of soft contacts (used by the Euler integrators)
@@ -761,6 +765,7 @@ class Model:
         self.joint_attach_ke = 1.0e3
         self.joint_attach_kd = 1.0e2
 
+        self.soft_contact_radius = 0.2
         self.soft_contact_margin = 0.2
         self.soft_contact_ke = 1.0e3
         self.soft_contact_kd = 10.0
@@ -1046,6 +1051,8 @@ class Model:
     @property
     def soft_contact_max(self):
         """Maximum number of soft contacts that can be registered"""
+        if self.soft_contact_particle is None:
+            return 0
         return len(self.soft_contact_particle)
 
 
@@ -1392,6 +1399,8 @@ class ModelBuilder:
                 # apply offset transform to root bodies
                 if xform is not None:
                     self.shape_transform.append(xform * builder.shape_transform[s])
+                else:
+                    self.shape_transform.append(builder.shape_transform[s])
 
         for b, shapes in builder.body_shapes.items():
             self.body_shapes[b + start_body_idx] = [s + start_shape_idx for s in shapes]
@@ -1414,18 +1423,16 @@ class ModelBuilder:
 
             # offset the indices
             self.articulation_start.extend([a + self.joint_count for a in builder.articulation_start])
-            self.joint_parent.extend([p + self.joint_count if p != -1 else -1 for p in builder.joint_parent])
-            self.joint_child.extend([c + self.joint_count for c in builder.joint_child])
+            self.joint_parent.extend([p + self.body_count if p != -1 else -1 for p in builder.joint_parent])
+            self.joint_child.extend([c + self.body_count for c in builder.joint_child])
 
             self.joint_q_start.extend([c + self.joint_coord_count for c in builder.joint_q_start])
             self.joint_qd_start.extend([c + self.joint_dof_count for c in builder.joint_qd_start])
 
             self.joint_axis_start.extend([a + self.joint_axis_total_count for a in builder.joint_axis_start])
 
-        joint_children = set(builder.joint_child)
         for i in range(builder.body_count):
-            if xform is not None and i not in joint_children:
-                # rigid body is not attached to a joint, so apply input transform directly
+            if xform is not None:
                 self.body_q.append(xform * builder.body_q[i])
             else:
                 self.body_q.append(builder.body_q[i])
@@ -1747,8 +1754,8 @@ class ModelBuilder:
         mode: int = JOINT_MODE_FORCE,
         limit_lower: float = -2 * math.pi,
         limit_upper: float = 2 * math.pi,
-        limit_ke: float = default_joint_limit_ke,
-        limit_kd: float = default_joint_limit_kd,
+        limit_ke: float = None,
+        limit_kd: float = None,
         linear_compliance: float = 0.0,
         angular_compliance: float = 0.0,
         armature: float = 1e-2,
@@ -1769,8 +1776,8 @@ class ModelBuilder:
             target_kd: The damping of the joint target
             limit_lower: The lower limit of the joint
             limit_upper: The upper limit of the joint
-            limit_ke: The stiffness of the joint limit
-            limit_kd: The damping of the joint limit
+            limit_ke: The stiffness of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
+            limit_kd: The damping of the joint limit (None to use the default value :attr:`default_joint_limit_kd`)
             linear_compliance: The linear compliance of the joint
             angular_compliance: The angular compliance of the joint
             armature: Artificial inertia added around the joint axis
@@ -1788,6 +1795,9 @@ class ModelBuilder:
         if child_xform is None:
             child_xform = wp.transform()
 
+        limit_ke = limit_ke if limit_ke is not None else self.default_joint_limit_ke
+        limit_kd = limit_kd if limit_kd is not None else self.default_joint_limit_kd
+
         action = 0.0
         if target is None and mode == JOINT_MODE_TARGET_POSITION:
             action = 0.5 * (limit_lower + limit_upper)
@@ -1834,8 +1844,8 @@ class ModelBuilder:
         mode: int = JOINT_MODE_FORCE,
         limit_lower: float = -1e4,
         limit_upper: float = 1e4,
-        limit_ke: float = default_joint_limit_ke,
-        limit_kd: float = default_joint_limit_kd,
+        limit_ke: float = None,
+        limit_kd: float = None,
         linear_compliance: float = 0.0,
         angular_compliance: float = 0.0,
         armature: float = 1e-2,
@@ -1856,8 +1866,8 @@ class ModelBuilder:
             target_kd: The damping of the joint target
             limit_lower: The lower limit of the joint
             limit_upper: The upper limit of the joint
-            limit_ke: The stiffness of the joint limit
-            limit_kd: The damping of the joint limit
+            limit_ke: The stiffness of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
+            limit_kd: The damping of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
             linear_compliance: The linear compliance of the joint
             angular_compliance: The angular compliance of the joint
             armature: Artificial inertia added around the joint axis
@@ -1875,6 +1885,9 @@ class ModelBuilder:
         if child_xform is None:
             child_xform = wp.transform()
 
+        limit_ke = limit_ke if limit_ke is not None else self.default_joint_limit_ke
+        limit_kd = limit_kd if limit_kd is not None else self.default_joint_limit_kd
+
         action = 0.0
         if target is None and mode == JOINT_MODE_TARGET_POSITION:
             action = 0.5 * (limit_lower + limit_upper)
@@ -2523,7 +2536,7 @@ class ModelBuilder:
                 last_dynamic_body_name = self.body_name[last_dynamic_body] if last_dynamic_body > -1 else "world"
                 if verbose:
                     print(
-                        f'Remove fixed joint {joint["name"]} between {parent_name} and {child_name}, '
+                        f"Remove fixed joint {joint['name']} between {parent_name} and {child_name}, "
                         f"merging {child_name} into {last_dynamic_body_name}"
                     )
                 child_id = body_data[child_body]["original_id"]
@@ -2775,7 +2788,7 @@ class ModelBuilder:
                 c = np.cross(normal, (0.0, 1.0, 0.0))
                 angle = np.arcsin(np.linalg.norm(c))
                 axis = np.abs(c) / np.linalg.norm(c)
-                rot = wp.quat_from_axis_angle(axis, angle)
+                rot = wp.quat_from_axis_angle(wp.vec3(*axis), wp.float32(angle))
         scale = wp.vec3(width, length, 0.0)
 
         return self._add_shape(
@@ -3501,11 +3514,11 @@ class ModelBuilder:
         i: int,
         j: int,
         k: int,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ) -> float:
         """Adds a triangular FEM element between three particles in the system.
 
@@ -3525,6 +3538,11 @@ class ModelBuilder:
             between the particles in their initial configuration.
         """
         # TODO: Expose elastic parameters on a per-element basis
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
 
         # compute basis for 2D rest pose
         p = self.particle_q[i]
@@ -3705,8 +3723,8 @@ class ModelBuilder:
         k: int,
         l: int,
         rest: float = None,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        edge_ke: float = None,
+        edge_kd: float = None,
     ):
         """Adds a bending edge element between four particles in the system.
 
@@ -3727,6 +3745,9 @@ class ModelBuilder:
             winding: (i, k, l), (j, l, k).
 
         """
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+
         # compute rest angle
         if rest is None:
             x1 = self.particle_q[i]
@@ -3834,17 +3855,17 @@ class ModelBuilder:
         fix_right: bool = False,
         fix_top: bool = False,
         fix_bottom: bool = False,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
+        edge_ke: float = None,
+        edge_kd: float = None,
         add_springs: bool = False,
-        spring_ke: float = default_spring_ke,
-        spring_kd: float = default_spring_kd,
-        particle_radius: float = default_particle_radius,
+        spring_ke: float = None,
+        spring_kd: float = None,
+        particle_radius: float = None,
     ):
         """Helper to create a regular planar cloth grid
 
@@ -3866,6 +3887,16 @@ class ModelBuilder:
             fix_top: Make the top-most edge of particles kinematic
             fix_bottom: Make the bottom-most edge of particles kinematic
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+        spring_ke = spring_ke if spring_ke is not None else self.default_spring_ke
+        spring_kd = spring_kd if spring_kd is not None else self.default_spring_kd
+        particle_radius = particle_radius if particle_radius is not None else self.default_particle_radius
 
         def grid_index(x, y, dim_x):
             return y * dim_x + x
@@ -3968,17 +3999,17 @@ class ModelBuilder:
         density: float,
         edge_callback=None,
         face_callback=None,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
+        edge_ke: float = None,
+        edge_kd: float = None,
         add_springs: bool = False,
-        spring_ke: float = default_spring_ke,
-        spring_kd: float = default_spring_kd,
-        particle_radius: float = default_particle_radius,
+        spring_ke: float = None,
+        spring_kd: float = None,
+        particle_radius: float = None,
     ):
         """Helper to create a cloth model from a regular triangle mesh
 
@@ -3999,6 +4030,17 @@ class ModelBuilder:
 
             The mesh should be two manifold.
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+        spring_ke = spring_ke if spring_ke is not None else self.default_spring_ke
+        spring_kd = spring_kd if spring_kd is not None else self.default_spring_kd
+        particle_radius = particle_radius if particle_radius is not None else self.default_particle_radius
+
         num_tris = int(len(indices) / 3)
 
         start_vertex = len(self.particle_q)
@@ -4076,9 +4118,11 @@ class ModelBuilder:
         cell_z: float,
         mass: float,
         jitter: float,
-        radius_mean: float = default_particle_radius,
+        radius_mean: float = None,
         radius_std: float = 0.0,
     ):
+        radius_mean = radius_mean if radius_mean is not None else self.default_particle_radius
+
         rng = np.random.default_rng(42)
         for z in range(dim_z):
             for y in range(dim_y):
@@ -4113,11 +4157,11 @@ class ModelBuilder:
         fix_right: bool = False,
         fix_top: bool = False,
         fix_bottom: bool = False,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ):
         """Helper to create a rectangular tetrahedral FEM grid
 
@@ -4144,6 +4188,11 @@ class ModelBuilder:
             fix_top: Make the top-most edge of particles kinematic
             fix_bottom: Make the bottom-most edge of particles kinematic
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
 
         start_vertex = len(self.particle_q)
 
@@ -4235,11 +4284,11 @@ class ModelBuilder:
         k_mu: float,
         k_lambda: float,
         k_damp: float,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ):
         """Helper to create a tetrahedral model from an input tetrahedral mesh
 
@@ -4254,6 +4303,12 @@ class ModelBuilder:
             k_lambda: The second elastic Lame parameter
             k_damp: The damping stiffness
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+
         num_tets = int(len(indices) / 4)
 
         start_vertex = len(self.particle_q)
@@ -4344,16 +4399,22 @@ class ModelBuilder:
         self,
         normal=None,
         offset=0.0,
-        ke: float = default_shape_ke,
-        kd: float = default_shape_kd,
-        kf: float = default_shape_kf,
-        mu: float = default_shape_mu,
-        restitution: float = default_shape_restitution,
+        ke: float = None,
+        kd: float = None,
+        kf: float = None,
+        mu: float = None,
+        restitution: float = None,
     ):
         """
         Creates a ground plane for the world. If the normal is not specified,
         the up_vector of the ModelBuilder is used.
         """
+        ke = ke if ke is not None else self.default_shape_ke
+        kd = kd if kd is not None else self.default_shape_kd
+        kf = kf if kf is not None else self.default_shape_kf
+        mu = mu if mu is not None else self.default_shape_mu
+        restitution = restitution if restitution is not None else self.default_shape_restitution
+
         if normal is None:
             normal = self.up_vector
         self._ground_params = {

warp/sim/render.py

@@ -213,7 +213,7 @@ def CreateSimRenderer(renderer):
                                 pos=p,
                                 rot=q,
                                 scale=geo_scale,
-                                colors=[color],
+                                colors=color,
                                 parent_body=body,
                                 is_template=True,
                             )
@@ -328,7 +328,7 @@ def CreateSimRenderer(renderer):
                         "surface",
                         particle_q,
                         self.model.tri_indices.numpy().flatten(),
-                        colors=(((0.75, 0.25, 0.0),) * len(particle_q)),
+                        colors=(0.75, 0.25, 0.0),
                     )
 
                 # render springs