Apply scale curve to singularities (#226)

NewHorizons/Builder/Body/SingularityBuilder.cs

@@ -7,6 +7,7 @@ using UnityEngine;
 using Logger = NewHorizons.Utility.Logger;
 using System.Collections.Generic;
 using System.Linq;
+using NewHorizons.Components.SizeControllers;
 
 namespace NewHorizons.Builder.Body
 {
@@ -15,11 +16,12 @@ namespace NewHorizons.Builder.Body
 
         private static Shader blackHoleShader = null;
         private static Shader whiteHoleShader = null;
-        private static readonly int Radius = Shader.PropertyToID("_Radius");
+
-        private static readonly int MaxDistortRadius = Shader.PropertyToID("_MaxDistortRadius");
+        public static readonly int Radius = Shader.PropertyToID("_Radius");
-        private static readonly int MassScale = Shader.PropertyToID("_MassScale");
+        public static readonly int MaxDistortRadius = Shader.PropertyToID("_MaxDistortRadius");
-        private static readonly int DistortFadeDist = Shader.PropertyToID("_DistortFadeDist");
+        public static readonly int MassScale = Shader.PropertyToID("_MassScale");
-        private static readonly int Color1 = Shader.PropertyToID("_Color");
+        public static readonly int DistortFadeDist = Shader.PropertyToID("_DistortFadeDist");
+        public static readonly int Color1 = Shader.PropertyToID("_Color");
 
         private static Dictionary<string, GameObject> _singularitiesByID;
 
@@ -44,10 +46,10 @@ namespace NewHorizons.Builder.Body
             switch (polarity)
             {
                 case SingularityModule.SingularityType.BlackHole:
-                    newSingularity = MakeBlackHole(go, sector, localPosition, size, hasHazardVolume, singularity.targetStarSystem);
+                    newSingularity = MakeBlackHole(go, sector, localPosition, size, hasHazardVolume, singularity.targetStarSystem, singularity.curve);
                     break;
                 case SingularityModule.SingularityType.WhiteHole:
-                    newSingularity = MakeWhiteHole(go, sector, OWRB, localPosition, size, makeZeroGVolume);
+                    newSingularity = MakeWhiteHole(go, sector, OWRB, localPosition, size, singularity.curve, makeZeroGVolume);
                     break;
             }
 
@@ -88,9 +90,12 @@ namespace NewHorizons.Builder.Body
             }
 
             blackHoleVolume._whiteHole = whiteHoleVolume;
+
+
         }
 
-        public static GameObject MakeBlackHole(GameObject planetGO, Sector sector, Vector3 localPosition, float size, bool hasDestructionVolume, string targetSolarSystem, bool makeAudio = true)
+        public static GameObject MakeBlackHole(GameObject planetGO, Sector sector, Vector3 localPosition, float size, 
+            bool hasDestructionVolume, string targetSolarSystem, VariableSizeModule.TimeValuePair[] curve, bool makeAudio = true)
         {
             var blackHole = new GameObject("BlackHole");
             blackHole.SetActive(false);
@@ -102,6 +107,14 @@ namespace NewHorizons.Builder.Body
             blackHoleRender.transform.localPosition = Vector3.zero;
             blackHoleRender.transform.localScale = Vector3.one * size;
 
+            BlackHoleSizeController sizeController = null;
+            if (curve != null)
+            {
+                sizeController = blackHoleRender.AddComponent<BlackHoleSizeController>();
+                sizeController.SetScaleCurve(curve);
+                sizeController.size = size;
+            }
+
             var meshFilter = blackHoleRender.AddComponent<MeshFilter>();
             meshFilter.mesh = SearchUtilities.Find("BrittleHollow_Body/BlackHole_BH/BlackHoleRenderer").GetComponent<MeshFilter>().mesh;
 
@@ -112,6 +125,7 @@ namespace NewHorizons.Builder.Body
             meshRenderer.material.SetFloat(MaxDistortRadius, size * 0.95f);
             meshRenderer.material.SetFloat(MassScale, 1);
             meshRenderer.material.SetFloat(DistortFadeDist, size * 0.55f);
+            if (sizeController != null) sizeController.material = meshRenderer.material;
 
             if (makeAudio)
             {
@@ -123,14 +137,15 @@ namespace NewHorizons.Builder.Body
                 blackHoleAudioSource.maxDistance = size * 2.5f;
                 blackHoleAudioSource.minDistance = size * 0.4f;
                 blackHoleAmbience.transform.localPosition = Vector3.zero;
+                if (sizeController != null) sizeController.audioSource = blackHoleAudioSource;
 
                 var blackHoleOneShot = GameObject.Instantiate(SearchUtilities.Find("BrittleHollow_Body/BlackHole_BH/BlackHoleEmissionOneShot"), blackHole.transform);
                 var oneShotAudioSource = blackHoleOneShot.GetComponent<AudioSource>();
                 oneShotAudioSource.maxDistance = size * 3f;
                 oneShotAudioSource.minDistance = size * 0.4f;
+                if (sizeController != null) sizeController.oneShotAudioSource = oneShotAudioSource;
             }
 
-
             if (hasDestructionVolume || targetSolarSystem != null)
             {
                 var destructionVolumeGO = new GameObject("DestructionVolume");
@@ -142,6 +157,7 @@ namespace NewHorizons.Builder.Body
                 var sphereCollider = destructionVolumeGO.AddComponent<SphereCollider>();
                 sphereCollider.radius = size * 0.4f;
                 sphereCollider.isTrigger = true;
+                if (sizeController != null) sizeController.sphereCollider = sphereCollider;
 
                 if (hasDestructionVolume) destructionVolumeGO.AddComponent<BlackHoleDestructionVolume>();
                 else if (targetSolarSystem != null)
@@ -154,14 +170,17 @@ namespace NewHorizons.Builder.Body
             {
                 var blackHoleVolume = GameObject.Instantiate(SearchUtilities.Find("BrittleHollow_Body/BlackHole_BH/BlackHoleVolume"), blackHole.transform);
                 blackHoleVolume.name = "BlackHoleVolume";
-                blackHoleVolume.GetComponent<SphereCollider>().radius = size * 0.4f;
+                var blackHoleSphereCollider = blackHoleVolume.GetComponent<SphereCollider>();
+                blackHoleSphereCollider.radius = size * 0.4f;
+                if (sizeController != null) sizeController.sphereCollider = blackHoleSphereCollider;
             }
 
             blackHole.SetActive(true);
             return blackHole;
         }
 
-        public static GameObject MakeWhiteHole(GameObject planetGO, Sector sector, OWRigidbody OWRB, Vector3 localPosition, float size, bool makeZeroGVolume = true)
+        public static GameObject MakeWhiteHole(GameObject planetGO, Sector sector, OWRigidbody OWRB, Vector3 localPosition, float size,
+            VariableSizeModule.TimeValuePair[] curve, bool makeZeroGVolume = true)
         {
             var whiteHole = new GameObject("WhiteHole");
             whiteHole.SetActive(false);
@@ -173,6 +192,14 @@ namespace NewHorizons.Builder.Body
             whiteHoleRenderer.transform.localPosition = Vector3.zero;
             whiteHoleRenderer.transform.localScale = Vector3.one * size * 2.8f;
 
+            WhiteHoleSizeController sizeController = null;
+            if (curve != null)
+            {
+                sizeController = whiteHoleRenderer.AddComponent<WhiteHoleSizeController>();
+                sizeController.SetScaleCurve(curve);
+                sizeController.size = size * 2.8f; // Gets goofy because of this
+            }
+
             var meshFilter = whiteHoleRenderer.AddComponent<MeshFilter>();
             meshFilter.mesh = SearchUtilities.Find("WhiteHole_Body/WhiteHoleVisuals/Singularity").GetComponent<MeshFilter>().mesh;
 
@@ -184,13 +211,16 @@ namespace NewHorizons.Builder.Body
             meshRenderer.sharedMaterial.SetFloat(MaxDistortRadius, size * 2.8f);
             meshRenderer.sharedMaterial.SetFloat(MassScale, -1);
             meshRenderer.sharedMaterial.SetColor(Color1, new Color(1.88f, 1.88f, 1.88f, 1f));
+            if (sizeController != null) sizeController.material = meshRenderer.sharedMaterial;
 
             var ambientLight = GameObject.Instantiate(SearchUtilities.Find("WhiteHole_Body/WhiteHoleVisuals/AmbientLight_WH"));
             ambientLight.transform.parent = whiteHole.transform;
             ambientLight.transform.localScale = Vector3.one;
             ambientLight.transform.localPosition = Vector3.zero;
             ambientLight.name = "AmbientLight";
-            ambientLight.GetComponent<Light>().range = size * 7f;
+            var light = ambientLight.GetComponent<Light>();
+            light.range = size * 7f;
+            if (sizeController != null) sizeController.light = light;
 
             GameObject whiteHoleVolumeGO = GameObject.Instantiate(SearchUtilities.Find("WhiteHole_Body/WhiteHoleVolume"));
             whiteHoleVolumeGO.transform.parent = whiteHole.transform;
@@ -198,11 +228,13 @@ namespace NewHorizons.Builder.Body
             whiteHoleVolumeGO.transform.localScale = Vector3.one;
             whiteHoleVolumeGO.GetComponent<SphereCollider>().radius = size;
             whiteHoleVolumeGO.name = "WhiteHoleVolume";
+            if (sizeController != null) sizeController.sphereCollider = whiteHoleVolumeGO.GetComponent<SphereCollider>(); 
 
             var whiteHoleFluidVolume = whiteHoleVolumeGO.GetComponent<WhiteHoleFluidVolume>();
             whiteHoleFluidVolume._innerRadius = size * 0.5f;
             whiteHoleFluidVolume._outerRadius = size;
             whiteHoleFluidVolume._attachedBody = OWRB;
+            if (sizeController != null) sizeController.fluidVolume = whiteHoleFluidVolume;
 
             var whiteHoleVolume = whiteHoleVolumeGO.GetComponent<WhiteHoleVolume>();
             whiteHoleVolume._debrisDistMax = size * 6.5f;
@@ -212,8 +244,7 @@ namespace NewHorizons.Builder.Body
             whiteHoleVolume._whiteHoleBody = OWRB;
             whiteHoleVolume._whiteHoleProxyShadowSuperGroup = planetGO.GetComponent<ProxyShadowCasterSuperGroup>();
             whiteHoleVolume._radius = size * 0.5f;
-
+            if (sizeController != null) sizeController.volume = whiteHoleVolume;
-            whiteHoleVolumeGO.GetComponent<SphereCollider>().radius = size;
 
             whiteHoleVolume.enabled = true;
             whiteHoleFluidVolume.enabled = true;
@@ -231,6 +262,12 @@ namespace NewHorizons.Builder.Body
                 rulesetVolume.transform.localPosition = Vector3.zero;
                 rulesetVolume.transform.localScale = Vector3.one * size / 100f;
                 rulesetVolume.GetComponent<SphereShape>().enabled = true;
+
+                if (sizeController != null)
+                {
+                    sizeController.zeroGSphereCollider = zeroGVolume.GetComponent<SphereCollider>();
+                    sizeController.rulesetVolume = rulesetVolume;
+                }
             }
 
             whiteHole.SetActive(true);

NewHorizons/Components/SizeControllers/BlackHoleSizeController.cs

@@ -0,0 +1,44 @@
+using NewHorizons.Builder.Body;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components.SizeControllers
+{
+    public class BlackHoleSizeController : SizeController
+    {
+        public Material material;
+        public AudioSource audioSource;
+        public AudioSource oneShotAudioSource;
+        public SphereCollider sphereCollider;
+
+        protected new void FixedUpdate()
+        {
+            base.FixedUpdate();
+
+            material.SetFloat(SingularityBuilder.Radius, CurrentScale * 0.4f);
+            material.SetFloat(SingularityBuilder.MaxDistortRadius, CurrentScale * 0.95f);
+            material.SetFloat(SingularityBuilder.DistortFadeDist, CurrentScale * 0.55f);
+
+            if (audioSource != null)
+            {
+                audioSource.maxDistance = CurrentScale * 2.5f;
+                audioSource.minDistance = CurrentScale * 0.4f;
+            }
+
+            if(oneShotAudioSource != null)
+            {
+                oneShotAudioSource.maxDistance = CurrentScale * 3f;
+                oneShotAudioSource.minDistance = CurrentScale * 0.4f;
+            }
+
+            if (sphereCollider != null)
+            {
+                sphereCollider.radius = CurrentScale * 0.4f;
+            }
+        }
+    }
+}

NewHorizons/Components/SizeControllers/SizeController.cs

@@ -1,4 +1,5 @@
-using UnityEngine;
+using NewHorizons.External.Modules.VariableSize;
+using UnityEngine;
 namespace NewHorizons.Components.SizeControllers
 {
     public class SizeController : MonoBehaviour
@@ -20,5 +21,14 @@ namespace NewHorizons.Components.SizeControllers
 
             base.transform.localScale = Vector3.one * CurrentScale;
         }
+
+        public void SetScaleCurve(VariableSizeModule.TimeValuePair[] curve)
+        {
+            scaleCurve = new AnimationCurve();
+            foreach (var pair in curve)
+            {
+                scaleCurve.AddKey(new Keyframe(pair.time, pair.value));
+            }
+        }
     }
 }

NewHorizons/Components/SizeControllers/WhiteHoleSizeController.cs

@@ -0,0 +1,55 @@
+using NewHorizons.Builder.Body;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace NewHorizons.Components.SizeControllers
+{
+    public class WhiteHoleSizeController : SizeController
+    {
+        public Material material;
+        public Light light;
+        public SphereCollider sphereCollider, zeroGSphereCollider;
+        public WhiteHoleFluidVolume fluidVolume;
+        public WhiteHoleVolume volume;
+        public GameObject rulesetVolume;
+
+        public new void FixedUpdate()
+        {
+            base.FixedUpdate();
+
+            // The "size" parameter set in the config got multiplied by 2.8 so we gotta divide by that
+            var trueSize = CurrentScale / 2.8f;
+
+            material.SetFloat(SingularityBuilder.Radius, trueSize * 0.4f);
+            material.SetFloat(SingularityBuilder.DistortFadeDist, trueSize);
+            material.SetFloat(SingularityBuilder.MaxDistortRadius, trueSize * 2.8f);
+
+            if (light != null)
+            {
+                light.range = trueSize * 7f;
+            }
+
+            if (sphereCollider != null) sphereCollider.radius = trueSize;
+
+            if (fluidVolume != null)
+            {
+                fluidVolume._innerRadius = trueSize * 0.5f;
+                fluidVolume._outerRadius = trueSize;
+            }
+            
+            if (volume != null)
+            {
+                volume._debrisDistMax = trueSize * 6.5f;
+                volume._debrisDistMin = trueSize * 2f;
+                volume._radius = trueSize * 0.5f;
+            }
+
+            if (zeroGSphereCollider != null) zeroGSphereCollider.radius = trueSize * 10f;
+            if (rulesetVolume != null) rulesetVolume.transform.localScale = Vector3.one * trueSize / 100f;
+        }
+    }
+}