。。

module/Local_Server/server/Config.cpp

@@ -368,6 +368,9 @@ void Cesium_Graphics_Config::from_base_json(const Psc::JSON* that_json) {
   terrain_limit_maximum_level = read_optional_bool_field(that_json, "terrain_limit_maximum_level", terrain_limit_maximum_level);
   terrain_maximum_level = std::clamp(read_optional_uint32_field(that_json, "terrain_maximum_level", terrain_maximum_level), 0u, 24u);
   terrain_cache_tiles = std::clamp(read_optional_uint32_field(that_json, "terrain_cache_tiles", terrain_cache_tiles), 16u, 2048u);
+  terrain_occlusion_enabled = read_optional_bool_field(that_json, "terrain_occlusion_enabled", terrain_occlusion_enabled);
+  occlusion_sample_spacing_meters = std::clamp(read_optional_double_field(that_json, "occlusion_sample_spacing_meters", occlusion_sample_spacing_meters), 10.0, 5000.0);
+  occlusion_clearance_margin_meters = read_optional_double_field(that_json, "occlusion_clearance_margin_meters", occlusion_clearance_margin_meters);
 }
 Psc::JSON Cesium_Graphics_Config::to_base_json() const {
   auto ret = Psc::JSON::object();
@@ -387,6 +390,9 @@ Psc::JSON Cesium_Graphics_Config::to_base_json() const {
   ret.append({"terrain_limit_maximum_level", terrain_limit_maximum_level});
   ret.append({"terrain_maximum_level", terrain_maximum_level});
   ret.append({"terrain_cache_tiles", terrain_cache_tiles});
+  ret.append({"terrain_occlusion_enabled", terrain_occlusion_enabled});
+  ret.append({"occlusion_sample_spacing_meters", occlusion_sample_spacing_meters});
+  ret.append({"occlusion_clearance_margin_meters", occlusion_clearance_margin_meters});
   return ret;
 }
 Map_Model_Item_Config::Map_Model_Item_Config(std::string url)
@@ -424,12 +430,14 @@ void Map_Model_Config::from_base_json(const Psc::JSON* that_json) {
   aircraft_model.from_base_json(that_json->get("aircraft_model"));
   aircraft_models = read_optional_model_object_field(that_json, "aircraft_models", make_default_aircraft_models());
   base_station_model.from_base_json(that_json->get("base_station_model"));
+  device_model.from_base_json(that_json->get("device_model"));
 }
 Psc::JSON Map_Model_Config::to_base_json() const {
   auto ret = Psc::JSON::object();
   ret.append({"aircraft_model", aircraft_model.to_base_json()});
   ret.append(write_model_object("aircraft_models", aircraft_models));
   ret.append({"base_station_model", base_station_model.to_base_json()});
+  ret.append({"device_model", device_model.to_base_json()});
   return ret;
 }
 

module/Local_Server/server/Config.h

@@ -187,6 +187,9 @@ struct Cesium_Graphics_Config {
     bool terrain_limit_maximum_level = true;
     std::uint32_t terrain_maximum_level = 15;
     std::uint32_t terrain_cache_tiles = 128;
+    bool terrain_occlusion_enabled = false;
+    double occlusion_sample_spacing_meters = 250.0;
+    double occlusion_clearance_margin_meters = 10.0;
     void from_base_json(const Psc::JSON* that_json);
     [[nodiscard]] Psc::JSON to_base_json() const;
 };
@@ -205,7 +208,8 @@ struct Map_Model_Item_Config {
 struct Map_Model_Config {
     Map_Model_Item_Config aircraft_model{"/ui/model/aircraft.glb", 50.0, -90.0, 0.0, 0.0};
     std::map<std::string, Map_Model_Item_Config> aircraft_models;
-    Map_Model_Item_Config base_station_model{"/ui/model/base-station.glb", 100.0, 0.0, 0.0, 0.0};
+    Map_Model_Item_Config base_station_model{"/ui/model/base-station.glb", 16.635522, 0.0, 0.0, 0.0};
+    Map_Model_Item_Config device_model{"/ui/model/device.glb", 80.0, 0.0, 0.0, 0.0};
     Map_Model_Config();
     void from_base_json(const Psc::JSON* that_json);
     [[nodiscard]] Psc::JSON to_base_json() const;

module/Local_Server/server/tiles.cpp

@@ -438,6 +438,9 @@ std::string model_file_name(std::string_view model_type, std::string_view aircra
     if (model_type == "base_station") {
         return "base-station-custom.glb";
     }
+    if (model_type == "device") {
+        return "device-custom.glb";
+    }
     throw std::invalid_argument("invalid model_type");
 }
 void save_uploaded_model_file(const drogon::HttpFile& upload,
@@ -473,9 +476,12 @@ void save_uploaded_model_file(const drogon::HttpFile& upload,
     else if (model_type == "aircraft_type") {
         global->map_model_config.aircraft_models[std::string(aircraft_model_key)].url = url;
     }
-    else {
+    else if (model_type == "base_station") {
         global->map_model_config.base_station_model.url = url;
     }
+    else {
+        global->map_model_config.device_model.url = url;
+    }
 }
 void handle_map_model_upload(const drogon::HttpRequestPtr& req, Global* global) {
     drogon::MultiPartParser parser;