Merge pull request #2 from sandalconsumer/spring-mass-modularity

System Refactor for ease of understanding and use.

Author: sandalconsumer

Assets/Scenes/SampleScene.unity

@@ -0,0 +1,76 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Drawing;
+using Color = UnityEngine.Color;
+
+[RequireComponent(typeof(SimulationDataCompiler))]
+public class PhysicsController : MonoBehaviour
+{
+    private SimulationEndData simulationEndData;
+
+    public bool visualizeSprings = true;
+    public bool recordData = true;
+    
+    public List<Pointmass> masses = new List<Pointmass>();
+    public List<Spring> springs = new List<Spring>();
+
+    private float timestep;
+    private float totalTime;
+    
+    void Start()
+    {
+        simulationEndData = GetComponent<SimulationDataCompiler>().simulationEndData;
+        timestep = Time.fixedDeltaTime;
+        
+        foreach (Spring spring in springs)
+        {
+            int rootLinkedIndex = spring.rootLinkedIndex;
+            int endLinkedIndex = spring.endLinkedIndex;
+
+            if (spring.rootLinkedIndex < masses.Count)
+            {
+                spring.rootLinked = masses[rootLinkedIndex];
+            }
+
+            if (spring.endLinkedIndex < masses.Count)
+            {
+                spring.endLinked = masses[endLinkedIndex];
+            }
+        }
+    }
+
+    void FixedUpdate()
+    {
+        foreach (Pointmass mass in masses)
+        {
+            mass.VerletHalfstep(timestep);
+        }
+
+        foreach (Spring spring in springs)
+        {
+            Vector3 springVector = spring.endLinked.position - spring.rootLinked.position;
+            float currentLength = springVector.magnitude;
+            float extension = currentLength - spring.restLength;
+            
+            Vector3 springDirection = springVector.normalized;
+            spring.restorativeForce = -spring.springConstant * extension * springDirection;
+
+            spring.rootLinked.leadForce -= spring.restorativeForce;
+            spring.endLinked.leadForce += spring.restorativeForce;
+            
+            if(visualizeSprings) {Debug.DrawLine(spring.rootLinked.position, spring.endLinked.position, Color.yellow);}
+            if(recordData) {simulationEndData.stretches.Add(extension);}
+        }
+        
+        foreach (Pointmass mass in masses)
+        {
+            mass.VerletFinalstep(timestep);
+            
+            mass.leadForce = Vector3.zero;
+            if(recordData) {simulationEndData.positions.Add(mass.position);}
+        }
+        
+        totalTime += timestep;
+        if(recordData) {simulationEndData.timeStamps.Add(totalTime);}
+    }
+}

Assets/Scripts/Physics/Body.cs

@@ -0,0 +1,42 @@
+using UnityEngine;
+using System.Collections.Generic;
+using Unity.Mathematics;
+
+[System.Serializable]
+public class Spring 
+{
+    public float springConstant = 100;
+    
+    public float restLength;
+
+    public int rootLinkedIndex;
+    public int endLinkedIndex;
+
+    [HideInInspector]public Pointmass rootLinked;
+    [HideInInspector]public Pointmass endLinked;
+    
+    [HideInInspector]public Vector3 restorativeForce = Vector3.zero; 
+}
+
+[System.Serializable]
+public class Pointmass
+{
+    public Vector3 position;
+    Vector3 acceleration;
+    Vector3 velocity;
+
+    public float mass = 100;
+    [HideInInspector]public Vector3 leadForce;
+
+    public void VerletHalfstep(float deltaTime)
+    {
+        position += velocity * deltaTime + acceleration * (0.5f * deltaTime * deltaTime);
+    }
+
+    public void VerletFinalstep(float deltaTime)
+    {
+        Vector3 nA = leadForce / mass;
+        velocity += (acceleration + nA) * (0.5f * deltaTime);
+        acceleration = leadForce / mass;
+    }
+}

Assets/Scripts/Physics/PhysicsController.cs

@@ -0,0 +1,26 @@
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(Pointmass))]
+public class PointmassEditor : Editor
+{
+    private SerializedProperty mass;
+    private SerializedProperty position;
+
+    void OnEnable()
+    {
+        mass = serializedObject.FindProperty("mass");
+        position = serializedObject.FindProperty("position");
+    }
+
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+        
+        EditorGUILayout.LabelField("Pointmass Properties", EditorStyles.boldLabel);
+        EditorGUILayout.PropertyField(mass);
+        EditorGUILayout.PropertyField(position);
+        
+        serializedObject.ApplyModifiedProperties();
+    }
+}

Assets/Scripts/Physics/PhysicsController.cs.meta

@@ -8,14 +8,15 @@ public class SimulationEndData
     public List<float> stretches = new List<float>();
 }
 
+[RequireComponent(typeof(PhysicsController))]
 public class SimulationDataCompiler : MonoBehaviour // to be used as a singleton
 {
     public SimulationEndData simulationEndData = new SimulationEndData();
 
     public float plotScale = 1f;
     public Vector3 plotOrigin = new Vector3(10, 0, 0);
 
-    void Update()
+    void FixedUpdate()
     {
         for (int i = 1; i < simulationEndData.timeStamps.Count; i++)
         {
@@ -24,4 +25,6 @@ void Update()
             Debug.DrawLine(p1, p2, Color.cyan);
         }
     }
+    
+    
 }

Assets/Scripts/Physics/PhysicsObjects.cs

@@ -4,13 +4,15 @@
 [CustomEditor(typeof(Spring))]
 public class SpringEditor : Editor
 {
-    private SerializedProperty rootPosition;
+    private SerializedProperty rootLinked;
+    private SerializedProperty endLinked;
     private SerializedProperty springConstant;
     private SerializedProperty restLength;
 
     void OnEnable()
     {
-        rootPosition = serializedObject.FindProperty("rootPosition");
+        rootLinked = serializedObject.FindProperty("rootLinkedIndex");
+        endLinked = serializedObject.FindProperty("endLinkedIndex");
         springConstant = serializedObject.FindProperty("springConstant");
         restLength = serializedObject.FindProperty("restLength");
     }
@@ -20,7 +22,8 @@ public override void OnInspectorGUI()
         serializedObject.Update();
 
         EditorGUILayout.LabelField("Spring Properties", EditorStyles.boldLabel);
-        EditorGUILayout.PropertyField(rootPosition);
+        EditorGUILayout.PropertyField(rootLinked);
+        EditorGUILayout.PropertyField(endLinked);
         EditorGUILayout.PropertyField(springConstant);
         EditorGUILayout.PropertyField(restLength);