Gittes-archive/new-horizons
2
0
Fork 0
mirror of https://github.com/Outer-Wilds-New-Horizons/new-horizons.git synced 2025-12-11 20:15:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5 from salomj/somework

Browse Source 
Some Fixes
This commit is contained in:
Nick 2021-12-30 16:48:12 -05:00 committed by GitHub
commit d3503ea1d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 263 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
NewHorizons/Builder/General/DetectorBuilder.cs
View File

@ -149,14 +149,19 @@ namespace NewHorizons.Builder.General
secondaryAO.SetKeplerCoordinatesFromTrueAnomaly(ecc, r2 / (1f - ecc), i, l, p, 180);
// Make sure positions are right
primary.transform.position = point.transform.position + OrbitalHelper.GetPosition(primaryAO);
secondary.transform.position = point.transform.position + OrbitalHelper.GetPosition(secondaryAO);
var gravity = new OrbitalHelper.Gravity(exponent, totalMass);
var primaryCat = OrbitalHelper.GetCartesian(gravity, primaryAO);
var secondaryCat = OrbitalHelper.GetCartesian(gravity, secondaryAO);
primary.transform.position = point.transform.position + primaryCat.Item1;
secondary.transform.position = point.transform.position + secondaryCat.Item1;
Logger.Log($"Primary AO: [{primaryAO}], Secondary AO: [{secondaryAO}]");
// Finally we update the speeds
var v1 = OrbitalHelper.GetVelocity(new OrbitalHelper.Gravity(exponent, totalMass), primaryAO);
var v2 = OrbitalHelper.GetVelocity(new OrbitalHelper.Gravity(exponent, totalMass), secondaryAO);
var v1 = primaryCat.Item2;
var v2 = primaryCat.Item2;
var focalPointMotion = point.gameObject.GetComponent<InitialMotion>();
var focalPointVelocity = focalPointMotion == null ? Vector3.zero : focalPointMotion.GetInitVelocity();

289
NewHorizons/Builder/General/HeavenlyBodyBuilder.cs
View File

@ -1,134 +1,155 @@
using NewHorizons.External;
using NewHorizons.OrbitalPhysics;
using NewHorizons.Utility;
using OWML.Utils;
using PacificEngine.OW_CommonResources.Game.Resource;
using PacificEngine.OW_CommonResources.Game.State;
using PacificEngine.OW_CommonResources.Geometry.Orbits;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using Logger = NewHorizons.Utility.Logger;
namespace NewHorizons.Builder.General
{
public static class HeavenlyBodyBuilder
{
private static readonly Dictionary<string, HeavenlyBody> _bodyMap = new Dictionary<string, HeavenlyBody>();
public static void Make(GameObject body, IPlanetConfig config, float SOI, GravityVolume bodyGravity, InitialMotion initialMotion)
{
var size = new Position.Size(config.Base.SurfaceSize, SOI);
var gravity = Gravity.of(0, 0);
if(bodyGravity != null)
{
var G = GravityVolume.GRAVITATIONAL_CONSTANT;
var exponent = bodyGravity.GetFalloffExponent();
var mass = bodyGravity._surfaceAcceleration * Mathf.Pow(bodyGravity._upperSurfaceRadius, exponent) / G;
gravity = Gravity.of(bodyGravity == null ? 2f : exponent, bodyGravity == null ? 0 : mass);
}
var parent = GetBody(config.Orbit.PrimaryBody);
var orbit = OrbitalHelper.KeplerCoordinatesFromOrbitModule(config.Orbit);
var hb = GetBody(config.Name);
if (hb == null)
{
hb = AddHeavenlyBody(config.Name);
}
Planet.Plantoid planetoid;
if (!config.Orbit.IsStatic)
{
planetoid = new Planet.Plantoid(size, gravity, body.transform.rotation, initialMotion._initAngularSpeed, parent, orbit);
}
else
{
planetoid = new Planet.Plantoid(size, gravity, body.transform.rotation, 0f, HeavenlyBody.None, body.transform.position, Vector3.zero);
}
var mapping = Planet.defaultMapping;
mapping[hb] = planetoid;
Planet.defaultMapping = mapping;
// Fix for binary focal points
var focalPoint = Position.AstroLookup[parent].Invoke()?.gameObject.GetComponent<BinaryFocalPoint>();
if (focalPoint != null && Planet.defaultMapping.ContainsKey(parent))
{
var primary = Position.getBody(GetBody(focalPoint.PrimaryName));
var secondary = Position.getBody(GetBody(focalPoint.SecondaryName));
if(primary != null && secondary != null)
{
Logger.Log($"Fixing BinaryFocalPoint HeavenlyBody gravity value for {parent.name}");
var exponent = ((primary?.GetAttachedGravityVolume()?.GetValue<float>("_falloffExponent") ?? 2f) + (secondary?.GetAttachedGravityVolume()?.GetValue<float>("_falloffExponent") ?? 2f)) / 2f;
var mass = ((primary?.GetAttachedGravityVolume()?.GetValue<float>("_gravitationalMass") ?? ((primary?.GetMass() ?? 0f) * 1000f)) + (secondary?.GetAttachedGravityVolume()?.GetValue<float>("_gravitationalMass") ?? ((secondary?.GetMass() ?? 0f) * 1000f))) / 4f;
var currentValue = Planet.mapping[parent];
var newValue = new Planet.Plantoid(currentValue.size, Gravity.of(exponent, mass), currentValue.state);
Planet.defaultMapping[parent] = newValue;
}
}
}
private static HeavenlyBody AddHeavenlyBody(string name)
{
var hb = new HeavenlyBody(name);
_bodyMap.Add(name, hb);
var astroLookup = Position.AstroLookup;
var bodyLookup = Position.BodyLookup;
astroLookup.Add(hb, () => GetAstroObject(name));
bodyLookup.Add(hb, () => GetOWRigidbody(name));
Position.AstroLookup = astroLookup;
Position.BodyLookup = bodyLookup;
return hb;
}
private static HeavenlyBody GetBody(string name)
{
if (_bodyMap.ContainsKey(name))
{
return _bodyMap[name];
}
var hb = Position.find(AstroObjectLocator.GetAstroObject(name));
if (hb != null)
{
_bodyMap.Add(name, hb);
}
return hb;
}
public static void OnDestroy()
{
Planet.defaultMapping = Planet.standardMapping;
}
private static AstroObject GetAstroObject(string name)
{
var astroBody = AstroObjectLocator.GetAstroObject(name);
if (astroBody == null
|| astroBody.gameObject == null)
{
return null;
}
return astroBody;
}
private static OWRigidbody GetOWRigidbody(string name)
{
var astroBody = GetAstroObject(name);
return astroBody?.GetOWRigidbody();
}
}
}
using NewHorizons.External;
using NewHorizons.OrbitalPhysics;
using NewHorizons.Utility;
using OWML.Common;
using OWML.Utils;
using PacificEngine.OW_CommonResources.Game;
using PacificEngine.OW_CommonResources.Game.Resource;
using PacificEngine.OW_CommonResources.Game.State;
using PacificEngine.OW_CommonResources.Geometry.Orbits;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using Logger = NewHorizons.Utility.Logger;
namespace NewHorizons.Builder.General
{
public static class HeavenlyBodyBuilder
{
private static readonly Dictionary<string, HeavenlyBody> _bodyMap = new Dictionary<string, HeavenlyBody>();
public static void Make(GameObject body, IPlanetConfig config, float SOI, GravityVolume bodyGravity, InitialMotion initialMotion)
{
var size = new Position.Size(config.Base.SurfaceSize, SOI);
var gravity = getGravity(bodyGravity);
var parent = GetBody(config.Orbit.PrimaryBody);
var orbit = OrbitalHelper.KeplerCoordinatesFromOrbitModule(config.Orbit);
if (parent == HeavenlyBody.None)
{
Helper.helper.Console.WriteLine($"Could not find planet ({config.Name}) reference to its parent {config.Orbit.PrimaryBody}", MessageType.Warning);
}
var hb = GetBody(config.Name);
if (hb == null)
{
hb = AddHeavenlyBody(config.Name);
}
Planet.Plantoid planetoid;
if (!config.Orbit.IsStatic)
{
planetoid = new Planet.Plantoid(size, gravity, body.transform.rotation, initialMotion._initAngularSpeed, parent, orbit);
}
else
{
planetoid = new Planet.Plantoid(size, gravity, body.transform.rotation, 0f, HeavenlyBody.None, body.transform.position, Vector3.zero);
}
var mapping = Planet.defaultMapping;
mapping[hb] = planetoid;
Planet.defaultMapping = mapping;
// Fix for binary focal points
var focalPoint = Position.AstroLookup[parent].Invoke()?.gameObject.GetComponent<BinaryFocalPoint>();
if (focalPoint != null && mapping.ContainsKey(parent))
{
var primary = Position.getBody(GetBody(focalPoint.PrimaryName));
var secondary = Position.getBody(GetBody(focalPoint.SecondaryName));
if(primary != null && secondary != null)
{
Logger.Log($"Fixing BinaryFocalPoint HeavenlyBody gravity value for {parent.name}");
var primaryGravity = getGravity(primary?.GetAttachedGravityVolume());
var secondaryGravity = getGravity(secondary?.GetAttachedGravityVolume());
var exponent = (primaryGravity.exponent + secondaryGravity.exponent) / 2f;
var mass = (primaryGravity.mass + secondaryGravity.mass) / 4f;
mapping[parent] = new Planet.Plantoid(mapping[parent].size, Gravity.of(exponent, mass), mapping[parent].state);
Planet.defaultMapping = mapping;
}
}
}
public static void Remove(AstroObject obj)
{
var astro = Position.find(obj);
var mapping = Planet.defaultMapping;
mapping.Remove(astro);
Planet.defaultMapping = mapping;
}
private static Gravity getGravity(GravityVolume volume)
{
if (volume == null)
{
return Gravity.of(2, 0);
}
var exponent = volume._falloffType != GravityVolume.FalloffType.linear ? 2f : 1f;
var mass = (volume._surfaceAcceleration * Mathf.Pow(volume._upperSurfaceRadius, exponent)) / GravityVolume.GRAVITATIONAL_CONSTANT;
return Gravity.of(exponent, mass);
}
private static HeavenlyBody AddHeavenlyBody(string name)
{
var hb = new HeavenlyBody(name);
_bodyMap.Add(name, hb);
var astroLookup = Position.AstroLookup;
var bodyLookup = Position.BodyLookup;
astroLookup.Add(hb, () => GetAstroObject(name));
bodyLookup.Add(hb, () => GetOWRigidbody(name));
Position.AstroLookup = astroLookup;
Position.BodyLookup = bodyLookup;
return hb;
}
private static HeavenlyBody GetBody(string name)
{
if (_bodyMap.ContainsKey(name))
{
return _bodyMap[name];
}
var hb = Position.find(AstroObjectLocator.GetAstroObject(name));
if (hb != null)
{
_bodyMap.Add(name, hb);
}
return hb;
}
public static void Reset()
{
Planet.defaultMapping = Planet.standardMapping;
}
private static AstroObject GetAstroObject(string name)
{
var astroBody = AstroObjectLocator.GetAstroObject(name);
if (astroBody == null
|| astroBody.gameObject == null)
{
return null;
}
return astroBody;
}
private static OWRigidbody GetOWRigidbody(string name)
{
var astroBody = GetAstroObject(name);
return astroBody?.GetOWRigidbody();
}
}
}

2
NewHorizons/Builder/General/PlanetDestroyer.cs
View File

@ -102,6 +102,8 @@ namespace NewHorizons.Builder.General
Main.Instance.ModHelper.Events.Unity.FireOnNextUpdate(() => RemoveProxy(ao.name.Replace("_Body", "")));
ao.transform.root.gameObject.SetActive(false);
HeavenlyBodyBuilder.Remove(ao);
}
public static void RemoveDistantProxyClones()

2
NewHorizons/Builder/Orbital/InitialMotionBuilder.cs
View File

@ -38,7 +38,7 @@ namespace NewHorizons.Builder.Orbital
var gv = primaryBody.GetGravityVolume();
if(gv != null)
{
var velocity = OrbitalHelper.GetVelocity(new OrbitalHelper.Gravity(primaryBody.GetGravityVolume()), orbit);
var velocity = OrbitalHelper.GetCartesian(new OrbitalHelper.Gravity(primaryBody.GetGravityVolume()), orbit).Item2;
// For some stupid reason the InitialMotion awake method transforms the perfectly fine direction vector you give it so we preemptively do the inverse so it all cancels out
initialMotion._initLinearDirection = body.transform.InverseTransformDirection(velocity.normalized);

4
NewHorizons/Main.cs
View File

@ -70,7 +70,7 @@ namespace NewHorizons
void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
Logger.Log($"Scene Loaded: {scene.name} {mode}");
HeavenlyBodyBuilder.OnDestroy();
HeavenlyBodyBuilder.Reset();
if (scene.name != "SolarSystem") { return; }
Instance.ModHelper.Events.Unity.FireOnNextUpdate(() => Locator.GetPlayerBody().gameObject.AddComponent<DebugRaycaster>());
@ -290,7 +290,7 @@ namespace NewHorizons
// Now that we're done move the planet into place
go.transform.parent = Locator.GetRootTransform();
go.transform.position = OrbitalHelper.GetPosition(body.Config.Orbit) + primaryBody.transform.position;
go.transform.position = OrbitalHelper.GetCartesian(new OrbitalHelper.Gravity(1, 100), body.Config.Orbit).Item1 + primaryBody.transform.position;
if (go.transform.position.magnitude > FurthestOrbit)
{

209
NewHorizons/OrbitalPhysics/OrbitalHelper.cs
View File

@ -1,119 +1,90 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using NewHorizons.Utility;
using Logger = NewHorizons.Utility.Logger;
using NewHorizons.External;
using CRGravity = PacificEngine.OW_CommonResources.Geometry.Orbits.Gravity;
using KeplerCoordinates = PacificEngine.OW_CommonResources.Geometry.Orbits.KeplerCoordinates;
/*
* Wrapper class for OW_CommonResources.Geometry.Orbits functions
*/
namespace NewHorizons.OrbitalPhysics
{
public static class OrbitalHelper
{
public enum FalloffType
{
inverseSquared,
linear,
none
}
public static Vector3 GetPosition(OrbitModule orbit)
{
Vector3 pos = Vector3.zero;
if(orbit.SemiMajorAxis != 0)
{
// The gravity doesnt have an affect on position so we put whatever
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, 1f, 100f);
var kepler = KeplerCoordinates.fromTrueAnomaly(orbit.Eccentricity, orbit.SemiMajorAxis, orbit.Inclination, orbit.ArgumentOfPeriapsis, orbit.LongitudeOfAscendingNode, orbit.TrueAnomaly);
pos = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item1;
}
return pos;
}
public static Vector3 GetPosition(ParameterizedAstroObject ao)
{
Vector3 pos = Vector3.zero;
if(ao.SemiMajorAxis != 0)
{
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, 1f, 100f);
var kepler = KeplerCoordinates.fromTrueAnomaly(ao.Eccentricity, ao.SemiMajorAxis, ao.Inclination, ao.ArgumentOfPeriapsis, ao.LongitudeOfAscendingNode, ao.TrueAnomaly);
pos = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item1;
}
return pos;
}
public static Vector3 GetPositionFromTrueAnomaly(float eccentricity, float semiMajorAxis, float inclination, float argumentOfPeriapsis, float longitudeOfAscendingNode, float trueAnomaly)
{
Vector3 pos = Vector3.zero;
if (semiMajorAxis != 0)
{
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, 1f, 100f);
var kepler = KeplerCoordinates.fromTrueAnomaly(eccentricity, semiMajorAxis, inclination, argumentOfPeriapsis, longitudeOfAscendingNode, trueAnomaly);
pos = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item1;
}
return pos;
}
public static Vector3 GetPositionFromEccentricAnomaly(float eccentricity, float semiMajorAxis, float inclination, float argumentOfPeriapsis, float longitudeOfAscendingNode, float eccentricAnomaly)
{
Vector3 pos = Vector3.zero;
if (semiMajorAxis != 0)
{
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, 1f, 100f);
var kepler = KeplerCoordinates.fromEccentricAnomaly(eccentricity, semiMajorAxis, inclination, argumentOfPeriapsis, longitudeOfAscendingNode, eccentricAnomaly);
pos = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item1;
}
return pos;
}
public static Vector3 GetVelocity(Gravity gravity, OrbitModule orbit)
{
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, gravity.Exponent, gravity.Mass);
var kepler = KeplerCoordinates.fromTrueAnomaly(orbit.Eccentricity, orbit.SemiMajorAxis, orbit.Inclination, orbit.ArgumentOfPeriapsis, orbit.LongitudeOfAscendingNode, orbit.TrueAnomaly);
var vel = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item2;
return vel;
}
public static Vector3 GetVelocity(Gravity gravity, ParameterizedAstroObject ao)
{
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, gravity.Exponent, gravity.Mass);
var kepler = KeplerCoordinates.fromTrueAnomaly(ao.Eccentricity, ao.SemiMajorAxis, ao.Inclination, ao.ArgumentOfPeriapsis, ao.LongitudeOfAscendingNode, ao.TrueAnomaly);
var vel = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler).Item2;
return vel;
}
public static KeplerCoordinates KeplerCoordinatesFromOrbitModule(OrbitModule orbit)
{
return KeplerCoordinates.fromTrueAnomaly(orbit.Eccentricity, orbit.SemiMajorAxis, orbit.Inclination, orbit.ArgumentOfPeriapsis, orbit.LongitudeOfAscendingNode, orbit.TrueAnomaly);
}
public class Gravity
{
public float Exponent { get; }
public float Mass { get; }
public Gravity(float exponent, float mass)
{
Exponent = exponent;
Mass = mass;
}
public Gravity(GravityVolume gv)
{
Exponent = gv.GetFalloffExponent();
Mass = gv.GetStandardGravitationalParameter() / GravityVolume.GRAVITATIONAL_CONSTANT;
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using NewHorizons.Utility;
using Logger = NewHorizons.Utility.Logger;
using NewHorizons.External;
using CRGravity = PacificEngine.OW_CommonResources.Geometry.Orbits.Gravity;
using KeplerCoordinates = PacificEngine.OW_CommonResources.Geometry.Orbits.KeplerCoordinates;
/*
* Wrapper class for OW_CommonResources.Geometry.Orbits functions
*/
namespace NewHorizons.OrbitalPhysics
{
public static class OrbitalHelper
{
public enum FalloffType
{
inverseSquared,
linear,
none
}
public static Tuple<Vector3, Vector3> GetCartesian(Gravity gravity, OrbitModule orbit)
{
if (orbit.SemiMajorAxis == 0)
{
return Tuple.Create(Vector3.zero, Vector3.zero);
}
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, gravity.Exponent, gravity.Mass);
var kepler = KeplerCoordinates.fromTrueAnomaly(orbit.Eccentricity, orbit.SemiMajorAxis, orbit.Inclination, orbit.ArgumentOfPeriapsis, orbit.LongitudeOfAscendingNode, orbit.TrueAnomaly);
var cartesian = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler);
if (cartesian == null)
{
cartesian = Tuple.Create(Vector3.zero, Vector3.zero);
}
Logger.Log($"Position : {cartesian.Item1} Velocity : {cartesian.Item2}");
return cartesian;
}
public static Tuple<Vector3, Vector3> GetCartesian(Gravity gravity, ParameterizedAstroObject ao)
{
if (ao.SemiMajorAxis == 0)
{
return Tuple.Create(Vector3.zero, Vector3.zero);
}
var crGravity = new CRGravity(GravityVolume.GRAVITATIONAL_CONSTANT, gravity.Exponent, gravity.Mass);
var kepler = KeplerCoordinates.fromTrueAnomaly(ao.Eccentricity, ao.SemiMajorAxis, ao.Inclination, ao.ArgumentOfPeriapsis, ao.LongitudeOfAscendingNode, ao.TrueAnomaly);
var cartesian = PacificEngine.OW_CommonResources.Geometry.Orbits.OrbitHelper.toCartesian(crGravity, 0f, kepler);
if (cartesian == null)
{
cartesian = Tuple.Create(Vector3.zero, Vector3.zero);
}
Logger.Log($"Position : {cartesian.Item1} Velocity : {cartesian.Item2}");
return cartesian;
}
public static KeplerCoordinates KeplerCoordinatesFromOrbitModule(OrbitModule orbit)
{
return KeplerCoordinates.fromTrueAnomaly(orbit.Eccentricity, orbit.SemiMajorAxis, orbit.Inclination, orbit.ArgumentOfPeriapsis, orbit.LongitudeOfAscendingNode, orbit.TrueAnomaly);
}
public class Gravity
{
public float Exponent { get; }
public float Mass { get; }
public Gravity(float exponent, float mass)
{
Exponent = exponent;
Mass = mass;
}
public Gravity(GravityVolume gv)
{
Exponent = gv.GetFalloffExponent();
Mass = gv.GetStandardGravitationalParameter() / GravityVolume.GRAVITATIONAL_CONSTANT;
}
}
}
}

61
NewHorizons/OrbitalPhysics/ParameterizedOrbitLine.cs
View File

@ -1,61 +0,0 @@
using OWML.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using NewHorizons.Utility;
using Logger = NewHorizons.Utility.Logger;
namespace NewHorizons.OrbitalPhysics
{
public class ParameterizedOrbitLine : EllipticOrbitLine
{
public ParameterizedAstroObject astroObject;
public override void Start()
{
base.Start();
astroObject = _astroObject as ParameterizedAstroObject;
var periapsis = OrbitalHelper.GetPositionFromEccentricAnomaly(astroObject.Eccentricity, astroObject.SemiMajorAxis, astroObject.Inclination, astroObject.ArgumentOfPeriapsis, astroObject.LongitudeOfAscendingNode, 0f);
var semiMinorDecending = OrbitalHelper.GetPositionFromEccentricAnomaly(astroObject.Eccentricity, astroObject.SemiMajorAxis, astroObject.Inclination, astroObject.ArgumentOfPeriapsis, astroObject.LongitudeOfAscendingNode, 90f);
var a = astroObject.SemiMajorAxis;
var b = a * Mathf.Sqrt(1 - astroObject.Eccentricity * astroObject.Eccentricity);
_semiMajorAxis = periapsis.normalized * a;
_semiMinorAxis = semiMinorDecending.normalized * b;
_upAxisDir = Vector3.Cross(_semiMajorAxis, _semiMinorAxis).normalized;
_fociDistance = Mathf.Sqrt(a * a - b * b);
}
// Literally the stock EllipticOrbitLine but for now I don't want to use the patches from CommonResources
public override void Update()
{
AstroObject primaryAO = _astroObject?.GetPrimaryBody();
if (primaryAO == null)
{
base.enabled = false;
return;
}
Vector3 vector = primaryAO.transform.position + this._semiMajorAxis.normalized * this._fociDistance;
float num = this.CalcProjectedAngleToCenter(vector, this._semiMajorAxis, this._semiMinorAxis, this._astroObject.transform.position);
for (int i = 0; i < this._numVerts; i++)
{
float f = (float)i / (float)(this._numVerts - 1) * 3.1415927f * 2f - (num + 3.1415927f);
this._verts[i] = this._semiMajorAxis * Mathf.Cos(f) + this._semiMinorAxis * Mathf.Sin(f);
}
this._lineRenderer.SetPositions(this._verts);
base.transform.position = vector;
base.transform.rotation = Quaternion.LookRotation(this._semiMinorAxis, this._upAxisDir);
float num2 = this.DistanceToEllipticalOrbitLine(vector, this._semiMajorAxis, this._semiMinorAxis, this._upAxisDir, Locator.GetActiveCamera().transform.position);
float widthMultiplier = Mathf.Min(num2 * (this._lineWidth / 1000f), this._maxLineWidth);
float num3 = this._fade ? (1f - Mathf.Clamp01((num2 - this._fadeStartDist) / (this._fadeEndDist - this._fadeStartDist))) : 1f;
this._lineRenderer.widthMultiplier = widthMultiplier;
this._lineRenderer.startColor = new Color(this._color.r, this._color.g, this._color.b, num3 * num3);
}
}
}

8
README.md
View File

@ -24,16 +24,16 @@ Planets are created using a JSON file format structure, and placed in the `plane
<!-- /TOC -->
## Roadmap
- Stars (Done)
- Binary orbits (Done)
- Comets (Done)
- Procedurally terrain generation (started)
- Asteroid belts (started, needs more customization)
- "Quantum" orbits
- Better terrain and water LOD
- Support satellites (using custom models in the assets folder or in-game ones)
- Surface scatter (rocks, trees, etc, using custom models or in-game ones)
- Stars
- Binary orbits
- Surface scatter: rocks, trees, etc, using in-game models (done) or custom ones
- Load planet meshes from asset bundle
- Comets
- Edit existing planet orbits
- Black hole / white hole pairs
- Separate solar system scenes accessible via wormhole