improved time calculations

Author: aweeri

src/astro.c

@@ -60,12 +60,16 @@ double normalize_epoch(double epoch) {
     return (yy * 1000.0) + day_of_year;
 }
 
-double epoch_to_gmst(double epoch) {
+// utility to convert normalized epoch format to unix time for sgp4 math
+double get_unix_from_epoch(double epoch) {
     epoch = normalize_epoch(epoch);
     int yy = (int)(epoch / 1000.0);
     double day = fmod(epoch, 1000.0);
-    
-    double unix_time = ConvertEpochYearAndDayToUnix(yy, day);
+    return ConvertEpochYearAndDayToUnix(yy, day);
+}
+
+double epoch_to_gmst(double epoch) {
+    double unix_time = get_unix_from_epoch(epoch);
     double jd = (unix_time / 86400.0) + 2440587.5;
 
     double gmst = fmod(280.46061837 + 360.98564736629 * (jd - 2451545.0), 360.0);
@@ -134,6 +138,7 @@ void load_tle_data(const char* filename) {
         }
 
         sat->epoch_days = parse_tle_double(line1, 18, 14);
+        sat->epoch_unix = get_unix_from_epoch(sat->epoch_days); // precalculated for perf
         sat->inclination = parse_tle_double(line2, 8, 8) * DEG2RAD;
         sat->raan = parse_tle_double(line2, 17, 8) * DEG2RAD;
 
@@ -152,18 +157,9 @@ void load_tle_data(const char* filename) {
     fclose(file);
 }
 
-Vector3 calculate_position(Satellite* sat, double current_time_days) {
-    current_time_days = normalize_epoch(current_time_days);
-    
-    int cur_yy = (int)(current_time_days / 1000.0);
-    double cur_day = fmod(current_time_days, 1000.0);
-    double current_unix = ConvertEpochYearAndDayToUnix(cur_yy, cur_day);
-
-    int sat_yy = (int)(sat->epoch_days / 1000.0);
-    double sat_day = fmod(sat->epoch_days, 1000.0);
-    double sat_unix = ConvertEpochYearAndDayToUnix(sat_yy, sat_day);
-
-    double tsince = (current_unix - sat_unix) / 60.0;
+// precalculated unix time passed down to prevent excessyear/day conversions
+Vector3 calculate_position(Satellite* sat, double current_unix) {
+    double tsince = (current_unix - sat->epoch_unix) / 60.0;
 
     double ro[3] = {0};
     double vo[3] = {0};
@@ -197,17 +193,9 @@ void get_map_coordinates(Vector3 pos, double gmst_deg, float earth_offset, float
 
 void get_apsis_2d(Satellite* sat, double current_time, bool is_apoapsis, double gmst_deg, float earth_offset, float map_w, float map_h, Vector2* out) {
     (void)gmst_deg; 
-    current_time = normalize_epoch(current_time);
-
-    int cur_yy = (int)(current_time / 1000.0);
-    double cur_day = fmod(current_time, 1000.0);
-    double current_unix = ConvertEpochYearAndDayToUnix(cur_yy, cur_day);
 
-    int sat_yy = (int)(sat->epoch_days / 1000.0);
-    double sat_day = fmod(sat->epoch_days, 1000.0);
-    double sat_unix = ConvertEpochYearAndDayToUnix(sat_yy, sat_day);
-
-    double delta_time_s = current_unix - sat_unix;
+    double current_unix = get_unix_from_epoch(current_time);
+    double delta_time_s = current_unix - sat->epoch_unix;
 
     double M = fmod(sat->mean_anomaly + sat->mean_motion * delta_time_s, 2.0 * PI);
     if (M < 0) M += 2.0 * PI;
@@ -217,20 +205,16 @@ void get_apsis_2d(Satellite* sat, double current_time, bool is_apoapsis, double
     if (diff < 0) diff += 2.0 * PI;
 
     double t_target = current_time + (diff / sat->mean_motion) / 86400.0;
-    Vector3 pos3d = calculate_position(sat, t_target);
+    double t_target_unix = get_unix_from_epoch(t_target);
+    Vector3 pos3d = calculate_position(sat, t_target_unix);
     double gmst_target = epoch_to_gmst(t_target);
 
     get_map_coordinates(pos3d, gmst_target, earth_offset, map_w, map_h, &out->x, &out->y);
 }
 
 // i truly do hope this doesnt drift or something its so eyeballed istg
 Vector3 calculate_sun_position(double current_time_days) {
-    current_time_days = normalize_epoch(current_time_days);
-    
-    int yy = (int)(current_time_days / 1000.0);
-    double day = fmod(current_time_days, 1000.0);
-    
-    double unix_time = ConvertEpochYearAndDayToUnix(yy, day);
+    double unix_time = get_unix_from_epoch(current_time_days);
     double jd = (unix_time / 86400.0) + 2440587.5;
     double n = jd - 2451545.0;
 
@@ -260,12 +244,7 @@ Vector3 calculate_sun_position(double current_time_days) {
 }
 
 Vector3 calculate_moon_position(double current_time_days) {
-    current_time_days = normalize_epoch(current_time_days);
-    
-    int yy = (int)(current_time_days / 1000.0);
-    double day = fmod(current_time_days, 1000.0);
-    
-    double unix_time = ConvertEpochYearAndDayToUnix(yy, day);
+    double unix_time = get_unix_from_epoch(current_time_days);
     double jd = (unix_time / 86400.0) + 2440587.5;
     double D = jd - 2451545.0; 
 

src/astro.h

@@ -8,13 +8,13 @@ double epoch_to_gmst(double epoch);
 void epoch_to_datetime_str(double epoch, char* buffer);
 void load_tle_data(const char* filename);
 double normalize_epoch(double epoch);
+double get_unix_from_epoch(double epoch);
 
 // orbit math stuff
 Vector3 calculate_sun_position(double current_time_days);
 void get_map_coordinates(Vector3 pos, double gmst_deg, float earth_offset, float map_w, float map_h, float* out_x, float* out_y);
-Vector3 calculate_position(Satellite* sat, double current_time_days);
+Vector3 calculate_position(Satellite* sat, double current_unix);
 Vector3 calculate_moon_position(double current_time_days);
-void get_map_coordinates(Vector3 pos, double gmst_deg, float earth_offset, float map_w, float map_h, float* out_x, float* out_y);
 void get_apsis_2d(Satellite* sat, double current_time, bool is_apoapsis, double gmst_deg, float earth_offset, float map_w, float map_h, Vector2* out);
 
 #endif // ASTRO_H

src/main.c

@@ -161,7 +161,8 @@ static void update_orbit_cache(Satellite* sat, double current_epoch) {
     double time_step = period_days / (ORBIT_CACHE_SIZE - 1);
     for (int i = 0; i < ORBIT_CACHE_SIZE; i++) {
         double t = current_epoch + (i * time_step);
-        sat->orbit_cache[i] = Vector3Scale(calculate_position(sat, t), 1.0f / DRAW_SCALE);
+        double t_unix = get_unix_from_epoch(t);
+        sat->orbit_cache[i] = Vector3Scale(calculate_position(sat, t_unix), 1.0f / DRAW_SCALE);
     }
     sat->orbit_cached = true;
 }
@@ -181,7 +182,8 @@ static void draw_orbit_3d(Satellite* sat, double current_epoch, bool is_highligh
 
         for (int i = 0; i <= segments; i++) {
             double t = current_epoch + (i * time_step);
-            Vector3 pos = Vector3Scale(calculate_position(sat, t), 1.0f / DRAW_SCALE);
+            double t_unix = get_unix_from_epoch(t);
+            Vector3 pos = Vector3Scale(calculate_position(sat, t_unix), 1.0f / DRAW_SCALE);
 
             if (i > 0) DrawLine3D(prev_pos, pos, orbitColor);
             prev_pos = pos;
@@ -382,6 +384,15 @@ int main(void) {
             }
         }
 
+        double current_unix = get_unix_from_epoch(current_epoch);
+
+        // precalculate all satellite positions for the current frame
+        for (int i = 0; i < sat_count; i++) {
+            // don't waste time calculating if it's hidden and not selected
+            if (hide_unselected && selected_sat != NULL && &satellites[i] != selected_sat) continue;
+            satellites[i].current_pos = calculate_position(&satellites[i], current_unix);
+        }
+
         // fading math
         bool should_hide = (hide_unselected && selected_sat != NULL);
         if (should_hide) {
@@ -432,7 +443,6 @@ int main(void) {
             float hit_radius_pixels = 12.0f * cfg.ui_scale; // hitbox size in screen pixels
 
             for (int i = 0; i < sat_count; i++) {
-                satellites[i].current_pos = calculate_position(&satellites[i], current_epoch);
                 // prevent raycasting on hidden satellites
                 if (hide_unselected && selected_sat != NULL && &satellites[i] != selected_sat) continue;
 
@@ -468,11 +478,13 @@ int main(void) {
             float closest_dist = 9999.0f;
 
             for (int i = 0; i < sat_count; i++) {
-                satellites[i].current_pos = calculate_position(&satellites[i], current_epoch);
                 // Prevent raycasting on fading/hidden satellites
                 if (hide_unselected && selected_sat != NULL && &satellites[i] != selected_sat) continue;
 
                 Vector3 draw_pos = Vector3Scale(satellites[i].current_pos, 1.0f / DRAW_SCALE);
+
+                // fast coarse culling via squared distance to avoid expensive sphere collision checks on distant satellites
+                if (Vector3DistanceSqr(camera3d.target, draw_pos) > (camDistance * camDistance * 16.0f)) continue; 
 
                 // adjust sphere radius based on distance to maintain consistent screen-size hitbox
                 float distToCam = Vector3Distance(camera3d.position, draw_pos);
@@ -680,7 +692,8 @@ int main(void) {
 
                             for (int j = 0; j <= segments; j++) {
                                 double t = current_epoch + (j * time_step);
-                                get_map_coordinates(calculate_position(&satellites[i], t), epoch_to_gmst(t), cfg.earth_rotation_offset, map_w, map_h, &track_pts[j].x, &track_pts[j].y);
+                                double t_unix = get_unix_from_epoch(t);
+                                get_map_coordinates(calculate_position(&satellites[i], t_unix), epoch_to_gmst(t), cfg.earth_rotation_offset, map_w, map_h, &track_pts[j].x, &track_pts[j].y);
                             }
 
                             for (int offset_i = -1; offset_i <= 1; offset_i++) {
@@ -816,9 +829,11 @@ int main(void) {
 
                 double t_peri = current_epoch + (diff_peri / active_sat->mean_motion) / 86400.0;
                 double t_apo = current_epoch + (diff_apo / active_sat->mean_motion) / 86400.0;
+                double t_peri_unix = get_unix_from_epoch(t_peri);
+                double t_apo_unix = get_unix_from_epoch(t_apo);
 
-                Vector3 draw_p = Vector3Scale(calculate_position(active_sat, t_peri), 1.0f/DRAW_SCALE);
-                Vector3 draw_a = Vector3Scale(calculate_position(active_sat, t_apo), 1.0f/DRAW_SCALE);
+                Vector3 draw_p = Vector3Scale(calculate_position(active_sat, t_peri_unix), 1.0f/DRAW_SCALE);
+                Vector3 draw_a = Vector3Scale(calculate_position(active_sat, t_apo_unix), 1.0f/DRAW_SCALE);
 
                 if (!IsOccludedByEarth(camera3d.position, draw_p, draw_earth_radius)) {
                     Vector2 sp = GetWorldToScreen(draw_p, camera3d);
@@ -956,9 +971,11 @@ int main(void) {
 
             double t_peri = current_epoch + (diff_peri / active_sat->mean_motion) / 86400.0;
             double t_apo = current_epoch + (diff_apo / active_sat->mean_motion) / 86400.0;
+            double t_peri_unix = get_unix_from_epoch(t_peri);
+            double t_apo_unix = get_unix_from_epoch(t_apo);
 
-            double real_rp = Vector3Length(calculate_position(active_sat, t_peri));
-            double real_ra = Vector3Length(calculate_position(active_sat, t_apo));
+            double real_rp = Vector3Length(calculate_position(active_sat, t_peri_unix));
+            double real_ra = Vector3Length(calculate_position(active_sat, t_apo_unix));
             // hide the periapsis/apoapsis markers if they're currently behind the Earth in the 3D view, or just off the edge of the map in 2D
             if (is_2d_view) {
                 Vector2 p2, a2;
@@ -974,8 +991,8 @@ int main(void) {
                 periScreen = GetWorldToScreen2D(p2, camera2d);
                 apoScreen = GetWorldToScreen2D(a2, camera2d);
             } else {
-                Vector3 draw_p = Vector3Scale(calculate_position(active_sat, t_peri), 1.0f/DRAW_SCALE);
-                Vector3 draw_a = Vector3Scale(calculate_position(active_sat, t_apo), 1.0f/DRAW_SCALE);
+                Vector3 draw_p = Vector3Scale(calculate_position(active_sat, t_peri_unix), 1.0f/DRAW_SCALE);
+                Vector3 draw_a = Vector3Scale(calculate_position(active_sat, t_apo_unix), 1.0f/DRAW_SCALE);
 
                 if (IsOccludedByEarth(camera3d.position, draw_p, draw_earth_radius)) show_peri = false;
                 if (IsOccludedByEarth(camera3d.position, draw_a, draw_earth_radius)) show_apo = false;

src/types.h

@@ -21,6 +21,7 @@
 typedef struct {
     char name[32];
     double epoch_days;
+    double epoch_unix; 
     double inclination;
     double raan;
     double eccentricity;