973 lines
29 KiB
C#
973 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.Events;
|
|
|
|
namespace UnityEngine.AzureSky
|
|
{
|
|
[ExecuteInEditMode]
|
|
[AddComponentMenu("Azure[Sky]/Azure Time Controller")]
|
|
public class AzureTimeController : MonoBehaviour
|
|
{
|
|
[Tooltip("The Transform used to simulate the sun position in the sky.")]
|
|
[SerializeField]
|
|
private Transform m_sunTransform;
|
|
|
|
[Tooltip("The Transform used to simulate the moon position in the sky.")]
|
|
[SerializeField]
|
|
private Transform m_moonTransform;
|
|
|
|
[Tooltip("The directional light used to apply the sun and moon lighting to the scene.")]
|
|
[SerializeField]
|
|
private Transform m_directionalLight;
|
|
|
|
[Tooltip("If selected, the prefab will follow this transform in the scene, usually the main camera is used here.")]
|
|
[SerializeField]
|
|
private Transform m_followTarget;
|
|
|
|
[Tooltip("The method used to compute the celestial coordinate of the sun and moon in the sky. Any other celestial body that you may use, will always get the realistic astronomical coordinate.")]
|
|
[SerializeField]
|
|
private AzureTimeSystem m_timeSystem;
|
|
|
|
[Tooltip("The direction in which the time of day will flow.")]
|
|
[SerializeField]
|
|
private AzureTimeDirection m_timeDirection;
|
|
|
|
[Tooltip("The loop in which the calendar will perform the day changes.")]
|
|
[SerializeField]
|
|
private AzureDateLoop m_dateLoop;
|
|
|
|
[Tooltip("The current 'time position' in the day-night cycle. Note that this may not represent the correct time of day.")]
|
|
[SerializeField]
|
|
private float m_timeline = 6f;
|
|
|
|
[Tooltip("The hour converted from the time of day.")]
|
|
[SerializeField]
|
|
private int m_hour = 6;
|
|
|
|
[Tooltip("The minute converted from the time of day.")]
|
|
[SerializeField]
|
|
private int m_minute;
|
|
|
|
[Tooltip("The day used by the calendar and date system.")]
|
|
[SerializeField]
|
|
private int m_day = 1;
|
|
|
|
[Tooltip("The month used by the calendar and date system.")]
|
|
[SerializeField]
|
|
private int m_month = 1;
|
|
|
|
[Tooltip("The year used by the calendar and date system.")]
|
|
[SerializeField]
|
|
private int m_year = 2024;
|
|
|
|
[Tooltip("The current selected calendar day.")]
|
|
[SerializeField]
|
|
private int m_selectedCalendarDay = 1;
|
|
|
|
[Tooltip("The north-south angle of a position on the Earth's surface.")]
|
|
[SerializeField]
|
|
private float m_latitude;
|
|
|
|
[Tooltip("The east-west angle of a position on the Earth's surface.")]
|
|
[SerializeField]
|
|
private float m_longitude;
|
|
|
|
[Tooltip("Universal Time Coordinated.")]
|
|
[SerializeField]
|
|
private float m_utc;
|
|
|
|
[Tooltip("Duration of the day-night cycle in minutes.")]
|
|
[SerializeField]
|
|
private float m_dayLength = 24f;
|
|
|
|
[Tooltip("The minimum directional light altitude (0° - 90°). You can use this to avoid the shadows to get stretched when the sun is close to the horizon at sunset.")]
|
|
[SerializeField]
|
|
private float m_minLightAltitude;
|
|
|
|
[Tooltip("Will the 'time of day' be evaluated based on the timeline or based on the day-night length curve?")]
|
|
[SerializeField]
|
|
private bool m_isTimeEvaluatedByCurve;
|
|
|
|
[Tooltip("Duration of the day-night cycle in minutes.")]
|
|
[SerializeField]
|
|
private AnimationCurve m_dayLengthCurve = AnimationCurve.Linear(0f, 0f, 24f, 24f);
|
|
|
|
[Tooltip("List storing all celestial bodies currently in use by the system.")]
|
|
[SerializeField]
|
|
private List<AzureCelestialBody> m_celestialBodiesList = new List<AzureCelestialBody>();
|
|
|
|
[Tooltip("Event triggered when the minute changes.")]
|
|
[SerializeField]
|
|
private UnityEvent m_onMinuteChange = new UnityEvent();
|
|
|
|
[Tooltip("Event triggered when the hour changes.")]
|
|
[SerializeField]
|
|
private UnityEvent m_onHourChange = new UnityEvent();
|
|
|
|
[Tooltip("Event triggered when the day changes to the next day at midnight.")]
|
|
[SerializeField]
|
|
private UnityEvent m_onDayChange = new UnityEvent();
|
|
|
|
[Tooltip("The correct time of day converted from the timeline.")]
|
|
private float m_timeOfDay = 6f;
|
|
|
|
[Tooltip("The time progression step used to change the time of day.")]
|
|
private float m_timeProgressionStep;
|
|
|
|
[Tooltip("The sun elevation in the sky.")]
|
|
private float m_sunElevation;
|
|
|
|
[Tooltip("The moon elevation in the sky.")]
|
|
private float m_moonElevation;
|
|
|
|
[Tooltip("The distance between Earth and the Sun.")]
|
|
private float m_sunDistance;
|
|
|
|
[Tooltip("The local direction of the Sun.")]
|
|
private Vector3 m_sunLocalDirection;
|
|
|
|
[Tooltip("The local direction of the Moon.")]
|
|
private Vector3 m_moonLocalDirection;
|
|
|
|
[Tooltip("The local direction of the Directional Light.")]
|
|
private Vector3 m_lightLocalDirection;
|
|
|
|
[Tooltip("The distance between Earth and the Moon.")]
|
|
private float m_moonDistance;
|
|
|
|
[Tooltip("The time interval the system should use for checking the custom event list.")]
|
|
[SerializeField]
|
|
private AzureEventScanMode m_customEventScanMode;
|
|
|
|
[Tooltip("The list of custom events.")]
|
|
[SerializeField]
|
|
private List<AzureCustomEvent> m_customEventList = new List<AzureCustomEvent>();
|
|
|
|
private DateTime m_dateTime;
|
|
|
|
private int m_daysInMonth = 30;
|
|
|
|
private int m_previousDaysInMonth = 30;
|
|
|
|
private int m_previousMonth = 1;
|
|
|
|
private int m_dayOfWeek;
|
|
|
|
[Tooltip("String array that stores the name of each week day.")]
|
|
private readonly string[] m_weekNameList = new string[7] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
|
|
|
|
[Tooltip("String array that stores the name of each month.")]
|
|
private readonly string[] m_monthNameList = new string[12]
|
|
{
|
|
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October",
|
|
"November", "December"
|
|
};
|
|
|
|
[Tooltip("Array with 42 numeric strings used to fill a calendar.")]
|
|
[SerializeField]
|
|
private string[] m_dayNumberList = new string[42]
|
|
{
|
|
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
|
|
"10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
|
|
"30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
|
|
"40", "41"
|
|
};
|
|
|
|
private int m_timelineTransitionTargetHour;
|
|
|
|
private int m_timelineTransitionTargetMinute;
|
|
|
|
private float m_timelineTransitionTargetSpeed = 1f;
|
|
|
|
private int m_timelineTransitionTargetMonth;
|
|
|
|
private int m_timelineTransitionTargetDay;
|
|
|
|
private int m_timelineTransitionTargetYear;
|
|
|
|
private AzureTimeDirection m_timelineTransitionDirection;
|
|
|
|
private bool m_isTimelineTransitionInProgress;
|
|
|
|
private int m_previousHour = 6;
|
|
|
|
private int m_previousMinute;
|
|
|
|
public AzureTimeSystem TimeSystem
|
|
{
|
|
get
|
|
{
|
|
return m_timeSystem;
|
|
}
|
|
set
|
|
{
|
|
m_timeSystem = value;
|
|
}
|
|
}
|
|
|
|
private void Reset()
|
|
{
|
|
UpdateCalendar();
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
m_timeProgressionStep = GetTimeProgressionStep();
|
|
m_previousMinute = m_minute;
|
|
m_previousHour = m_hour;
|
|
UpdateCalendar();
|
|
EvaluateTimeOfDay();
|
|
ComputeCelestialCoordinates();
|
|
EvaluateSunMoonElevation();
|
|
SetDirectionalLightRotation();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!Application.isPlaying)
|
|
{
|
|
return;
|
|
}
|
|
if ((bool)m_followTarget)
|
|
{
|
|
base.transform.position = m_followTarget.position;
|
|
}
|
|
if (m_timeDirection == AzureTimeDirection.Forward)
|
|
{
|
|
m_timeline += m_timeProgressionStep * Time.deltaTime;
|
|
if (m_isTimelineTransitionInProgress)
|
|
{
|
|
ApplyTimelineTransition();
|
|
}
|
|
if (m_timeline > 24f)
|
|
{
|
|
IncreaseDay();
|
|
m_timeline = 0f;
|
|
m_onDayChange?.Invoke();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_timeline -= m_timeProgressionStep * Time.deltaTime;
|
|
if (m_isTimelineTransitionInProgress)
|
|
{
|
|
ApplyTimelineTransition();
|
|
}
|
|
if (m_timeline < 0f)
|
|
{
|
|
DecreaseDay();
|
|
m_timeline = 24f;
|
|
m_onDayChange?.Invoke();
|
|
}
|
|
}
|
|
EvaluateTimeOfDay();
|
|
EvaluateSunMoonElevation();
|
|
if (m_previousMinute != m_minute)
|
|
{
|
|
m_previousMinute = m_minute;
|
|
m_onMinuteChange?.Invoke();
|
|
if (m_customEventScanMode == AzureEventScanMode.ByMinute)
|
|
{
|
|
ScanCustomEventList();
|
|
}
|
|
}
|
|
if (m_previousHour != m_hour)
|
|
{
|
|
m_previousHour = m_hour;
|
|
m_onHourChange?.Invoke();
|
|
if (m_customEventScanMode == AzureEventScanMode.ByHour)
|
|
{
|
|
ScanCustomEventList();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
ComputeCelestialCoordinates();
|
|
SetDirectionalLightRotation();
|
|
}
|
|
|
|
private float GetTimeProgressionStep()
|
|
{
|
|
if (m_dayLength > 0f)
|
|
{
|
|
return 0.4f / m_dayLength;
|
|
}
|
|
return 0f;
|
|
}
|
|
|
|
public void StartTimelineTransition(int hour, int minute, float speedMultiplier, AzureTimeDirection timeDir = AzureTimeDirection.Forward, int day = int.MaxValue, int month = int.MaxValue, int year = int.MaxValue)
|
|
{
|
|
m_timelineTransitionTargetHour = Mathf.Min(hour, 23);
|
|
m_timelineTransitionTargetMinute = Mathf.Min(minute, 59);
|
|
m_timelineTransitionTargetSpeed = Mathf.Max(1f, m_timeProgressionStep * speedMultiplier);
|
|
m_timelineTransitionTargetDay = day;
|
|
m_timelineTransitionTargetMonth = month;
|
|
m_timelineTransitionTargetYear = year;
|
|
m_timelineTransitionDirection = timeDir;
|
|
if (timeDir == AzureTimeDirection.Backward)
|
|
{
|
|
if (day == int.MaxValue)
|
|
{
|
|
day = int.MinValue;
|
|
}
|
|
if (month == int.MaxValue)
|
|
{
|
|
month = int.MinValue;
|
|
}
|
|
if (year == int.MaxValue)
|
|
{
|
|
year = int.MinValue;
|
|
}
|
|
m_timelineTransitionTargetDay = day;
|
|
m_timelineTransitionTargetMonth = month;
|
|
m_timelineTransitionTargetYear = year;
|
|
}
|
|
m_isTimelineTransitionInProgress = true;
|
|
}
|
|
|
|
public void CancelTimelineTransition()
|
|
{
|
|
m_isTimelineTransitionInProgress = false;
|
|
}
|
|
|
|
private void ApplyTimelineTransition()
|
|
{
|
|
switch (m_timelineTransitionDirection)
|
|
{
|
|
case AzureTimeDirection.Forward:
|
|
ApplyTimelineTransitionForward();
|
|
break;
|
|
case AzureTimeDirection.Backward:
|
|
ApplyTimelineTransitionBackward();
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ApplyTimelineTransitionForward()
|
|
{
|
|
m_timeline += m_timelineTransitionTargetSpeed * Time.deltaTime;
|
|
if (m_hour < m_timelineTransitionTargetHour || m_minute < m_timelineTransitionTargetMinute)
|
|
{
|
|
return;
|
|
}
|
|
if (m_timelineTransitionTargetDay == int.MaxValue && m_timelineTransitionTargetMonth == int.MaxValue && m_timelineTransitionTargetYear == int.MaxValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else
|
|
{
|
|
if (m_day < m_timelineTransitionTargetDay)
|
|
{
|
|
return;
|
|
}
|
|
if (m_timelineTransitionTargetMonth == int.MaxValue && m_timelineTransitionTargetYear == int.MaxValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else if (m_month >= m_timelineTransitionTargetMonth)
|
|
{
|
|
if (m_timelineTransitionTargetYear == int.MaxValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else if (m_year >= m_timelineTransitionTargetYear)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyTimelineTransitionBackward()
|
|
{
|
|
m_timeline -= m_timelineTransitionTargetSpeed * Time.deltaTime;
|
|
if (m_hour > m_timelineTransitionTargetHour || m_minute > m_timelineTransitionTargetMinute)
|
|
{
|
|
return;
|
|
}
|
|
if (m_timelineTransitionTargetDay == int.MinValue && m_timelineTransitionTargetMonth == int.MinValue && m_timelineTransitionTargetYear == int.MinValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else
|
|
{
|
|
if (m_day > m_timelineTransitionTargetDay)
|
|
{
|
|
return;
|
|
}
|
|
if (m_timelineTransitionTargetMonth == int.MinValue && m_timelineTransitionTargetYear == int.MinValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else if (m_month <= m_timelineTransitionTargetMonth)
|
|
{
|
|
if (m_timelineTransitionTargetYear == int.MinValue)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
else if (m_year <= m_timelineTransitionTargetYear)
|
|
{
|
|
CancelTimelineTransition();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EvaluateTimeOfDay()
|
|
{
|
|
m_timeOfDay = (m_isTimeEvaluatedByCurve ? m_dayLengthCurve.Evaluate(m_timeline) : m_timeline);
|
|
m_hour = (int)Mathf.Floor(m_timeOfDay);
|
|
m_minute = (int)Mathf.Floor(m_timeOfDay * 60f % 60f);
|
|
}
|
|
|
|
private void EvaluateSunMoonElevation()
|
|
{
|
|
m_sunLocalDirection = m_sunTransform.forward;
|
|
m_moonLocalDirection = m_moonTransform.forward;
|
|
m_sunElevation = Vector3.Dot(-m_sunLocalDirection, Vector3.up);
|
|
m_moonElevation = Vector3.Dot(-m_moonLocalDirection, Vector3.up);
|
|
}
|
|
|
|
private void SetDirectionalLightRotation()
|
|
{
|
|
m_directionalLight.localRotation = Quaternion.LookRotation((m_sunElevation >= 0f) ? m_sunLocalDirection : m_moonLocalDirection);
|
|
if (m_minLightAltitude > 0f && m_minLightAltitude < 90f)
|
|
{
|
|
m_lightLocalDirection = m_directionalLight.localEulerAngles;
|
|
if (m_lightLocalDirection.x <= m_minLightAltitude)
|
|
{
|
|
m_lightLocalDirection.x = m_minLightAltitude;
|
|
}
|
|
m_directionalLight.localEulerAngles = m_lightLocalDirection;
|
|
}
|
|
}
|
|
|
|
private void ScanCustomEventList()
|
|
{
|
|
if (m_customEventList.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < m_customEventList.Count; i++)
|
|
{
|
|
if (m_customEventList[i].unityEvent == null || (m_customEventList[i].year != m_year && m_customEventList[i].year != -1) || (m_customEventList[i].month != m_month && m_customEventList[i].month != -1) || (m_customEventList[i].day != m_day && m_customEventList[i].day != -1))
|
|
{
|
|
continue;
|
|
}
|
|
if (m_hour != m_customEventList[i].executedHour)
|
|
{
|
|
m_customEventList[i].isAlreadyExecutedOnThisHour = false;
|
|
}
|
|
if (m_customEventList[i].hour == m_hour || m_customEventList[i].hour == -1)
|
|
{
|
|
if (m_customEventList[i].minute == -1)
|
|
{
|
|
m_customEventList[i].unityEvent.Invoke();
|
|
}
|
|
else if (!m_customEventList[i].isAlreadyExecutedOnThisHour && m_minute > m_customEventList[i].minute)
|
|
{
|
|
m_customEventList[i].executedHour = m_hour;
|
|
m_customEventList[i].isAlreadyExecutedOnThisHour = true;
|
|
m_customEventList[i].unityEvent.Invoke();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ComputeCelestialCoordinates()
|
|
{
|
|
switch (m_timeSystem)
|
|
{
|
|
case AzureTimeSystem.Simple:
|
|
m_sunTransform.localRotation = GetSunSimpleRotation();
|
|
m_moonTransform.localRotation = m_sunTransform.localRotation * Quaternion.Euler(0f, -180f, 0f);
|
|
Shader.SetGlobalMatrix(AzureShaderUniforms.StarfieldMatrix, m_sunTransform.worldToLocalMatrix);
|
|
break;
|
|
case AzureTimeSystem.Realistic:
|
|
{
|
|
float num = m_timeOfDay - m_utc;
|
|
float num2 = MathF.PI / 180f;
|
|
float num3 = 57.29578f;
|
|
float f = m_latitude * num2;
|
|
float num4 = 367 * m_year - 7 * (m_year + (m_month + 9) / 12) / 4 + 275 * m_month / 9 + m_day - 730530;
|
|
num4 += num / 24f;
|
|
float num5 = 23.4393f - 3.563E-07f * num4;
|
|
num5 *= num2;
|
|
float num6 = 0f;
|
|
float num7 = 0f;
|
|
float num8 = 282.9404f + 4.70935E-05f * num4;
|
|
float num9 = 1f;
|
|
float num10 = 0.016709f - 1.151E-09f * num4;
|
|
float num11 = 356.047f + 0.98560023f * num4;
|
|
num11 *= num2;
|
|
float f2 = num11 + num10 * Mathf.Sin(num11) * (1f + num10 * Mathf.Cos(num11));
|
|
float num12 = Mathf.Cos(f2) - num10;
|
|
float num13 = Mathf.Sqrt(1f - num10 * num10) * Mathf.Sin(f2);
|
|
float num14 = Mathf.Atan2(num13, num12) * num3;
|
|
float num15 = Mathf.Sqrt(num12 * num12 + num13 * num13);
|
|
float f3 = (num14 + num8) * num2;
|
|
float num16 = num15 * Mathf.Cos(f3);
|
|
float num17 = num15 * Mathf.Sin(f3);
|
|
float num18 = num16;
|
|
float num19 = num17 * Mathf.Cos(num5);
|
|
float y = num17 * Mathf.Sin(num5);
|
|
float num20 = Mathf.Atan2(num19, num18);
|
|
float f4 = Mathf.Atan2(y, Mathf.Sqrt(num18 * num18 + num19 * num19));
|
|
float num21 = (num14 + num8 + 180f + num * 15f + m_longitude) * num2;
|
|
float f5 = num21 - num20;
|
|
float num22 = Mathf.Cos(f5) * Mathf.Cos(f4);
|
|
float num23 = Mathf.Sin(f5) * Mathf.Cos(f4);
|
|
float num24 = Mathf.Sin(f4);
|
|
float x = num22 * Mathf.Sin(f) - num24 * Mathf.Cos(f);
|
|
float y2 = num23;
|
|
float f6 = num22 * Mathf.Cos(f) + num24 * Mathf.Sin(f);
|
|
float num25 = Mathf.Atan2(y2, x);
|
|
float num26 = Mathf.Asin(f6);
|
|
Vector3 euler = default(Vector3);
|
|
euler.x = num26 * num3;
|
|
euler.y = num25 * num3;
|
|
euler.z = 0f;
|
|
m_sunTransform.localRotation = Quaternion.Euler(euler);
|
|
m_sunDistance = num15 * 150000000f;
|
|
Shader.SetGlobalMatrix(AzureShaderUniforms.StarfieldMatrix, Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(90f - m_latitude, 0f, 0f) * Quaternion.Euler(0f, m_longitude, 0f) * Quaternion.Euler(0f, num21 * num3, 0f), Vector3.one).inverse);
|
|
num6 = 125.1228f - 0.05295381f * num4;
|
|
num7 = 5.1454f;
|
|
num8 = 318.0634f + 0.16435732f * num4;
|
|
num9 = 60.2666f;
|
|
num10 = 0.0549f;
|
|
num11 = 115.3654f + 13.064993f * num4;
|
|
num11 *= num2;
|
|
f2 = num11 + num10 * Mathf.Sin(num11) * (1f + num10 * Mathf.Cos(num11));
|
|
num12 = num9 * (Mathf.Cos(f2) - num10);
|
|
num13 = num9 * (Mathf.Sqrt(1f - num10 * num10) * Mathf.Sin(f2));
|
|
float num27 = Mathf.Atan2(num13, num12) * num3;
|
|
num15 = Mathf.Sqrt(num12 * num12 + num13 * num13);
|
|
f3 = (num27 + num8) * num2;
|
|
float num28 = Mathf.Sin(f3);
|
|
float num29 = Mathf.Cos(f3);
|
|
num6 *= num2;
|
|
num7 *= num2;
|
|
float num30 = num15 * (Mathf.Cos(num6) * num29 - Mathf.Sin(num6) * num28 * Mathf.Cos(num7));
|
|
float num31 = num15 * (Mathf.Sin(num6) * num29 + Mathf.Cos(num6) * num28 * Mathf.Cos(num7));
|
|
float num32 = num15 * (num28 * Mathf.Sin(num7));
|
|
num18 = num30;
|
|
num19 = num31 * Mathf.Cos(num5) - num32 * Mathf.Sin(num5);
|
|
float y3 = num31 * Mathf.Sin(num5) + num32 * Mathf.Cos(num5);
|
|
num20 = Mathf.Atan2(num19, num18);
|
|
f4 = Mathf.Atan2(y3, Mathf.Sqrt(num18 * num18 + num19 * num19));
|
|
float f7 = num21 - num20;
|
|
num22 = Mathf.Cos(f7) * Mathf.Cos(f4);
|
|
num23 = Mathf.Sin(f7) * Mathf.Cos(f4);
|
|
num24 = Mathf.Sin(f4);
|
|
x = num22 * Mathf.Sin(f) - num24 * Mathf.Cos(f);
|
|
y2 = num23;
|
|
float f8 = num22 * Mathf.Cos(f) + num24 * Mathf.Sin(f);
|
|
num25 = Mathf.Atan2(y2, x);
|
|
num26 = Mathf.Asin(f8);
|
|
euler.x = num26 * num3;
|
|
euler.y = num25 * num3;
|
|
euler.z = 0f;
|
|
m_moonTransform.localRotation = Quaternion.Euler(euler);
|
|
m_moonDistance = num15 * 6371f;
|
|
if (m_celestialBodiesList.Count <= 0)
|
|
{
|
|
break;
|
|
}
|
|
for (int i = 0; i < m_celestialBodiesList.Count; i++)
|
|
{
|
|
AzureCelestialBody azureCelestialBody = m_celestialBodiesList[i];
|
|
if ((bool)azureCelestialBody.transform)
|
|
{
|
|
switch (azureCelestialBody.type)
|
|
{
|
|
case AzureCelestialBody.Type.Mercury:
|
|
num6 = 48.3313f + 3.24587E-05f * num4;
|
|
num7 = 7.0047f + 5E-08f * num4;
|
|
num8 = 29.1241f + 1.01444E-05f * num4;
|
|
num9 = 0.387098f;
|
|
num10 = 0.205635f + 5.59E-10f * num4;
|
|
num11 = 168.6562f + 4.0923343f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Venus:
|
|
num6 = 76.6799f + 2.4659E-05f * num4;
|
|
num7 = 3.3946f + 2.75E-08f * num4;
|
|
num8 = 54.891f + 1.38374E-05f * num4;
|
|
num9 = 0.72333f;
|
|
num10 = 0.006773f - 1.302E-09f * num4;
|
|
num11 = 48.0052f + 1.6021302f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Mars:
|
|
num6 = 49.5574f + 2.11081E-05f * num4;
|
|
num7 = 1.8497f - 1.78E-08f * num4;
|
|
num8 = 286.5016f + 2.92961E-05f * num4;
|
|
num9 = 1.523688f;
|
|
num10 = 0.093405f + 2.516E-09f * num4;
|
|
num11 = 18.6021f + 0.5240208f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Jupiter:
|
|
num6 = 100.4542f + 2.76854E-05f * num4;
|
|
num7 = 1.303f - 1.557E-07f * num4;
|
|
num8 = 273.8777f + 1.64505E-05f * num4;
|
|
num9 = 5.20256f;
|
|
num10 = 0.048498f + 4.469E-09f * num4;
|
|
num11 = 19.895f + 0.0830853f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Saturn:
|
|
num6 = 113.6634f + 2.3898E-05f * num4;
|
|
num7 = 2.4886f - 1.081E-07f * num4;
|
|
num8 = 339.3939f + 2.97661E-05f * num4;
|
|
num9 = 9.55475f;
|
|
num10 = 0.055546f - 9.499E-09f * num4;
|
|
num11 = 316.967f + 0.03344423f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Uranus:
|
|
num6 = 74.0005f + 1.3978E-05f * num4;
|
|
num7 = 0.7733f + 1.9E-08f * num4;
|
|
num8 = 96.6612f + 3.0565E-05f * num4;
|
|
num9 = 19.18171f - 1.55E-08f * num4;
|
|
num10 = 0.047318f + 7.45E-09f * num4;
|
|
num11 = 142.5905f + 0.011725806f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Neptune:
|
|
num6 = 131.7806f + 3.0173E-05f * num4;
|
|
num7 = 1.77f - 2.55E-07f * num4;
|
|
num8 = 272.8461f - 6.027E-06f * num4;
|
|
num9 = 30.05826f + 3.313E-08f * num4;
|
|
num10 = 0.008606f + 2.15E-09f * num4;
|
|
num11 = 260.2471f + 0.005995147f * num4;
|
|
break;
|
|
case AzureCelestialBody.Type.Pluto:
|
|
{
|
|
float num33 = 50.03f + 0.033459652f * num4;
|
|
float num34 = 238.95f + 0.003968789f * num4;
|
|
num33 *= num2;
|
|
num34 *= num2;
|
|
float num35 = 238.9508f + 0.00400703f * num4 - 19.799f * Mathf.Sin(num34) + 19.848f * Mathf.Cos(num34) + 0.897f * Mathf.Sin(2f * num34) - 4.956f * Mathf.Cos(2f * num34) + 0.61f * Mathf.Sin(3f * num34) + 1.211f * Mathf.Cos(3f * num34) - 0.341f * Mathf.Sin(4f * num34) - 0.19f * Mathf.Cos(4f * num34) + 0.128f * Mathf.Sin(5f * num34) - 0.034f * Mathf.Cos(5f * num34) - 0.038f * Mathf.Sin(6f * num34) + 0.031f * Mathf.Cos(6f * num34) + 0.02f * Mathf.Sin(num33 - num34) - 0.01f * Mathf.Cos(num33 - num34);
|
|
float num36 = -3.9082f - 5.453f * Mathf.Sin(num34) - 14.975f * Mathf.Cos(num34) + 3.527f * Mathf.Sin(2f * num34) + 1.673f * Mathf.Cos(2f * num34) - 1.051f * Mathf.Sin(3f * num34) + 0.328f * Mathf.Cos(3f * num34) + 0.179f * Mathf.Sin(4f * num34) - 0.292f * Mathf.Cos(4f * num34) + 0.019f * Mathf.Sin(5f * num34) + 0.1f * Mathf.Cos(5f * num34) - 0.031f * Mathf.Sin(6f * num34) - 0.026f * Mathf.Cos(6f * num34) + 0.011f * Mathf.Cos(num33 - num34);
|
|
float num37 = 40.72f + 6.68f * Mathf.Sin(num34) + 6.9f * Mathf.Cos(num34) - 1.18f * Mathf.Sin(2f * num34) - 0.03f * Mathf.Cos(2f * num34) + 0.15f * Mathf.Sin(3f * num34) - 0.14f * Mathf.Cos(3f * num34);
|
|
num35 *= num2;
|
|
num36 *= num2;
|
|
float num38 = Mathf.Cos(num36);
|
|
num30 = num37 * Mathf.Cos(num35) * num38;
|
|
num31 = num37 * Mathf.Sin(num35) * num38;
|
|
num32 = num37 * Mathf.Sin(num36);
|
|
float num39 = num30 + num16;
|
|
float num40 = num31 + num17;
|
|
float num41 = num32;
|
|
num18 = num39;
|
|
num19 = num40 * Mathf.Cos(num5) - num41 * Mathf.Sin(num5);
|
|
float y4 = num40 * Mathf.Sin(num5) + num41 * Mathf.Cos(num5);
|
|
num20 = Mathf.Atan2(num19, num18);
|
|
f4 = Mathf.Atan2(y4, Mathf.Sqrt(num18 * num18 + num19 * num19));
|
|
float f9 = num21 - num20;
|
|
num22 = Mathf.Cos(f9) * Mathf.Cos(f4);
|
|
num23 = Mathf.Sin(f9) * Mathf.Cos(f4);
|
|
num24 = Mathf.Sin(f4);
|
|
x = num22 * Mathf.Sin(f) - num24 * Mathf.Cos(f);
|
|
y2 = num23;
|
|
float f10 = num22 * Mathf.Cos(f) + num24 * Mathf.Sin(f);
|
|
num25 = Mathf.Atan2(y2, x);
|
|
num26 = Mathf.Asin(f10);
|
|
euler.x = num26 * num3;
|
|
euler.y = num25 * num3;
|
|
euler.z = 0f;
|
|
azureCelestialBody.distance = num37 * 150000000f;
|
|
azureCelestialBody.transform.localRotation = Quaternion.Euler(euler);
|
|
continue;
|
|
}
|
|
}
|
|
num11 *= num2;
|
|
f2 = num11 + num10 * Mathf.Sin(num11) * (1f + num10 * Mathf.Cos(num11));
|
|
num12 = num9 * (Mathf.Cos(f2) - num10);
|
|
num13 = num9 * (Mathf.Sqrt(1f - num10 * num10) * Mathf.Sin(f2));
|
|
float num42 = Mathf.Atan2(num13, num12) * num3;
|
|
num15 = Mathf.Sqrt(num12 * num12 + num13 * num13);
|
|
f3 = (num42 + num8) * num2;
|
|
num29 = Mathf.Cos(f3);
|
|
num28 = Mathf.Sin(f3);
|
|
num6 *= num2;
|
|
num7 *= num2;
|
|
num30 = num15 * (Mathf.Cos(num6) * num29 - Mathf.Sin(num6) * num28 * Mathf.Cos(num7));
|
|
num31 = num15 * (Mathf.Sin(num6) * num29 + Mathf.Cos(num6) * num28 * Mathf.Cos(num7));
|
|
num32 = num15 * (num28 * Mathf.Sin(num7));
|
|
float f11 = Mathf.Atan2(num31, num30);
|
|
float f12 = Mathf.Atan2(num32, Mathf.Sqrt(num30 * num30 + num31 * num31));
|
|
float num43 = Mathf.Cos(f12);
|
|
num30 = num15 * Mathf.Cos(f11) * num43;
|
|
num31 = num15 * Mathf.Sin(f11) * num43;
|
|
num32 = num15 * Mathf.Sin(f12);
|
|
float num44 = num30 + num16;
|
|
float num45 = num31 + num17;
|
|
float num46 = num32;
|
|
num18 = num44;
|
|
num19 = num45 * Mathf.Cos(num5) - num46 * Mathf.Sin(num5);
|
|
float y5 = num45 * Mathf.Sin(num5) + num46 * Mathf.Cos(num5);
|
|
num20 = Mathf.Atan2(num19, num18);
|
|
f4 = Mathf.Atan2(y5, Mathf.Sqrt(num18 * num18 + num19 * num19));
|
|
float f13 = num21 - num20;
|
|
num22 = Mathf.Cos(f13) * Mathf.Cos(f4);
|
|
num23 = Mathf.Sin(f13) * Mathf.Cos(f4);
|
|
num24 = Mathf.Sin(f4);
|
|
x = num22 * Mathf.Sin(f) - num24 * Mathf.Cos(f);
|
|
y2 = num23;
|
|
float f14 = num22 * Mathf.Cos(f) + num24 * Mathf.Sin(f);
|
|
num25 = Mathf.Atan2(y2, x);
|
|
num26 = Mathf.Asin(f14);
|
|
euler.x = num26 * num3;
|
|
euler.y = num25 * num3;
|
|
euler.z = 0f;
|
|
azureCelestialBody.distance = num15 * 150000000f;
|
|
azureCelestialBody.transform.localRotation = Quaternion.Euler(euler);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int GetDayOfWeek()
|
|
{
|
|
m_dateTime = new DateTime(m_year, m_month, m_day);
|
|
return (int)m_dateTime.DayOfWeek;
|
|
}
|
|
|
|
public int GetDayOfWeek(int year, int month, int day)
|
|
{
|
|
m_dateTime = new DateTime(year, month, day);
|
|
return (int)m_dateTime.DayOfWeek;
|
|
}
|
|
|
|
public string GetDayOfWeekString()
|
|
{
|
|
m_dateTime = new DateTime(m_year, m_month, m_day);
|
|
return m_weekNameList[(int)m_dateTime.DayOfWeek];
|
|
}
|
|
|
|
public string GetDayOfWeekString(int year, int month, int day)
|
|
{
|
|
m_dateTime = new DateTime(year, month, day);
|
|
return m_weekNameList[(int)m_dateTime.DayOfWeek];
|
|
}
|
|
|
|
public void UpdateCalendar()
|
|
{
|
|
m_daysInMonth = DateTime.DaysInMonth(m_year, m_month);
|
|
m_day = Mathf.Clamp(m_day, 1, m_daysInMonth);
|
|
m_month = Mathf.Clamp(m_month, 1, 12);
|
|
m_year = Mathf.Clamp(m_year, 0, 9999);
|
|
m_dateTime = new DateTime(m_year, m_month, 1);
|
|
m_dayOfWeek = (int)m_dateTime.DayOfWeek;
|
|
m_selectedCalendarDay = m_day - 1 + m_dayOfWeek;
|
|
for (int i = 0; i < m_dayNumberList.Length; i++)
|
|
{
|
|
if (i < m_dayOfWeek || i >= m_dayOfWeek + m_daysInMonth)
|
|
{
|
|
m_dayNumberList[i] = "";
|
|
continue;
|
|
}
|
|
m_dateTime = new DateTime(m_year, m_month, i - m_dayOfWeek + 1);
|
|
m_dayNumberList[i] = m_dateTime.Day.ToString();
|
|
}
|
|
}
|
|
|
|
public void SetTimeline(float value)
|
|
{
|
|
m_timeline = value;
|
|
}
|
|
|
|
public float GetTimeline()
|
|
{
|
|
return m_timeline;
|
|
}
|
|
|
|
public Vector2 GetTimeOfDay()
|
|
{
|
|
return new Vector2(m_hour, m_minute);
|
|
}
|
|
|
|
public void PauseTime()
|
|
{
|
|
m_timeProgressionStep = 0f;
|
|
}
|
|
|
|
public void PlayTimeAgain()
|
|
{
|
|
m_timeProgressionStep = GetTimeProgressionStep();
|
|
}
|
|
|
|
public void SetNewDayLength(float value)
|
|
{
|
|
m_dayLength = value;
|
|
m_timeProgressionStep = GetTimeProgressionStep();
|
|
}
|
|
|
|
public float GetEvaluateTime()
|
|
{
|
|
return m_timeOfDay;
|
|
}
|
|
|
|
public float GetSunElevation()
|
|
{
|
|
return m_sunElevation;
|
|
}
|
|
|
|
public float GetMoonElevation()
|
|
{
|
|
return m_moonElevation;
|
|
}
|
|
|
|
public void SetDate(int year, int month, int day)
|
|
{
|
|
m_year = year;
|
|
m_month = month;
|
|
m_day = day;
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public Vector3Int GetDate()
|
|
{
|
|
return new Vector3Int(m_year, m_month, m_day);
|
|
}
|
|
|
|
public string GetDateString()
|
|
{
|
|
return m_monthNameList[m_month - 1] + " " + m_day.ToString("00") + ", " + m_year.ToString("0000");
|
|
}
|
|
|
|
public string GetDateString(string format)
|
|
{
|
|
m_dateTime = new DateTime(m_year, m_month, m_day);
|
|
return m_dateTime.ToString(format);
|
|
}
|
|
|
|
public void SetYear(int value)
|
|
{
|
|
m_year = value;
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public int GetYear()
|
|
{
|
|
return m_year;
|
|
}
|
|
|
|
public void SetMonth(int value)
|
|
{
|
|
m_month = value;
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public int GetMonth()
|
|
{
|
|
return m_month;
|
|
}
|
|
|
|
public void SetDay(int value)
|
|
{
|
|
m_day = value;
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public int GetDay()
|
|
{
|
|
return m_day;
|
|
}
|
|
|
|
public void IncreaseYear()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByYear)
|
|
{
|
|
m_year++;
|
|
if (m_year > 9999)
|
|
{
|
|
m_year = 0;
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public void DecreaseYear()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByYear)
|
|
{
|
|
m_year--;
|
|
if (m_year < 0)
|
|
{
|
|
m_year = 9999;
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public void IncreaseMonth()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByMonth)
|
|
{
|
|
m_month++;
|
|
if (m_month > 12)
|
|
{
|
|
m_month = 1;
|
|
IncreaseYear();
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public void DecreaseMonth()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByMonth)
|
|
{
|
|
m_month--;
|
|
if (m_month < 1)
|
|
{
|
|
m_month = 12;
|
|
DecreaseYear();
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public void IncreaseDay()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByDay)
|
|
{
|
|
m_day++;
|
|
if (m_day > m_daysInMonth)
|
|
{
|
|
m_day = 1;
|
|
IncreaseMonth();
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
public void DecreaseDay()
|
|
{
|
|
if (m_dateLoop != AzureDateLoop.ByDay)
|
|
{
|
|
m_day--;
|
|
m_previousMonth = ((m_dateLoop == AzureDateLoop.ByMonth) ? m_month : (m_month - 1));
|
|
if (m_previousMonth < 1)
|
|
{
|
|
m_previousMonth = 12;
|
|
}
|
|
m_previousDaysInMonth = DateTime.DaysInMonth(m_year, m_previousMonth);
|
|
if (m_day < 1)
|
|
{
|
|
m_day = m_previousDaysInMonth;
|
|
DecreaseMonth();
|
|
}
|
|
}
|
|
UpdateCalendar();
|
|
}
|
|
|
|
private Quaternion GetSunSimpleRotation()
|
|
{
|
|
return Quaternion.Euler(0f, m_longitude, 0f - m_latitude) * Quaternion.Euler((m_timeOfDay + m_utc) * 360f / 24f - 90f, 180f, 0f);
|
|
}
|
|
}
|
|
}
|