Add Joint base class to joint classes

src/Jitter2/Dynamics/Joints/HingeJoint.cs

@@ -28,7 +28,7 @@ namespace Jitter2.Dynamics.Constraints;
 /// <summary>
 /// Constructs a hinge joint utilizing a <see cref="HingeAngle"/>, a <see cref="BallSocket"/>, and an optional <see cref="AngularMotor"/>.
 /// </summary>
-public class HingeJoint
+public class HingeJoint : Joint
 {
     public RigidBody Body1 { get; private set; }
     public RigidBody Body2 { get; private set; }
@@ -47,14 +47,17 @@ public HingeJoint(World world, RigidBody body1, RigidBody body2, JVector hingeCe
 
         HingeAngle = world.CreateConstraint<HingeAngle>(body1, body2);
         HingeAngle.Initialize(hingeAxis, angle);
+        Register(HingeAngle);
 
         BallSocket = world.CreateConstraint<BallSocket>(body1, body2);
         BallSocket.Initialize(hingeCenter);
+        Register(BallSocket);
 
         if (hasMotor)
         {
             Motor = world.CreateConstraint<AngularMotor>(body1, body2);
             Motor.Initialize(hingeAxis);
+            Register(Motor);
         }
     }
 

src/Jitter2/Dynamics/Joints/Joint.cs

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Thorben Linneweber and others
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+using System.Collections.Generic;
+using Jitter2.DataStructures;
+
+namespace Jitter2.Dynamics.Constraints;
+
+public class Joint
+{
+    private readonly List<Constraint> constraints = new(4);
+    public ReadOnlyList<Constraint> Constraints { get; }
+
+    private protected Joint()
+    {
+        Constraints = new ReadOnlyList<Constraint>(constraints);
+    }
+
+    /// <summary>
+    /// Add a constraint to the internal book keeping
+    /// </summary>
+    protected void Register(Constraint constraint) => constraints.Add(constraint);
+
+    /// <summary>
+    /// Remove a constraint from the internal book keeping
+    /// </summary>
+    protected void Deregister(Constraint constraint) => constraints.Remove(constraint);
+
+    /// <summary>
+    /// Enables all constraints that this joint is composed of.
+    /// </summary>
+    public void Enable()
+    {
+        foreach (var constraint in constraints)
+        {
+            if (constraint.Handle.IsZero) continue;
+            constraint.IsEnabled = true;
+        }
+    }
+
+    /// <summary>
+    /// Disables all constraints that this joint is composed of temporarily.
+    /// For a complete removal use <see cref="Joint.Remove()"/>.
+    /// </summary>
+    public void Disable()
+    {
+        foreach (var constraint in constraints)
+        {
+            if (constraint.Handle.IsZero) continue;
+            constraint.IsEnabled = false;
+        }
+    }
+
+    /// <summary>
+    /// Removes all constraints that this joint is composed of from the physics world.
+    /// </summary>
+    public void Remove()
+    {
+        foreach (var constraint in constraints)
+        {
+            if (constraint.Handle.IsZero) continue;
+            constraint.Body1.World.Remove(constraint);
+        }
+
+        constraints.Clear();
+    }
+}

src/Jitter2/Dynamics/Joints/PrismaticJoint.cs

@@ -29,7 +29,7 @@ namespace Jitter2.Dynamics.Constraints;
 /// Constructs a prismatic joint utilizing a <see cref="PointOnLine"/> constraint in conjunction with
 /// <see cref="FixedAngle"/>, <see cref="HingeAngle"/>, and <see cref="LinearMotor"/> constraints.
 /// </summary>
-public class PrismaticJoint
+public class PrismaticJoint : Joint
 {
     public RigidBody Body1 { get; private set; }
     public RigidBody Body2 { get; private set; }
@@ -56,22 +56,26 @@ public PrismaticJoint(World world, RigidBody body1, RigidBody body2, JVector cen
 
         Slider = world.CreateConstraint<PointOnLine>(body1, body2);
         Slider.Initialize(axis, center, center, limit);
+        Register(Slider);
 
         if (pinned)
         {
             FixedAngle = world.CreateConstraint<FixedAngle>(body1, body2);
             FixedAngle.Initialize();
+            Register(FixedAngle);
         }
         else
         {
             HingeAngle = world.CreateConstraint<HingeAngle>(body1, body2);
             HingeAngle.Initialize(axis, AngularLimit.Full);
+            Register(HingeAngle);
         }
 
         if (hasMotor)
         {
             Motor = world.CreateConstraint<LinearMotor>(body1, body2);
             Motor.Initialize(axis, axis);
+            Register(Motor);
         }
     }
 

src/Jitter2/Dynamics/Joints/UniversalJoint.cs

@@ -29,7 +29,7 @@ namespace Jitter2.Dynamics.Constraints;
 /// Creates a universal joint utilizing a <see cref="TwistAngle"/>, <see cref="BallSocket"/>, and an optional <see cref="AngularMotor"/>
 /// constraint.
 /// </summary>
-public class UniversalJoint
+public class UniversalJoint : Joint
 {
     public RigidBody Body1 { get; private set; }
     public RigidBody Body2 { get; private set; }
@@ -48,14 +48,17 @@ public UniversalJoint(World world, RigidBody body1, RigidBody body2, JVector cen
 
         TwistAngle = world.CreateConstraint<TwistAngle>(body1, body2);
         TwistAngle.Initialize(rotateAxis1, rotateAxis2);
+        Register(TwistAngle);
 
         BallSocket = world.CreateConstraint<BallSocket>(body1, body2);
         BallSocket.Initialize(center);
+        Register(TwistAngle);
 
         if (hasMotor)
         {
             Motor = world.CreateConstraint<AngularMotor>(body1, body2);
             Motor.Initialize(rotateAxis1, rotateAxis2);
+            Register(Motor);
         }
     }
 }

src/Jitter2/UnmanagedMemory/UnmanagedActiveList.cs

@@ -45,6 +45,8 @@ internal JHandle(T** ptr)
         Pointer = ptr;
     }
 
+    public bool IsZero => Pointer == (T**)null;
+
     internal static JHandle<K> AsHandle<K>(JHandle<T> handle) where K : unmanaged
     {
         return new JHandle<K>((K**)handle.Pointer);

src/JitterDemo/Demos/Demo01.cs

@@ -87,8 +87,7 @@ public void Draw()
             var h = hinges[i];
             if (h.BallSocket.Impulse.Length() > 0.5f)
             {
-                world.Remove(h.BallSocket);
-                world.Remove(h.HingeAngle);
+                h.Remove();
                 hinges.RemoveAt(i);
             }
         }