CONFIGURATION!

src/core/gfx.cpp

@@ -39,10 +39,10 @@ draw::color_t interpolateColor(double value,
   return stops.back().color;
 }
 
-#ifdef METRIC
+#ifdef CONFIG_METRIC
 draw::color_t get_altitude_color(uint32_t value) {
   static constexpr std::array<color_stop, 11> stops = {{
-#ifdef METRIC
+#ifdef CONFIG_METRIC
       {0, {220, 90, 20}},
       {150, {245, 115, 25}},
       {300, {250, 150, 30}},
@@ -55,7 +55,7 @@ draw::color_t get_altitude_color(uint32_t value) {
       {9000, {50, 110, 240}},
       {12000, {140, 50, 220}}
 #endif
-#ifndef METRIC
+#ifndef CONFIG_METRIC
       {0, {220, 90, 20}},      // Brown/Dark Orange
       {500, {245, 115, 25}},   // Orange
       {1000, {250, 150, 30}},  // Light Orange

src/main.cpp

@@ -7,22 +7,25 @@
 #include "hal/net.hpp"
 #include "nlohmann/json_fwd.hpp"
 #include <cstdint>
+#include <cstdlib>
 #include <format>
 #include <iostream>
 #include "core/global.hpp"
 #include "core/geo.hpp"
 #include "core/gfx.hpp"
 
-#ifdef AUTOSCALE
-uint16_t max_range = 500;
+#ifndef CONFIG_AUTOSCALE
+constexpr
 #endif
+uint16_t max_range = CONFIG_MAX_RANGE;
+
 
 int main() {
   if (hal::init() != 0) {
     return 1;
   }
   const auto [screen_w, screen_h] = hal::get_screen_size();
-  #ifndef AUTOSCALE
+  #ifndef CONFIG_AUTOSCALE
   const
   #endif
   float pixels_per_km =
@@ -34,13 +37,13 @@ int main() {
   const uint16_t middle_y = (screen_h / 2);
   {
     nlohmann::json receiver =
-        net::http_get_json(std::format("{}/receiver.json", base_url));
+        net::http_get_json(std::format("{}/receiver.json", CONFIG_BASE_URL));
     try {
       receiver_lat = receiver["lat"].get<float>();
       receiver_lon = receiver["lon"].get<float>();
     } catch (...) {
-      receiver_lat = FALLBACK_LAT;
-      receiver_lon = FALLBACK_LON;
+      receiver_lat = std::atof(CONFIG_FALLBACK_LAT);
+      receiver_lon = std::atof(CONFIG_FALLBACK_LON);
       std::cerr << BLUE "[INFO]" RESET " using fallback lat/lon\n";
     }
   }
@@ -73,19 +76,19 @@ int main() {
     }
 
     { // draw rings
-      for (uint16_t r = first_ring_distance; r <= max_range; r *= 2) {
+      for (uint16_t r = CONFIG_FIRST_RING_DISTANCE; r <= max_range; r *= 2) {
         draw::circle(middle_x, middle_y, r * pixels_per_km, {0xff, 0xff, 0xff});
       }
     }
 
-    #ifdef AUTOSCALE
+    #ifdef CONFIG_AUTOSCALE
     {
       // fardest aircraft in km
       uint16_t fardest_aircraft_distance_linear = 0;
     #endif
 
     { // draw planes
-      nlohmann::json aircraft = net::http_get_json(std::format("{}/aircraft.json", base_url));
+      nlohmann::json aircraft = net::http_get_json(std::format("{}/aircraft.json", CONFIG_BASE_URL));
       if (aircraft!= nullptr) {
         for(nlohmann::json &craft : aircraft["aircraft"]) {
           
@@ -95,7 +98,7 @@ int main() {
               altitude = 0;
             } else {
               altitude =craft["alt_baro"].get<uint32_t>();
-              #ifdef METRIC
+              #ifdef CONFIG_METRIC
               altitude = feet_to_meters(altitude);
               #endif
             }
@@ -106,7 +109,7 @@ int main() {
           draw::color_t color= get_altitude_color(altitude);
           try {
           const auto [x_offset,y_offset] = get_offset_from_station(craft["lat"].get<double>(), craft["lon"].get<double>());
-          #ifdef AUTOSCALE
+          #ifdef CONFIG_AUTOSCALE
           if(std::abs(x_offset)/1000 > fardest_aircraft_distance_linear) {
             fardest_aircraft_distance_linear = std::abs(x_offset)/1000;
           } 
@@ -128,11 +131,11 @@ int main() {
         std::cerr << RED"[ERROR]" RESET " failed to get aircraft\n";
       }
     }
-        #ifdef AUTOSCALE
+        #ifdef CONFIG_AUTOSCALE
         if (fardest_aircraft_distance_linear > 0) {
-          for(uint16_t i = first_ring_distance; i < UINT16_MAX; i*=2) {
-            if (i+(range_padding/2) >= fardest_aircraft_distance_linear) {
-              max_range = i+range_padding;
+          for(uint16_t i = CONFIG_FIRST_RING_DISTANCE; i < UINT16_MAX; i*=2) {
+            if (i+(CONFIG_RANGE_PADDING/2) >= fardest_aircraft_distance_linear) {
+              max_range = i+CONFIG_RANGE_PADDING;
               pixels_per_km =
       static_cast<float>(screen_h > screen_w ? screen_w : screen_h) /
       (max_range * 2);