diff --git a/Source/Engine/Core/Types/DateTime.cpp b/Source/Engine/Core/Types/DateTime.cpp
index 3141cd52d..85b42378c 100644
--- a/Source/Engine/Core/Types/DateTime.cpp
+++ b/Source/Engine/Core/Types/DateTime.cpp
@@ -12,22 +12,22 @@ const int32 CachedDaysToMonth[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
 DateTime::DateTime(int32 year, int32 month, int32 day, int32 hour, int32 minute, int32 second, int32 millisecond)
 {
     ASSERT_LOW_LAYER(Validate(year, month, day, hour, minute, second, millisecond));
-    int32 totalDays = 0;
+    int32 daysSum = 0;
     if (month > 2 && IsLeapYear(year))
-        totalDays++;
+        daysSum++;
     year--;
     month--;
-    totalDays += year * 365 + year / 4 - year / 100 + year / 400 + CachedDaysToMonth[month] + day - 1;
-    Ticks = totalDays * Constants::TicksPerDay
-            + hour * Constants::TicksPerHour
-            + minute * Constants::TicksPerMinute
-            + second * Constants::TicksPerSecond
-            + millisecond * Constants::TicksPerMillisecond;
+    daysSum += year * 365 + year / 4 - year / 100 + year / 400 + CachedDaysToMonth[month] + day - 1;
+    Ticks = daysSum * TimeSpan::TicksPerDay
+            + hour * TimeSpan::TicksPerHour
+            + minute * TimeSpan::TicksPerMinute
+            + second * TimeSpan::TicksPerSecond
+            + millisecond * TimeSpan::TicksPerMillisecond;
 }
 
 DateTime DateTime::GetDate() const
 {
-    return DateTime(Ticks - Ticks % Constants::TicksPerDay);
+    return DateTime(Ticks - Ticks % TimeSpan::TicksPerDay);
 }
 
 void DateTime::GetDate(int32& year, int32& month, int32& day) const
@@ -59,7 +59,7 @@ int32 DateTime::GetDay() const
 
 DayOfWeek DateTime::GetDayOfWeek() const
 {
-    return static_cast<DayOfWeek>((Ticks / Constants::TicksPerDay) % 7);
+    return static_cast<DayOfWeek>((Ticks / TimeSpan::TicksPerDay) % 7);
 }
 
 int32 DateTime::GetDayOfYear() const
@@ -73,7 +73,7 @@ int32 DateTime::GetDayOfYear() const
 
 int32 DateTime::GetHour() const
 {
-    return static_cast<int32>(Ticks / Constants::TicksPerHour % 24);
+    return static_cast<int32>(Ticks / TimeSpan::TicksPerHour % 24);
 }
 
 int32 DateTime::GetHour12() const
@@ -88,7 +88,7 @@ int32 DateTime::GetHour12() const
 
 double DateTime::GetJulianDay() const
 {
-    return 1721425.5 + static_cast<double>(Ticks) / Constants::TicksPerDay;
+    return 1721425.5 + static_cast<double>(Ticks) / TimeSpan::TicksPerDay;
 }
 
 double DateTime::GetModifiedJulianDay() const
@@ -98,12 +98,12 @@ double DateTime::GetModifiedJulianDay() const
 
 int32 DateTime::GetMillisecond() const
 {
-    return static_cast<int32>(Ticks / Constants::TicksPerMillisecond % 1000);
+    return static_cast<int32>(Ticks / TimeSpan::TicksPerMillisecond % 1000);
 }
 
 int32 DateTime::GetMinute() const
 {
-    return static_cast<int32>(Ticks / Constants::TicksPerMinute % 60);
+    return static_cast<int32>(Ticks / TimeSpan::TicksPerMinute % 60);
 }
 
 int32 DateTime::GetMonth() const
@@ -120,12 +120,12 @@ MonthOfYear DateTime::GetMonthOfYear() const
 
 int32 DateTime::GetSecond() const
 {
-    return static_cast<int32>(Ticks / Constants::TicksPerSecond % 60);
+    return static_cast<int32>(Ticks / TimeSpan::TicksPerSecond % 60);
 }
 
 TimeSpan DateTime::GetTimeOfDay() const
 {
-    return TimeSpan(Ticks % Constants::TicksPerDay);
+    return TimeSpan(Ticks % TimeSpan::TicksPerDay);
 }
 
 int32 DateTime::GetYear() const
@@ -135,11 +135,6 @@ int32 DateTime::GetYear() const
     return year;
 }
 
-int32 DateTime::ToUnixTimestamp() const
-{
-    return static_cast<int32>((Ticks - DateTime(1970, 1, 1).Ticks) / Constants::TicksPerSecond);
-}
-
 int32 DateTime::DaysInMonth(int32 year, int32 month)
 {
     ASSERT_LOW_LAYER((month >= 1) && (month <= 12));
@@ -153,16 +148,6 @@ int32 DateTime::DaysInYear(int32 year)
     return IsLeapYear(year) ? 366 : 365;
 }
 
-DateTime DateTime::FromJulianDay(double julianDay)
-{
-    return DateTime(static_cast<int64>((julianDay - 1721425.5) * Constants::TicksPerDay));
-}
-
-DateTime DateTime::FromUnixTimestamp(int32 unixTime)
-{
-    return DateTime(1970, 1, 1) + TimeSpan(static_cast<int64>(unixTime) * Constants::TicksPerSecond);
-}
-
 bool DateTime::IsLeapYear(int32 year)
 {
     if ((year % 4) == 0)
@@ -174,7 +159,7 @@ bool DateTime::IsLeapYear(int32 year)
 
 DateTime DateTime::MaxValue()
 {
-    return DateTime(3652059 * Constants::TicksPerDay - 1);
+    return DateTime(3652059 * TimeSpan::TicksPerDay - 1);
 }
 
 DateTime DateTime::Now()
diff --git a/Source/Engine/Core/Types/DateTime.h b/Source/Engine/Core/Types/DateTime.h
index 67b2d70ff..a89a69fcf 100644
--- a/Source/Engine/Core/Types/DateTime.h
+++ b/Source/Engine/Core/Types/DateTime.h
@@ -199,11 +199,6 @@ public:
     /// </summary>
     int32 GetYear() const;
 
-    /// <summary>
-    /// Gets this date as the number of seconds since the Unix Epoch (January 1st of 1970).
-    /// </summary>
-    int32 ToUnixTimestamp() const;
-
 public:
     /// <summary>
     /// Gets the number of days in the year and month.
@@ -220,20 +215,6 @@ public:
     /// <returns>The number of days.</returns>
     static int32 DaysInYear(int32 year);
 
-    /// <summary>
-    /// Returns the proleptic Gregorian date for the given Julian Day.
-    /// </summary>
-    /// <param name="julianDay">The Julian Day.</param>
-    /// <returns>Gregorian date and time.</returns>
-    static DateTime FromJulianDay(double julianDay);
-
-    /// <summary>
-    /// Returns the date from Unix time (seconds from midnight 1970-01-01).
-    /// </summary>
-    /// <param name="unixTime">The Unix time (seconds from midnight 1970-01-01).</param>
-    /// <returns>The Gregorian date and time.</returns>
-    static DateTime FromUnixTimestamp(int32 unixTime);
-
     /// <summary>
     /// Determines whether the specified year is a leap year.
     /// </summary>
diff --git a/Source/Engine/Core/Types/TimeSpan.cpp b/Source/Engine/Core/Types/TimeSpan.cpp
index 0e4aed407..287097672 100644
--- a/Source/Engine/Core/Types/TimeSpan.cpp
+++ b/Source/Engine/Core/Types/TimeSpan.cpp
@@ -6,38 +6,53 @@
 TimeSpan TimeSpan::FromDays(double days)
 {
     ASSERT_LOW_LAYER((days >= MinValue().GetTotalDays()) && (days <= MaxValue().GetTotalDays()));
-    return TimeSpan(static_cast<int64>(days * Constants::TicksPerDay));
+    return TimeSpan(static_cast<int64>(days * TicksPerDay));
 }
 
 TimeSpan TimeSpan::FromHours(double hours)
 {
     ASSERT_LOW_LAYER((hours >= MinValue().GetTotalHours()) && (hours <= MaxValue().GetTotalHours()));
-    return TimeSpan(static_cast<int64>(hours * Constants::TicksPerHour));
+    return TimeSpan(static_cast<int64>(hours * TicksPerHour));
 }
 
 TimeSpan TimeSpan::FromMilliseconds(double milliseconds)
 {
     ASSERT_LOW_LAYER((milliseconds >= MinValue().GetTotalMilliseconds()) && (milliseconds <= MaxValue().GetTotalMilliseconds()));
-    return TimeSpan(static_cast<int64>(milliseconds * Constants::TicksPerMillisecond));
+    return TimeSpan(static_cast<int64>(milliseconds * TicksPerMillisecond));
 }
 
 TimeSpan TimeSpan::FromMinutes(double minutes)
 {
     ASSERT_LOW_LAYER((minutes >= MinValue().GetTotalMinutes()) && (minutes <= MaxValue().GetTotalMinutes()));
-    return TimeSpan(static_cast<int64>(minutes * Constants::TicksPerMinute));
+    return TimeSpan(static_cast<int64>(minutes * TicksPerMinute));
 }
 
 TimeSpan TimeSpan::FromSeconds(double seconds)
 {
     ASSERT_LOW_LAYER((seconds >= MinValue().GetTotalSeconds()) && (seconds <= MaxValue().GetTotalSeconds()));
-    return TimeSpan(static_cast<int64>(seconds * Constants::TicksPerSecond));
+    return TimeSpan(static_cast<int64>(seconds * TicksPerSecond));
+}
+
+TimeSpan TimeSpan::MaxValue()
+{
+    return TimeSpan(9223372036854775807);
+}
+
+TimeSpan TimeSpan::MinValue()
+{
+    return TimeSpan(-9223372036854775807 - 1);
+}
+
+TimeSpan TimeSpan::Zero()
+{
+    return TimeSpan(0);
 }
 
 void TimeSpan::Set(int32 days, int32 hours, int32 minutes, int32 seconds, int32 milliseconds)
 {
     const int64 totalMs = 1000 * (60 * 60 * 24 * (int64)days + 60 * 60 * (int64)hours + 60 * (int64)minutes + (int64)seconds) + (int64)milliseconds;
     ASSERT_LOW_LAYER((totalMs >= MinValue().GetTotalMilliseconds()) && (totalMs <= MaxValue().GetTotalMilliseconds()));
-    Ticks = totalMs * Constants::TicksPerMillisecond;
+    Ticks = totalMs * TicksPerMillisecond;
 }
 
 String TimeSpan::ToString() const
diff --git a/Source/Engine/Core/Types/TimeSpan.h b/Source/Engine/Core/Types/TimeSpan.h
index 7545a21c0..f14a622a0 100644
--- a/Source/Engine/Core/Types/TimeSpan.h
+++ b/Source/Engine/Core/Types/TimeSpan.h
@@ -6,32 +6,30 @@
 #include "Engine/Core/Formatting.h"
 #include "Engine/Core/Templates.h"
 
-namespace Constants
-{
-    // The number of timespan ticks per day.
-    const int64 TicksPerDay = 864000000000;
-
-    // The number of timespan ticks per hour.
-    const int64 TicksPerHour = 36000000000;
-
-    // The number of timespan ticks per millisecond.
-    const int64 TicksPerMillisecond = 10000;
-
-    // The number of timespan ticks per minute.
-    const int64 TicksPerMinute = 600000000;
-
-    // The number of timespan ticks per second.
-    const int64 TicksPerSecond = 10000000;
-
-    // The number of timespan ticks per week.
-    const int64 TicksPerWeek = 6048000000000;
-}
-
 /// <summary>
 /// Represents the difference between two dates and times.
 /// </summary>
 API_STRUCT(InBuild, Namespace="System") struct FLAXENGINE_API TimeSpan
 {
+public:
+    // The number of timespan ticks per day.
+    static constexpr int64 TicksPerDay = 864000000000;
+
+    // The number of timespan ticks per hour.
+    static constexpr int64 TicksPerHour = 36000000000;
+
+    // The number of timespan ticks per millisecond.
+    static constexpr int64 TicksPerMillisecond = 10000;
+
+    // The number of timespan ticks per minute.
+    static constexpr int64 TicksPerMinute = 600000000;
+
+    // The number of timespan ticks per second.
+    static constexpr int64 TicksPerSecond = 10000000;
+
+    // The number of timespan ticks per week.
+    static constexpr int64 TicksPerWeek = 6048000000000;
+
 public:
     /// <summary>
     /// Time span in 100 nanoseconds resolution.
@@ -170,7 +168,7 @@ public:
     /// </summary>
     FORCE_INLINE int32 GetDays() const
     {
-        return (int32)(Ticks / Constants::TicksPerDay);
+        return (int32)(Ticks / TicksPerDay);
     }
 
     /// <summary>
@@ -186,7 +184,7 @@ public:
     /// </summary>
     FORCE_INLINE int32 GetHours() const
     {
-        return (int32)(Ticks / Constants::TicksPerHour % 24);
+        return (int32)(Ticks / TicksPerHour % 24);
     }
 
     /// <summary>
@@ -194,7 +192,7 @@ public:
     /// </summary>
     FORCE_INLINE int32 GetMilliseconds() const
     {
-        return (int32)(Ticks / Constants::TicksPerMillisecond % 1000);
+        return (int32)(Ticks / TicksPerMillisecond % 1000);
     }
 
     /// <summary>
@@ -202,7 +200,7 @@ public:
     /// </summary>
     FORCE_INLINE int32 GetMinutes() const
     {
-        return (int32)(Ticks / Constants::TicksPerMinute % 60);
+        return (int32)(Ticks / TicksPerMinute % 60);
     }
 
     /// <summary>
@@ -210,7 +208,7 @@ public:
     /// </summary>
     FORCE_INLINE int32 GetSeconds() const
     {
-        return (int32)(Ticks / Constants::TicksPerSecond % 60);
+        return (int32)(Ticks / TicksPerSecond % 60);
     }
 
     /// <summary>
@@ -218,7 +216,7 @@ public:
     /// </summary>
     FORCE_INLINE double GetTotalDays() const
     {
-        return (double)Ticks / Constants::TicksPerDay;
+        return (double)Ticks / TicksPerDay;
     }
 
     /// <summary>
@@ -226,7 +224,7 @@ public:
     /// </summary>
     FORCE_INLINE double GetTotalHours() const
     {
-        return (double)Ticks / Constants::TicksPerHour;
+        return (double)Ticks / TicksPerHour;
     }
 
     /// <summary>
@@ -234,7 +232,7 @@ public:
     /// </summary>
     FORCE_INLINE double GetTotalMilliseconds() const
     {
-        return (double)Ticks / Constants::TicksPerMillisecond;
+        return (double)Ticks / TicksPerMillisecond;
     }
 
     /// <summary>
@@ -242,7 +240,7 @@ public:
     /// </summary>
     FORCE_INLINE double GetTotalMinutes() const
     {
-        return (double)Ticks / Constants::TicksPerMinute;
+        return (double)Ticks / TicksPerMinute;
     }
 
     /// <summary>
@@ -250,7 +248,7 @@ public:
     /// </summary>
     FORCE_INLINE float GetTotalSeconds() const
     {
-        return static_cast<float>(Ticks) / Constants::TicksPerSecond;
+        return static_cast<float>(Ticks) / TicksPerSecond;
     }
 
 public:
@@ -293,29 +291,17 @@ public:
     /// <summary>
     /// Returns the maximum time span value.
     /// </summary>
-    /// <returns>The time span.</returns>
-    static TimeSpan MaxValue()
-    {
-        return TimeSpan(9223372036854775807);
-    }
+    static TimeSpan MaxValue();
 
     /// <summary>
     /// Returns the minimum time span value.
     /// </summary>
-    /// <returns>The time span.</returns>
-    static TimeSpan MinValue()
-    {
-        return TimeSpan(-9223372036854775807 - 1);
-    }
+    static TimeSpan MinValue();
 
     /// <summary>
     /// Returns the zero time span value.
     /// </summary>
-    /// <returns>The time span.</returns>
-    static TimeSpan Zero()
-    {
-        return TimeSpan(0);
-    }
+    static TimeSpan Zero();
 
 private:
     void Set(int32 days, int32 hours, int32 minutes, int32 seconds, int32 milliseconds);
diff --git a/Source/Engine/Engine/Time.cpp b/Source/Engine/Engine/Time.cpp
index 3adccdbd9..bb0c856f8 100644
--- a/Source/Engine/Engine/Time.cpp
+++ b/Source/Engine/Engine/Time.cpp
@@ -67,7 +67,7 @@ void Time::TickData::OnBeforeRun(float targetFps, double currentTime)
 {
     Time = UnscaledTime = TimeSpan::Zero();
     DeltaTime = UnscaledDeltaTime = targetFps > ZeroTolerance ? TimeSpan::FromSeconds(1.0f / targetFps) : TimeSpan::Zero();
-    LastLength = static_cast<double>(DeltaTime.Ticks) / Constants::TicksPerSecond;
+    LastLength = static_cast<double>(DeltaTime.Ticks) / TimeSpan::TicksPerSecond;
     LastBegin = currentTime - LastLength;
     LastEnd = currentTime;
     NextBegin = targetFps > ZeroTolerance ? LastBegin + (1.0f / targetFps) : 0.0;
@@ -76,7 +76,7 @@ void Time::TickData::OnBeforeRun(float targetFps, double currentTime)
 void Time::TickData::OnReset(float targetFps, double currentTime)
 {
     DeltaTime = UnscaledDeltaTime = targetFps > ZeroTolerance ? TimeSpan::FromSeconds(1.0f / targetFps) : TimeSpan::Zero();
-    LastLength = static_cast<double>(DeltaTime.Ticks) / Constants::TicksPerSecond;
+    LastLength = static_cast<double>(DeltaTime.Ticks) / TimeSpan::TicksPerSecond;
     LastBegin = currentTime - LastLength;
     LastEnd = currentTime;
 }