Add explicit groundType to all map files

assets/maps/map_forest.json

@@ -9,6 +9,7 @@
     "tileSize": 1.0
   },
   "biome": {
+    "groundType": "forest_mud",
     "seed": 12345,
     "patchDensity": 3.2,
     "patchJitter": 0.85,

assets/maps/map_mountain.json

@@ -9,6 +9,7 @@
     "tileSize": 1.0
   },
   "biome": {
+    "groundType": "alpine_mix",
     "seed": 24567,
     "patchDensity": 3.0,
     "patchJitter": 0.8,

assets/maps/map_rivers.json

@@ -9,6 +9,7 @@
     "tileSize": 1.0
   },
   "biome": {
+    "groundType": "soil_fertile",
     "seed": 42,
     "patchDensity": 3.5,
     "patchJitter": 0.9,

assets/shaders/ground_plane.frag

@@ -19,13 +19,13 @@ uniform float u_ambientBoost;
 uniform vec3 u_lightDir;
 
 // Ground-type-specific uniforms
-uniform float u_snowCoverage;      // 0-1: snow accumulation
-uniform float u_moistureLevel;     // 0-1: wetness/dryness
-uniform float u_crackIntensity;    // 0-1: ground cracking
-uniform float u_rockExposure;      // 0-1: rock visibility
-uniform float u_grassSaturation;   // 0-1.5: grass color intensity
-uniform float u_soilRoughness;     // 0-1: soil texture roughness
-uniform vec3 u_snowColor;          // Snow tint color
+uniform float u_snowCoverage;    // 0-1: snow accumulation
+uniform float u_moistureLevel;   // 0-1: wetness/dryness
+uniform float u_crackIntensity;  // 0-1: ground cracking
+uniform float u_rockExposure;    // 0-1: rock visibility
+uniform float u_grassSaturation; // 0-1.5: grass color intensity
+uniform float u_soilRoughness;   // 0-1: soil texture roughness
+uniform vec3 u_snowColor;        // Snow tint color
 
 float hash21(vec2 p) {
   return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
@@ -76,7 +76,7 @@ void main() {
   if (u_crackIntensity > 0.01) {
     float crackNoise1 = noise21(wuv * 8.0);
     float crackNoise2 = noise21(wuv * 16.0 + vec2(42.0, 17.0));
-    float crackPattern = smoothstep(0.45, 0.50, crackNoise1) * 
+    float crackPattern = smoothstep(0.45, 0.50, crackNoise1) *
                          smoothstep(0.40, 0.55, crackNoise2);
     float crackDarkening = 1.0 - crackPattern * u_crackIntensity * 0.35;
     baseCol *= crackDarkening;
@@ -87,7 +87,8 @@ void main() {
     float snowNoise = fbm(wuv * 0.5 + vec2(123.0, 456.0));
     float snowAccumulation = smoothstep(0.3, 0.7, snowNoise);
     float heightSnowBonus = smoothstep(-0.5, 1.5, v_worldPos.y) * 0.3;
-    float snowMask = clamp(snowAccumulation * (u_snowCoverage + heightSnowBonus), 0.0, 1.0);
+    float snowMask =
+        clamp(snowAccumulation * (u_snowCoverage + heightSnowBonus), 0.0, 1.0);
     vec3 snowTinted = u_snowColor * (1.0 + detail * 0.1);
     baseCol = mix(baseCol, snowTinted, snowMask * 0.85);
   }

assets/shaders/terrain_chunk.frag

@@ -17,13 +17,13 @@ uniform float u_heightNoiseStrength, u_heightNoiseFrequency;
 uniform float u_ambientBoost, u_rockDetailStrength;
 
 // Ground-type-specific uniforms
-uniform float u_snowCoverage;      // 0-1: snow accumulation (alpine_mix)
-uniform float u_moistureLevel;     // 0-1: wetness/dryness
-uniform float u_crackIntensity;    // 0-1: ground cracking (grass_dry)
-uniform float u_rockExposure;      // 0-1: how much rock shows through
-uniform float u_grassSaturation;   // 0-1.5: grass color intensity
-uniform float u_soilRoughness;     // 0-1: soil texture roughness
-uniform vec3 u_snowColor;          // Snow tint color
+uniform float u_snowCoverage;    // 0-1: snow accumulation (alpine_mix)
+uniform float u_moistureLevel;   // 0-1: wetness/dryness
+uniform float u_crackIntensity;  // 0-1: ground cracking (grass_dry)
+uniform float u_rockExposure;    // 0-1: how much rock shows through
+uniform float u_grassSaturation; // 0-1.5: grass color intensity
+uniform float u_soilRoughness;   // 0-1: soil texture roughness
+uniform vec3 u_snowColor;        // Snow tint color
 
 // lets soil “climb” up steep toes (world units)
 uniform float u_soilFootHeight; // try 0.6–1.2
@@ -276,7 +276,7 @@ void main() {
   if (u_crackIntensity > 0.01) {
     float crackNoise1 = noise21(world_coord * 8.0);
     float crackNoise2 = noise21(world_coord * 16.0 + vec2(42.0, 17.0));
-    float crackPattern = smoothstep(0.45, 0.50, crackNoise1) * 
+    float crackPattern = smoothstep(0.45, 0.50, crackNoise1) *
                          smoothstep(0.40, 0.55, crackNoise2);
     crackPattern *= (1.0 - slope * 0.8); // Less cracking on slopes
     float crackDarkening = 1.0 - crackPattern * u_crackIntensity * 0.35;
@@ -291,8 +291,9 @@ void main() {
     float slopeSnowReduction = 1.0 - smoothstep(0.15, 0.45, slope);
     // Higher areas get more snow
     float heightSnowBonus = smoothstep(-0.5, 1.5, v_worldPos.y) * 0.3;
-    float snowMask = clamp(snowAccumulation * slopeSnowReduction * 
-                          (u_snowCoverage + heightSnowBonus), 0.0, 1.0);
+    float snowMask = clamp(snowAccumulation * slopeSnowReduction *
+                               (u_snowCoverage + heightSnowBonus),
+                           0.0, 1.0);
     // Blend in snow color with brightness boost
     vec3 snowTinted = u_snowColor * (1.0 + detailNoise * 0.1);
     terrainColor = mix(terrainColor, snowTinted, snowMask * 0.85);
@@ -310,7 +311,8 @@ void main() {
 
   // albedo jitter - modulated by soil roughness
   float jitterAmp = 0.06 * (0.5 + u_soilRoughness * 0.5);
-  float jitter = (hash21(world_coord * 0.27 + vec2(17.0, 9.0)) - 0.5) * jitterAmp;
+  float jitter =
+      (hash21(world_coord * 0.27 + vec2(17.0, 9.0)) - 0.5) * jitterAmp;
   float brightnessVar = (moistureVar - 0.5) * 0.08 * (1.0 - rockMask);
   terrainColor *= (1.0 + jitter + brightnessVar) * u_tint;
 
@@ -323,7 +325,8 @@ void main() {
   // Surface roughness affects specular - wet surfaces are shinier
   float surfaceRoughness = mix(0.65, 0.95, u_soilRoughness);
   surfaceRoughness = mix(surfaceRoughness, 0.45, u_moistureLevel * 0.5);
-  float specContrib = fresnel * 0.12 * (1.0 - surfaceRoughness) * (1.0 - rockMask);
+  float specContrib =
+      fresnel * 0.12 * (1.0 - surfaceRoughness) * (1.0 - rockMask);
   // Add subtle moisture-based specular for wet surfaces
   specContrib += u_moistureLevel * 0.08 * fresnel * (1.0 - rockMask);
   float shade = ambient + ndl * 0.75 + specContrib;

game/core/serialization.cpp

@@ -514,47 +514,47 @@ auto Serialization::serializeTerrain(
   terrain_obj["bridges"] = bridges_array;
 
   QJsonObject biome_obj;
-  biome_obj["grassPrimaryR"] = biome.grassPrimary.x();
-  biome_obj["grassPrimaryG"] = biome.grassPrimary.y();
-  biome_obj["grassPrimaryB"] = biome.grassPrimary.z();
-  biome_obj["grassSecondaryR"] = biome.grassSecondary.x();
-  biome_obj["grassSecondaryG"] = biome.grassSecondary.y();
-  biome_obj["grassSecondaryB"] = biome.grassSecondary.z();
-  biome_obj["grassDryR"] = biome.grassDry.x();
-  biome_obj["grassDryG"] = biome.grassDry.y();
-  biome_obj["grassDryB"] = biome.grassDry.z();
-  biome_obj["soilColorR"] = biome.soilColor.x();
-  biome_obj["soilColorG"] = biome.soilColor.y();
-  biome_obj["soilColorB"] = biome.soilColor.z();
-  biome_obj["rockLowR"] = biome.rockLow.x();
-  biome_obj["rockLowG"] = biome.rockLow.y();
-  biome_obj["rockLowB"] = biome.rockLow.z();
-  biome_obj["rockHighR"] = biome.rockHigh.x();
-  biome_obj["rockHighG"] = biome.rockHigh.y();
-  biome_obj["rockHighB"] = biome.rockHigh.z();
-  biome_obj["patchDensity"] = biome.patchDensity;
-  biome_obj["patchJitter"] = biome.patchJitter;
-  biome_obj["backgroundBladeDensity"] = biome.backgroundBladeDensity;
-  biome_obj["bladeHeightMin"] = biome.bladeHeightMin;
-  biome_obj["bladeHeightMax"] = biome.bladeHeightMax;
-  biome_obj["bladeWidthMin"] = biome.bladeWidthMin;
-  biome_obj["bladeWidthMax"] = biome.bladeWidthMax;
+  biome_obj["grassPrimaryR"] = biome.grass_primary.x();
+  biome_obj["grassPrimaryG"] = biome.grass_primary.y();
+  biome_obj["grassPrimaryB"] = biome.grass_primary.z();
+  biome_obj["grassSecondaryR"] = biome.grass_secondary.x();
+  biome_obj["grassSecondaryG"] = biome.grass_secondary.y();
+  biome_obj["grassSecondaryB"] = biome.grass_secondary.z();
+  biome_obj["grassDryR"] = biome.grass_dry.x();
+  biome_obj["grassDryG"] = biome.grass_dry.y();
+  biome_obj["grassDryB"] = biome.grass_dry.z();
+  biome_obj["soilColorR"] = biome.soil_color.x();
+  biome_obj["soilColorG"] = biome.soil_color.y();
+  biome_obj["soilColorB"] = biome.soil_color.z();
+  biome_obj["rockLowR"] = biome.rock_low.x();
+  biome_obj["rockLowG"] = biome.rock_low.y();
+  biome_obj["rockLowB"] = biome.rock_low.z();
+  biome_obj["rockHighR"] = biome.rock_high.x();
+  biome_obj["rockHighG"] = biome.rock_high.y();
+  biome_obj["rockHighB"] = biome.rock_high.z();
+  biome_obj["patchDensity"] = biome.patch_density;
+  biome_obj["patchJitter"] = biome.patch_jitter;
+  biome_obj["backgroundBladeDensity"] = biome.background_blade_density;
+  biome_obj["bladeHeightMin"] = biome.blade_height_min;
+  biome_obj["bladeHeightMax"] = biome.blade_height_max;
+  biome_obj["bladeWidthMin"] = biome.blade_width_min;
+  biome_obj["bladeWidthMax"] = biome.blade_width_max;
   biome_obj["sway_strength"] = biome.sway_strength;
   biome_obj["sway_speed"] = biome.sway_speed;
-  biome_obj["heightNoiseAmplitude"] = biome.heightNoiseAmplitude;
-  biome_obj["heightNoiseFrequency"] = biome.heightNoiseFrequency;
-  biome_obj["terrainMacroNoiseScale"] = biome.terrainMacroNoiseScale;
-  biome_obj["terrainDetailNoiseScale"] = biome.terrainDetailNoiseScale;
-  biome_obj["terrainSoilHeight"] = biome.terrainSoilHeight;
-  biome_obj["terrainSoilSharpness"] = biome.terrainSoilSharpness;
-  biome_obj["terrainRockThreshold"] = biome.terrainRockThreshold;
-  biome_obj["terrainRockSharpness"] = biome.terrainRockSharpness;
-  biome_obj["terrainAmbientBoost"] = biome.terrainAmbientBoost;
-  biome_obj["terrainRockDetailStrength"] = biome.terrainRockDetailStrength;
-  biome_obj["backgroundSwayVariance"] = biome.backgroundSwayVariance;
-  biome_obj["backgroundScatterRadius"] = biome.backgroundScatterRadius;
+  biome_obj["heightNoiseAmplitude"] = biome.height_noise_amplitude;
+  biome_obj["heightNoiseFrequency"] = biome.height_noise_frequency;
+  biome_obj["terrainMacroNoiseScale"] = biome.terrain_macro_noise_scale;
+  biome_obj["terrainDetailNoiseScale"] = biome.terrain_detail_noise_scale;
+  biome_obj["terrainSoilHeight"] = biome.terrain_soil_height;
+  biome_obj["terrainSoilSharpness"] = biome.terrain_soil_sharpness;
+  biome_obj["terrainRockThreshold"] = biome.terrain_rock_threshold;
+  biome_obj["terrainRockSharpness"] = biome.terrain_rock_sharpness;
+  biome_obj["terrainAmbientBoost"] = biome.terrain_ambient_boost;
+  biome_obj["terrainRockDetailStrength"] = biome.terrain_rock_detail_strength;
+  biome_obj["backgroundSwayVariance"] = biome.background_sway_variance;
+  biome_obj["backgroundScatterRadius"] = biome.background_scatter_radius;
   biome_obj["plant_density"] = biome.plant_density;
-  biome_obj["spawnEdgePadding"] = biome.spawnEdgePadding;
+  biome_obj["spawnEdgePadding"] = biome.spawn_edge_padding;
   biome_obj["seed"] = static_cast<qint64>(biome.seed);
   terrain_obj["biome"] = biome_obj;
 
@@ -585,78 +585,79 @@ void Serialization::deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
       return {r, g, b};
     };
 
-    biome.grassPrimary =
-        read_color(QStringLiteral("grassPrimary"), default_biome.grassPrimary);
-    biome.grassSecondary = read_color(QStringLiteral("grassSecondary"),
-                                      default_biome.grassSecondary);
-    biome.grassDry =
-        read_color(QStringLiteral("grassDry"), default_biome.grassDry);
-    biome.soilColor =
-        read_color(QStringLiteral("soilColor"), default_biome.soilColor);
-    biome.rockLow =
-        read_color(QStringLiteral("rockLow"), default_biome.rockLow);
-    biome.rockHigh =
-        read_color(QStringLiteral("rockHigh"), default_biome.rockHigh);
-
-    biome.patchDensity = static_cast<float>(
-        biome_obj["patchDensity"].toDouble(default_biome.patchDensity));
-    biome.patchJitter = static_cast<float>(
-        biome_obj["patchJitter"].toDouble(default_biome.patchJitter));
-    biome.backgroundBladeDensity =
+    biome.grass_primary =
+        read_color(QStringLiteral("grassPrimary"), default_biome.grass_primary);
+    biome.grass_secondary = read_color(QStringLiteral("grassSecondary"),
+                                       default_biome.grass_secondary);
+    biome.grass_dry =
+        read_color(QStringLiteral("grassDry"), default_biome.grass_dry);
+    biome.soil_color =
+        read_color(QStringLiteral("soilColor"), default_biome.soil_color);
+    biome.rock_low =
+        read_color(QStringLiteral("rockLow"), default_biome.rock_low);
+    biome.rock_high =
+        read_color(QStringLiteral("rockHigh"), default_biome.rock_high);
+
+    biome.patch_density = static_cast<float>(
+        biome_obj["patchDensity"].toDouble(default_biome.patch_density));
+    biome.patch_jitter = static_cast<float>(
+        biome_obj["patchJitter"].toDouble(default_biome.patch_jitter));
+    biome.background_blade_density =
         static_cast<float>(biome_obj["backgroundBladeDensity"].toDouble(
-            default_biome.backgroundBladeDensity));
-    biome.bladeHeightMin = static_cast<float>(
-        biome_obj["bladeHeightMin"].toDouble(default_biome.bladeHeightMin));
-    biome.bladeHeightMax = static_cast<float>(
-        biome_obj["bladeHeightMax"].toDouble(default_biome.bladeHeightMax));
-    biome.bladeWidthMin = static_cast<float>(
-        biome_obj["bladeWidthMin"].toDouble(default_biome.bladeWidthMin));
-    biome.bladeWidthMax = static_cast<float>(
-        biome_obj["bladeWidthMax"].toDouble(default_biome.bladeWidthMax));
+            default_biome.background_blade_density));
+    biome.blade_height_min = static_cast<float>(
+        biome_obj["bladeHeightMin"].toDouble(default_biome.blade_height_min));
+    biome.blade_height_max = static_cast<float>(
+        biome_obj["bladeHeightMax"].toDouble(default_biome.blade_height_max));
+    biome.blade_width_min = static_cast<float>(
+        biome_obj["bladeWidthMin"].toDouble(default_biome.blade_width_min));
+    biome.blade_width_max = static_cast<float>(
+        biome_obj["bladeWidthMax"].toDouble(default_biome.blade_width_max));
     biome.sway_strength = static_cast<float>(
         biome_obj["sway_strength"].toDouble(default_biome.sway_strength));
     biome.sway_speed = static_cast<float>(
         biome_obj["sway_speed"].toDouble(default_biome.sway_speed));
-    biome.heightNoiseAmplitude =
+    biome.height_noise_amplitude =
         static_cast<float>(biome_obj["heightNoiseAmplitude"].toDouble(
-            default_biome.heightNoiseAmplitude));
-    biome.heightNoiseFrequency =
+            default_biome.height_noise_amplitude));
+    biome.height_noise_frequency =
         static_cast<float>(biome_obj["heightNoiseFrequency"].toDouble(
-            default_biome.heightNoiseFrequency));
-    biome.terrainMacroNoiseScale =
+            default_biome.height_noise_frequency));
+    biome.terrain_macro_noise_scale =
         static_cast<float>(biome_obj["terrainMacroNoiseScale"].toDouble(
-            default_biome.terrainMacroNoiseScale));
-    biome.terrainDetailNoiseScale =
+            default_biome.terrain_macro_noise_scale));
+    biome.terrain_detail_noise_scale =
         static_cast<float>(biome_obj["terrainDetailNoiseScale"].toDouble(
-            default_biome.terrainDetailNoiseScale));
-    biome.terrainSoilHeight =
+            default_biome.terrain_detail_noise_scale));
+    biome.terrain_soil_height =
         static_cast<float>(biome_obj["terrainSoilHeight"].toDouble(
-            default_biome.terrainSoilHeight));
-    biome.terrainSoilSharpness =
+            default_biome.terrain_soil_height));
+    biome.terrain_soil_sharpness =
         static_cast<float>(biome_obj["terrainSoilSharpness"].toDouble(
-            default_biome.terrainSoilSharpness));
-    biome.terrainRockThreshold =
+            default_biome.terrain_soil_sharpness));
+    biome.terrain_rock_threshold =
         static_cast<float>(biome_obj["terrainRockThreshold"].toDouble(
-            default_biome.terrainRockThreshold));
-    biome.terrainRockSharpness =
+            default_biome.terrain_rock_threshold));
+    biome.terrain_rock_sharpness =
         static_cast<float>(biome_obj["terrainRockSharpness"].toDouble(
-            default_biome.terrainRockSharpness));
-    biome.terrainAmbientBoost =
+            default_biome.terrain_rock_sharpness));
+    biome.terrain_ambient_boost =
         static_cast<float>(biome_obj["terrainAmbientBoost"].toDouble(
-            default_biome.terrainAmbientBoost));
-    biome.terrainRockDetailStrength =
+            default_biome.terrain_ambient_boost));
+    biome.terrain_rock_detail_strength =
         static_cast<float>(biome_obj["terrainRockDetailStrength"].toDouble(
-            default_biome.terrainRockDetailStrength));
-    biome.backgroundSwayVariance =
+            default_biome.terrain_rock_detail_strength));
+    biome.background_sway_variance =
         static_cast<float>(biome_obj["backgroundSwayVariance"].toDouble(
-            default_biome.backgroundSwayVariance));
-    biome.backgroundScatterRadius =
+            default_biome.background_sway_variance));
+    biome.background_scatter_radius =
         static_cast<float>(biome_obj["backgroundScatterRadius"].toDouble(
-            default_biome.backgroundScatterRadius));
+            default_biome.background_scatter_radius));
     biome.plant_density = static_cast<float>(
         biome_obj["plant_density"].toDouble(default_biome.plant_density));
-    biome.spawnEdgePadding = static_cast<float>(
-        biome_obj["spawnEdgePadding"].toDouble(default_biome.spawnEdgePadding));
+    biome.spawn_edge_padding =
+        static_cast<float>(biome_obj["spawnEdgePadding"].toDouble(
+            default_biome.spawn_edge_padding));
     if (biome_obj.contains("seed")) {
       biome.seed = static_cast<std::uint32_t>(
           biome_obj["seed"].toVariant().toULongLong());

game/map/map_loader.cpp

@@ -85,48 +85,49 @@ auto readVector3(const QJsonValue &value,
 }
 
 void readBiome(const QJsonObject &obj, BiomeSettings &out) {
-  // First, check for ground_type and apply defaults if specified
+
   if (obj.contains(GROUND_TYPE)) {
     const QString ground_type_str = obj.value(GROUND_TYPE).toString();
     GroundType parsed_ground_type;
-    if (tryParseGroundType(ground_type_str, parsed_ground_type)) {
-      applyGroundTypeDefaults(out, parsed_ground_type);
+    if (try_parse_ground_type(ground_type_str, parsed_ground_type)) {
+      apply_ground_type_defaults(out, parsed_ground_type);
     } else {
       qWarning() << "MapLoader: unknown ground type" << ground_type_str
                  << "- using default (forest_mud)";
-      applyGroundTypeDefaults(out, GroundType::ForestMud);
+      apply_ground_type_defaults(out, GroundType::ForestMud);
     }
   }
-  // Then apply any explicit overrides from JSON
+
   if (obj.contains(SEED)) {
     out.seed = static_cast<std::uint32_t>(
         std::max(0.0, obj.value(SEED).toDouble(out.seed)));
   }
   if (obj.contains(PATCH_DENSITY)) {
-    out.patchDensity =
-        float(obj.value(PATCH_DENSITY).toDouble(out.patchDensity));
+    out.patch_density =
+        float(obj.value(PATCH_DENSITY).toDouble(out.patch_density));
   }
   if (obj.contains(PATCH_JITTER)) {
-    out.patchJitter = float(obj.value(PATCH_JITTER).toDouble(out.patchJitter));
+    out.patch_jitter =
+        float(obj.value(PATCH_JITTER).toDouble(out.patch_jitter));
   }
   if (obj.contains(BLADE_HEIGHT)) {
     auto arr = obj.value(BLADE_HEIGHT).toArray();
     if (arr.size() == 2) {
-      out.bladeHeightMin = float(arr[0].toDouble(out.bladeHeightMin));
-      out.bladeHeightMax = float(arr[1].toDouble(out.bladeHeightMax));
+      out.blade_height_min = float(arr[0].toDouble(out.blade_height_min));
+      out.blade_height_max = float(arr[1].toDouble(out.blade_height_max));
     }
   }
   if (obj.contains(BLADE_WIDTH)) {
     auto arr = obj.value(BLADE_WIDTH).toArray();
     if (arr.size() == 2) {
-      out.bladeWidthMin = float(arr[0].toDouble(out.bladeWidthMin));
-      out.bladeWidthMax = float(arr[1].toDouble(out.bladeWidthMax));
+      out.blade_width_min = float(arr[0].toDouble(out.blade_width_min));
+      out.blade_width_max = float(arr[1].toDouble(out.blade_width_max));
     }
   }
   if (obj.contains(BACKGROUND_BLADE_DENSITY)) {
-    out.backgroundBladeDensity =
+    out.background_blade_density =
         float(obj.value(BACKGROUND_BLADE_DENSITY)
-                  .toDouble(out.backgroundBladeDensity));
+                  .toDouble(out.background_blade_density));
   }
   if (obj.contains(SWAY_STRENGTH)) {
     out.sway_strength =
@@ -138,92 +139,94 @@ void readBiome(const QJsonObject &obj, BiomeSettings &out) {
   if (obj.contains(HEIGHT_NOISE)) {
     auto arr = obj.value(HEIGHT_NOISE).toArray();
     if (arr.size() == 2) {
-      out.heightNoiseAmplitude =
-          float(arr[0].toDouble(out.heightNoiseAmplitude));
-      out.heightNoiseFrequency =
-          float(arr[1].toDouble(out.heightNoiseFrequency));
+      out.height_noise_amplitude =
+          float(arr[0].toDouble(out.height_noise_amplitude));
+      out.height_noise_frequency =
+          float(arr[1].toDouble(out.height_noise_frequency));
     }
   }
 
   if (obj.contains(GRASS_PRIMARY)) {
-    out.grassPrimary = readVector3(obj.value(GRASS_PRIMARY), out.grassPrimary);
+    out.grass_primary =
+        readVector3(obj.value(GRASS_PRIMARY), out.grass_primary);
   }
   if (obj.contains(GRASS_SECONDARY)) {
-    out.grassSecondary =
-        readVector3(obj.value(GRASS_SECONDARY), out.grassSecondary);
+    out.grass_secondary =
+        readVector3(obj.value(GRASS_SECONDARY), out.grass_secondary);
   }
   if (obj.contains(GRASS_DRY)) {
-    out.grassDry = readVector3(obj.value(GRASS_DRY), out.grassDry);
+    out.grass_dry = readVector3(obj.value(GRASS_DRY), out.grass_dry);
   }
   if (obj.contains(SOIL_COLOR)) {
-    out.soilColor = readVector3(obj.value(SOIL_COLOR), out.soilColor);
+    out.soil_color = readVector3(obj.value(SOIL_COLOR), out.soil_color);
   }
   if (obj.contains(ROCK_LOW)) {
-    out.rockLow = readVector3(obj.value(ROCK_LOW), out.rockLow);
+    out.rock_low = readVector3(obj.value(ROCK_LOW), out.rock_low);
   }
   if (obj.contains(ROCK_HIGH)) {
-    out.rockHigh = readVector3(obj.value(ROCK_HIGH), out.rockHigh);
+    out.rock_high = readVector3(obj.value(ROCK_HIGH), out.rock_high);
   }
   if (obj.contains(TERRAIN_MACRO_NOISE_SCALE)) {
-    out.terrainMacroNoiseScale =
+    out.terrain_macro_noise_scale =
         float(obj.value(TERRAIN_MACRO_NOISE_SCALE)
-                  .toDouble(out.terrainMacroNoiseScale));
+                  .toDouble(out.terrain_macro_noise_scale));
   }
   if (obj.contains(TERRAIN_DETAIL_NOISE_SCALE)) {
-    out.terrainDetailNoiseScale =
+    out.terrain_detail_noise_scale =
         float(obj.value(TERRAIN_DETAIL_NOISE_SCALE)
-                  .toDouble(out.terrainDetailNoiseScale));
+                  .toDouble(out.terrain_detail_noise_scale));
   }
   if (obj.contains(TERRAIN_SOIL_HEIGHT)) {
-    out.terrainSoilHeight =
-        float(obj.value(TERRAIN_SOIL_HEIGHT).toDouble(out.terrainSoilHeight));
+    out.terrain_soil_height =
+        float(obj.value(TERRAIN_SOIL_HEIGHT).toDouble(out.terrain_soil_height));
   }
   if (obj.contains(TERRAIN_SOIL_SHARPNESS)) {
-    out.terrainSoilSharpness = float(
-        obj.value(TERRAIN_SOIL_SHARPNESS).toDouble(out.terrainSoilSharpness));
+    out.terrain_soil_sharpness = float(
+        obj.value(TERRAIN_SOIL_SHARPNESS).toDouble(out.terrain_soil_sharpness));
   }
   if (obj.contains(TERRAIN_ROCK_THRESHOLD)) {
-    out.terrainRockThreshold = float(
-        obj.value(TERRAIN_ROCK_THRESHOLD).toDouble(out.terrainRockThreshold));
+    out.terrain_rock_threshold = float(
+        obj.value(TERRAIN_ROCK_THRESHOLD).toDouble(out.terrain_rock_threshold));
   }
   if (obj.contains(TERRAIN_ROCK_SHARPNESS)) {
-    out.terrainRockSharpness = float(
-        obj.value(TERRAIN_ROCK_SHARPNESS).toDouble(out.terrainRockSharpness));
+    out.terrain_rock_sharpness = float(
+        obj.value(TERRAIN_ROCK_SHARPNESS).toDouble(out.terrain_rock_sharpness));
   }
   if (obj.contains(TERRAIN_AMBIENT_BOOST)) {
-    out.terrainAmbientBoost = float(
-        obj.value(TERRAIN_AMBIENT_BOOST).toDouble(out.terrainAmbientBoost));
+    out.terrain_ambient_boost = float(
+        obj.value(TERRAIN_AMBIENT_BOOST).toDouble(out.terrain_ambient_boost));
   }
   if (obj.contains(TERRAIN_ROCK_DETAIL_STRENGTH)) {
-    out.terrainRockDetailStrength =
+    out.terrain_rock_detail_strength =
         float(obj.value(TERRAIN_ROCK_DETAIL_STRENGTH)
-                  .toDouble(out.terrainRockDetailStrength));
+                  .toDouble(out.terrain_rock_detail_strength));
   }
   if (obj.contains(BACKGROUND_SWAY_VARIANCE)) {
-    out.backgroundSwayVariance =
+    out.background_sway_variance =
         float(obj.value(BACKGROUND_SWAY_VARIANCE)
-                  .toDouble(out.backgroundSwayVariance));
+                  .toDouble(out.background_sway_variance));
   }
   if (obj.contains(BACKGROUND_SCATTER_RADIUS)) {
-    out.backgroundScatterRadius =
+    out.background_scatter_radius =
         float(obj.value(BACKGROUND_SCATTER_RADIUS)
-                  .toDouble(out.backgroundScatterRadius));
+                  .toDouble(out.background_scatter_radius));
   }
   if (obj.contains(PLANT_DENSITY)) {
     out.plant_density =
         float(obj.value(PLANT_DENSITY).toDouble(out.plant_density));
   }
   if (obj.contains(GROUND_IRREGULARITY_ENABLED)) {
-    out.groundIrregularityEnabled = obj.value(GROUND_IRREGULARITY_ENABLED)
-                                        .toBool(out.groundIrregularityEnabled);
+    out.ground_irregularity_enabled =
+        obj.value(GROUND_IRREGULARITY_ENABLED)
+            .toBool(out.ground_irregularity_enabled);
   }
   if (obj.contains(IRREGULARITY_SCALE)) {
-    out.irregularityScale =
-        float(obj.value(IRREGULARITY_SCALE).toDouble(out.irregularityScale));
+    out.irregularity_scale =
+        float(obj.value(IRREGULARITY_SCALE).toDouble(out.irregularity_scale));
   }
   if (obj.contains(IRREGULARITY_AMPLITUDE)) {
-    out.irregularityAmplitude = float(
-        obj.value(IRREGULARITY_AMPLITUDE).toDouble(out.irregularityAmplitude));
+    out.irregularity_amplitude = float(
+        obj.value(IRREGULARITY_AMPLITUDE).toDouble(out.irregularity_amplitude));
   }
 }
 

game/map/terrain.cpp

@@ -470,10 +470,10 @@ void TerrainHeightMap::applyBiomeVariation(const BiomeSettings &settings) {
     return;
   }
 
-  if (settings.groundIrregularityEnabled) {
-    const float amplitude = std::max(0.0F, settings.irregularityAmplitude);
+  if (settings.ground_irregularity_enabled) {
+    const float amplitude = std::max(0.0F, settings.irregularity_amplitude);
     if (amplitude > 0.0001F) {
-      const float frequency = std::max(0.0001F, settings.irregularityScale);
+      const float frequency = std::max(0.0001F, settings.irregularity_scale);
       const float half_width = m_width * 0.5F - 0.5F;
       const float half_height = m_height * 0.5F - 0.5F;
 
@@ -514,9 +514,10 @@ void TerrainHeightMap::applyBiomeVariation(const BiomeSettings &settings) {
     }
   }
 
-  const float legacy_amplitude = std::max(0.0F, settings.heightNoiseAmplitude);
+  const float legacy_amplitude =
+      std::max(0.0F, settings.height_noise_amplitude);
   if (legacy_amplitude > 0.0001F) {
-    const float frequency = std::max(0.0001F, settings.heightNoiseFrequency);
+    const float frequency = std::max(0.0001F, settings.height_noise_frequency);
     const float half_width = m_width * 0.5F - 0.5F;
     const float half_height = m_height * 0.5F - 0.5F;
 

game/map/terrain.h

@@ -13,14 +13,14 @@ namespace Game::Map {
 enum class TerrainType { Flat, Hill, Mountain, River };
 
 enum class GroundType {
-  ForestMud,    // Default: Deep green + mud ground (current style)
-  GrassDry,     // Dry Mediterranean Grass
-  SoilRocky,    // Light-Brown Rocky Soil
-  AlpineMix,    // Alpine Rock + Snow Mix
-  SoilFertile   // Dark Fertile Farmland Soil
+  ForestMud,
+  GrassDry,
+  SoilRocky,
+  AlpineMix,
+  SoilFertile
 };
 
-inline auto groundTypeToQString(GroundType type) -> QString {
+inline auto ground_type_to_qstring(GroundType type) -> QString {
   switch (type) {
   case GroundType::ForestMud:
     return QStringLiteral("forest_mud");
@@ -36,11 +36,12 @@ inline auto groundTypeToQString(GroundType type) -> QString {
   return QStringLiteral("forest_mud");
 }
 
-inline auto groundTypeToString(GroundType type) -> std::string {
-  return groundTypeToQString(type).toStdString();
+inline auto ground_type_to_string(GroundType type) -> std::string {
+  return ground_type_to_qstring(type).toStdString();
 }
 
-inline auto tryParseGroundType(const QString &value, GroundType &out) -> bool {
+inline auto try_parse_ground_type(const QString &value,
+                                  GroundType &out) -> bool {
   const QString lowered = value.trimmed().toLower();
   if (lowered == QStringLiteral("forest_mud")) {
     out = GroundType::ForestMud;
@@ -66,9 +67,9 @@ inline auto tryParseGroundType(const QString &value, GroundType &out) -> bool {
 }
 
 inline auto
-groundTypeFromString(const std::string &str) -> std::optional<GroundType> {
+ground_type_from_string(const std::string &str) -> std::optional<GroundType> {
   GroundType result;
-  if (tryParseGroundType(QString::fromStdString(str), result)) {
+  if (try_parse_ground_type(QString::fromStdString(str), result)) {
     return result;
   }
   return std::nullopt;
@@ -124,268 +125,262 @@ terrainTypeFromString(const std::string &str) -> std::optional<TerrainType> {
 }
 
 struct BiomeSettings {
-  GroundType groundType = GroundType::ForestMud;
-  QVector3D grassPrimary{0.30F, 0.60F, 0.28F};
-  QVector3D grassSecondary{0.44F, 0.70F, 0.32F};
-  QVector3D grassDry{0.72F, 0.66F, 0.48F};
-  QVector3D soilColor{0.28F, 0.24F, 0.18F};
-  QVector3D rockLow{0.48F, 0.46F, 0.44F};
-  QVector3D rockHigh{0.68F, 0.69F, 0.73F};
-  float patchDensity = 4.5F;
-  float patchJitter = 0.95F;
-  float backgroundBladeDensity = 0.65F;
-  float bladeHeightMin = 0.55F;
-  float bladeHeightMax = 1.35F;
-  float bladeWidthMin = 0.025F;
-  float bladeWidthMax = 0.055F;
+  GroundType ground_type = GroundType::ForestMud;
+  QVector3D grass_primary{0.30F, 0.60F, 0.28F};
+  QVector3D grass_secondary{0.44F, 0.70F, 0.32F};
+  QVector3D grass_dry{0.72F, 0.66F, 0.48F};
+  QVector3D soil_color{0.28F, 0.24F, 0.18F};
+  QVector3D rock_low{0.48F, 0.46F, 0.44F};
+  QVector3D rock_high{0.68F, 0.69F, 0.73F};
+  float patch_density = 4.5F;
+  float patch_jitter = 0.95F;
+  float background_blade_density = 0.65F;
+  float blade_height_min = 0.55F;
+  float blade_height_max = 1.35F;
+  float blade_width_min = 0.025F;
+  float blade_width_max = 0.055F;
   float sway_strength = 0.25F;
   float sway_speed = 1.4F;
-  float heightNoiseAmplitude = 0.16F;
-  float heightNoiseFrequency = 0.05F;
-  float terrainMacroNoiseScale = 0.035F;
-  float terrainDetailNoiseScale = 0.14F;
-  float terrainSoilHeight = 0.6F;
-  float terrainSoilSharpness = 3.8F;
-  float terrainRockThreshold = 0.42F;
-  float terrainRockSharpness = 3.1F;
-  float terrainAmbientBoost = 1.08F;
-  float terrainRockDetailStrength = 0.35F;
-  float backgroundSwayVariance = 0.2F;
-  float backgroundScatterRadius = 0.35F;
+  float height_noise_amplitude = 0.16F;
+  float height_noise_frequency = 0.05F;
+  float terrain_macro_noise_scale = 0.035F;
+  float terrain_detail_noise_scale = 0.14F;
+  float terrain_soil_height = 0.6F;
+  float terrain_soil_sharpness = 3.8F;
+  float terrain_rock_threshold = 0.42F;
+  float terrain_rock_sharpness = 3.1F;
+  float terrain_ambient_boost = 1.08F;
+  float terrain_rock_detail_strength = 0.35F;
+  float background_sway_variance = 0.2F;
+  float background_scatter_radius = 0.35F;
   float plant_density = 0.5F;
-  float spawnEdgePadding = 0.08F;
+  float spawn_edge_padding = 0.08F;
   std::uint32_t seed = 1337U;
-  bool groundIrregularityEnabled = true;
-  float irregularityScale = 0.15F;
-  float irregularityAmplitude = 0.08F;
-
-  // Ground-type-specific shader parameters
-  float snowCoverage = 0.0F;      // 0-1: snow accumulation (alpine_mix)
-  float moistureLevel = 0.5F;     // 0-1: wetness/dryness (affects soil/grass)
-  float crackIntensity = 0.0F;    // 0-1: ground cracking (grass_dry)
-  float rockExposure = 0.3F;      // 0-1: how much rock shows through (soil_rocky)
-  float grassSaturation = 1.0F;   // 0-1.5: grass color intensity
-  float soilRoughness = 0.5F;     // 0-1: soil texture roughness
-  QVector3D snowColor{0.92F, 0.94F, 0.98F}; // Snow tint color (alpine_mix)
+  bool ground_irregularity_enabled = true;
+  float irregularity_scale = 0.15F;
+  float irregularity_amplitude = 0.08F;
+
+  float snow_coverage = 0.0F;
+  float moisture_level = 0.5F;
+  float crack_intensity = 0.0F;
+  float rock_exposure = 0.3F;
+  float grass_saturation = 1.0F;
+  float soil_roughness = 0.5F;
+  QVector3D snow_color{0.92F, 0.94F, 0.98F};
 };
 
-inline void applyGroundTypeDefaults(BiomeSettings &settings,
-                                    GroundType groundType) {
-  settings.groundType = groundType;
-  switch (groundType) {
+inline void apply_ground_type_defaults(BiomeSettings &settings,
+                                       GroundType ground_type) {
+  settings.ground_type = ground_type;
+  switch (ground_type) {
   case GroundType::ForestMud:
-    // Default: Deep green + mud ground (current style)
-    // Lush vegetation with wet, muddy soil in shaded forest areas
-    settings.grassPrimary = QVector3D(0.30F, 0.60F, 0.28F);
-    settings.grassSecondary = QVector3D(0.44F, 0.70F, 0.32F);
-    settings.grassDry = QVector3D(0.72F, 0.66F, 0.48F);
-    settings.soilColor = QVector3D(0.28F, 0.24F, 0.18F);
-    settings.rockLow = QVector3D(0.48F, 0.46F, 0.44F);
-    settings.rockHigh = QVector3D(0.68F, 0.69F, 0.73F);
-    settings.terrainAmbientBoost = 1.08F;
-    settings.terrainRockDetailStrength = 0.35F;
-    // Grass/vegetation properties - tall lush grass
-    settings.patchDensity = 4.5F;
-    settings.patchJitter = 0.95F;
-    settings.backgroundBladeDensity = 0.70F;
-    settings.bladeHeightMin = 0.60F;
-    settings.bladeHeightMax = 1.40F;
-    settings.bladeWidthMin = 0.028F;
-    settings.bladeWidthMax = 0.058F;
+
+    settings.grass_primary = QVector3D(0.30F, 0.60F, 0.28F);
+    settings.grass_secondary = QVector3D(0.44F, 0.70F, 0.32F);
+    settings.grass_dry = QVector3D(0.72F, 0.66F, 0.48F);
+    settings.soil_color = QVector3D(0.28F, 0.24F, 0.18F);
+    settings.rock_low = QVector3D(0.48F, 0.46F, 0.44F);
+    settings.rock_high = QVector3D(0.68F, 0.69F, 0.73F);
+    settings.terrain_ambient_boost = 1.08F;
+    settings.terrain_rock_detail_strength = 0.35F;
+
+    settings.patch_density = 4.5F;
+    settings.patch_jitter = 0.95F;
+    settings.background_blade_density = 0.70F;
+    settings.blade_height_min = 0.60F;
+    settings.blade_height_max = 1.40F;
+    settings.blade_width_min = 0.028F;
+    settings.blade_width_max = 0.058F;
     settings.sway_strength = 0.28F;
     settings.sway_speed = 1.3F;
-    // Terrain noise - moderate variation with mud patches
-    settings.terrainMacroNoiseScale = 0.035F;
-    settings.terrainDetailNoiseScale = 0.14F;
-    settings.terrainSoilHeight = 0.65F;
-    settings.terrainSoilSharpness = 3.5F;
-    settings.terrainRockThreshold = 0.48F;
-    settings.terrainRockSharpness = 3.2F;
-    // Ground irregularity - moderate for forest floor
-    settings.groundIrregularityEnabled = true;
-    settings.irregularityScale = 0.15F;
-    settings.irregularityAmplitude = 0.09F;
+
+    settings.terrain_macro_noise_scale = 0.035F;
+    settings.terrain_detail_noise_scale = 0.14F;
+    settings.terrain_soil_height = 0.65F;
+    settings.terrain_soil_sharpness = 3.5F;
+    settings.terrain_rock_threshold = 0.48F;
+    settings.terrain_rock_sharpness = 3.2F;
+
+    settings.ground_irregularity_enabled = true;
+    settings.irregularity_scale = 0.15F;
+    settings.irregularity_amplitude = 0.09F;
     settings.plant_density = 0.60F;
-    // Ground-type-specific shader parameters - forest_mud
-    settings.snowCoverage = 0.0F;
-    settings.moistureLevel = 0.70F;
-    settings.crackIntensity = 0.0F;
-    settings.rockExposure = 0.25F;
-    settings.grassSaturation = 1.05F;
-    settings.soilRoughness = 0.55F;
-    settings.snowColor = QVector3D(0.92F, 0.94F, 0.98F);
+
+    settings.snow_coverage = 0.0F;
+    settings.moisture_level = 0.70F;
+    settings.crack_intensity = 0.0F;
+    settings.rock_exposure = 0.25F;
+    settings.grass_saturation = 1.05F;
+    settings.soil_roughness = 0.55F;
+    settings.snow_color = QVector3D(0.92F, 0.94F, 0.98F);
     break;
 
   case GroundType::GrassDry:
-    // Dry Mediterranean Grass
-    // Sparse, yellowed grass with dusty exposed soil and cracked earth
-    settings.grassPrimary = QVector3D(0.58F, 0.54F, 0.32F);
-    settings.grassSecondary = QVector3D(0.65F, 0.60F, 0.38F);
-    settings.grassDry = QVector3D(0.78F, 0.72F, 0.45F);
-    settings.soilColor = QVector3D(0.52F, 0.44F, 0.32F);
-    settings.rockLow = QVector3D(0.62F, 0.58F, 0.52F);
-    settings.rockHigh = QVector3D(0.78F, 0.75F, 0.70F);
-    settings.terrainAmbientBoost = 1.18F;
-    settings.terrainRockDetailStrength = 0.28F;
-    // Grass/vegetation properties - short sparse dry grass
-    settings.patchDensity = 2.8F;
-    settings.patchJitter = 0.75F;
-    settings.backgroundBladeDensity = 0.35F;
-    settings.bladeHeightMin = 0.35F;
-    settings.bladeHeightMax = 0.80F;
-    settings.bladeWidthMin = 0.018F;
-    settings.bladeWidthMax = 0.038F;
+
+    settings.grass_primary = QVector3D(0.58F, 0.54F, 0.32F);
+    settings.grass_secondary = QVector3D(0.65F, 0.60F, 0.38F);
+    settings.grass_dry = QVector3D(0.78F, 0.72F, 0.45F);
+    settings.soil_color = QVector3D(0.52F, 0.44F, 0.32F);
+    settings.rock_low = QVector3D(0.62F, 0.58F, 0.52F);
+    settings.rock_high = QVector3D(0.78F, 0.75F, 0.70F);
+    settings.terrain_ambient_boost = 1.18F;
+    settings.terrain_rock_detail_strength = 0.28F;
+
+    settings.patch_density = 2.8F;
+    settings.patch_jitter = 0.75F;
+    settings.background_blade_density = 0.35F;
+    settings.blade_height_min = 0.35F;
+    settings.blade_height_max = 0.80F;
+    settings.blade_width_min = 0.018F;
+    settings.blade_width_max = 0.038F;
     settings.sway_strength = 0.15F;
     settings.sway_speed = 1.8F;
-    // Terrain noise - less variation, more cracked appearance
-    settings.terrainMacroNoiseScale = 0.028F;
-    settings.terrainDetailNoiseScale = 0.22F;
-    settings.terrainSoilHeight = 0.50F;
-    settings.terrainSoilSharpness = 4.5F;
-    settings.terrainRockThreshold = 0.38F;
-    settings.terrainRockSharpness = 2.8F;
-    // Ground irregularity - low for dry packed earth
-    settings.groundIrregularityEnabled = true;
-    settings.irregularityScale = 0.10F;
-    settings.irregularityAmplitude = 0.04F;
+
+    settings.terrain_macro_noise_scale = 0.028F;
+    settings.terrain_detail_noise_scale = 0.22F;
+    settings.terrain_soil_height = 0.50F;
+    settings.terrain_soil_sharpness = 4.5F;
+    settings.terrain_rock_threshold = 0.38F;
+    settings.terrain_rock_sharpness = 2.8F;
+
+    settings.ground_irregularity_enabled = true;
+    settings.irregularity_scale = 0.10F;
+    settings.irregularity_amplitude = 0.04F;
     settings.plant_density = 0.25F;
-    // Ground-type-specific shader parameters - grass_dry
-    settings.snowCoverage = 0.0F;
-    settings.moistureLevel = 0.15F;
-    settings.crackIntensity = 0.65F;
-    settings.rockExposure = 0.35F;
-    settings.grassSaturation = 0.75F;
-    settings.soilRoughness = 0.72F;
-    settings.snowColor = QVector3D(0.92F, 0.94F, 0.98F);
+
+    settings.snow_coverage = 0.0F;
+    settings.moisture_level = 0.15F;
+    settings.crack_intensity = 0.65F;
+    settings.rock_exposure = 0.35F;
+    settings.grass_saturation = 0.75F;
+    settings.soil_roughness = 0.72F;
+    settings.snow_color = QVector3D(0.92F, 0.94F, 0.98F);
     break;
 
   case GroundType::SoilRocky:
-    // Light-Brown Rocky Soil
-    // Exposed rocks with thin soil cover, mountain foothills aesthetic
-    settings.grassPrimary = QVector3D(0.40F, 0.45F, 0.28F);
-    settings.grassSecondary = QVector3D(0.48F, 0.52F, 0.32F);
-    settings.grassDry = QVector3D(0.58F, 0.52F, 0.38F);
-    settings.soilColor = QVector3D(0.55F, 0.48F, 0.38F);
-    settings.rockLow = QVector3D(0.52F, 0.50F, 0.46F);
-    settings.rockHigh = QVector3D(0.72F, 0.70F, 0.66F);
-    settings.terrainAmbientBoost = 1.05F;
-    settings.terrainRockDetailStrength = 0.65F;
-    // Grass/vegetation properties - sparse clumps between rocks
-    settings.patchDensity = 2.2F;
-    settings.patchJitter = 0.60F;
-    settings.backgroundBladeDensity = 0.28F;
-    settings.bladeHeightMin = 0.30F;
-    settings.bladeHeightMax = 0.70F;
-    settings.bladeWidthMin = 0.020F;
-    settings.bladeWidthMax = 0.040F;
+
+    settings.grass_primary = QVector3D(0.40F, 0.45F, 0.28F);
+    settings.grass_secondary = QVector3D(0.48F, 0.52F, 0.32F);
+    settings.grass_dry = QVector3D(0.58F, 0.52F, 0.38F);
+    settings.soil_color = QVector3D(0.55F, 0.48F, 0.38F);
+    settings.rock_low = QVector3D(0.52F, 0.50F, 0.46F);
+    settings.rock_high = QVector3D(0.72F, 0.70F, 0.66F);
+    settings.terrain_ambient_boost = 1.05F;
+    settings.terrain_rock_detail_strength = 0.65F;
+
+    settings.patch_density = 2.2F;
+    settings.patch_jitter = 0.60F;
+    settings.background_blade_density = 0.28F;
+    settings.blade_height_min = 0.30F;
+    settings.blade_height_max = 0.70F;
+    settings.blade_width_min = 0.020F;
+    settings.blade_width_max = 0.040F;
     settings.sway_strength = 0.18F;
     settings.sway_speed = 1.5F;
-    // Terrain noise - high detail for rocky texture
-    settings.terrainMacroNoiseScale = 0.055F;
-    settings.terrainDetailNoiseScale = 0.28F;
-    settings.terrainSoilHeight = 0.40F;
-    settings.terrainSoilSharpness = 5.0F;
-    settings.terrainRockThreshold = 0.28F;
-    settings.terrainRockSharpness = 4.0F;
-    // Ground irregularity - high for rocky terrain
-    settings.groundIrregularityEnabled = true;
-    settings.irregularityScale = 0.22F;
-    settings.irregularityAmplitude = 0.14F;
+
+    settings.terrain_macro_noise_scale = 0.055F;
+    settings.terrain_detail_noise_scale = 0.28F;
+    settings.terrain_soil_height = 0.40F;
+    settings.terrain_soil_sharpness = 5.0F;
+    settings.terrain_rock_threshold = 0.28F;
+    settings.terrain_rock_sharpness = 4.0F;
+
+    settings.ground_irregularity_enabled = true;
+    settings.irregularity_scale = 0.22F;
+    settings.irregularity_amplitude = 0.14F;
     settings.plant_density = 0.18F;
-    // Ground-type-specific shader parameters - soil_rocky
-    settings.snowCoverage = 0.0F;
-    settings.moistureLevel = 0.35F;
-    settings.crackIntensity = 0.25F;
-    settings.rockExposure = 0.75F;
-    settings.grassSaturation = 0.85F;
-    settings.soilRoughness = 0.85F;
-    settings.snowColor = QVector3D(0.92F, 0.94F, 0.98F);
+
+    settings.snow_coverage = 0.0F;
+    settings.moisture_level = 0.35F;
+    settings.crack_intensity = 0.25F;
+    settings.rock_exposure = 0.75F;
+    settings.grass_saturation = 0.85F;
+    settings.soil_roughness = 0.85F;
+    settings.snow_color = QVector3D(0.92F, 0.94F, 0.98F);
     break;
 
   case GroundType::AlpineMix:
-    // Alpine Rock + Snow Mix
-    // High altitude with snow patches, lichen-covered rocks, hardy grass
-    settings.grassPrimary = QVector3D(0.32F, 0.40F, 0.30F);
-    settings.grassSecondary = QVector3D(0.38F, 0.46F, 0.36F);
-    settings.grassDry = QVector3D(0.50F, 0.48F, 0.42F);
-    settings.soilColor = QVector3D(0.42F, 0.40F, 0.38F);
-    settings.rockLow = QVector3D(0.58F, 0.60F, 0.64F);
-    settings.rockHigh = QVector3D(0.88F, 0.90F, 0.94F);
-    settings.terrainAmbientBoost = 1.25F;
-    settings.terrainRockDetailStrength = 0.52F;
-    // Grass/vegetation properties - short hardy alpine grass
-    settings.patchDensity = 1.8F;
-    settings.patchJitter = 0.50F;
-    settings.backgroundBladeDensity = 0.22F;
-    settings.bladeHeightMin = 0.20F;
-    settings.bladeHeightMax = 0.50F;
-    settings.bladeWidthMin = 0.015F;
-    settings.bladeWidthMax = 0.032F;
+
+    settings.grass_primary = QVector3D(0.32F, 0.40F, 0.30F);
+    settings.grass_secondary = QVector3D(0.38F, 0.46F, 0.36F);
+    settings.grass_dry = QVector3D(0.50F, 0.48F, 0.42F);
+    settings.soil_color = QVector3D(0.42F, 0.40F, 0.38F);
+    settings.rock_low = QVector3D(0.58F, 0.60F, 0.64F);
+    settings.rock_high = QVector3D(0.88F, 0.90F, 0.94F);
+    settings.terrain_ambient_boost = 1.25F;
+    settings.terrain_rock_detail_strength = 0.52F;
+
+    settings.patch_density = 1.8F;
+    settings.patch_jitter = 0.50F;
+    settings.background_blade_density = 0.22F;
+    settings.blade_height_min = 0.20F;
+    settings.blade_height_max = 0.50F;
+    settings.blade_width_min = 0.015F;
+    settings.blade_width_max = 0.032F;
     settings.sway_strength = 0.22F;
     settings.sway_speed = 2.0F;
-    // Terrain noise - moderate with snow accumulation effect
-    settings.terrainMacroNoiseScale = 0.042F;
-    settings.terrainDetailNoiseScale = 0.18F;
-    settings.terrainSoilHeight = 0.55F;
-    settings.terrainSoilSharpness = 3.0F;
-    settings.terrainRockThreshold = 0.32F;
-    settings.terrainRockSharpness = 2.5F;
-    // Ground irregularity - moderate for alpine terrain
-    settings.groundIrregularityEnabled = true;
-    settings.irregularityScale = 0.18F;
-    settings.irregularityAmplitude = 0.12F;
+
+    settings.terrain_macro_noise_scale = 0.042F;
+    settings.terrain_detail_noise_scale = 0.18F;
+    settings.terrain_soil_height = 0.55F;
+    settings.terrain_soil_sharpness = 3.0F;
+    settings.terrain_rock_threshold = 0.32F;
+    settings.terrain_rock_sharpness = 2.5F;
+
+    settings.ground_irregularity_enabled = true;
+    settings.irregularity_scale = 0.18F;
+    settings.irregularity_amplitude = 0.12F;
     settings.plant_density = 0.12F;
-    // Ground-type-specific shader parameters - alpine_mix
-    settings.snowCoverage = 0.55F;
-    settings.moistureLevel = 0.45F;
-    settings.crackIntensity = 0.10F;
-    settings.rockExposure = 0.60F;
-    settings.grassSaturation = 0.80F;
-    settings.soilRoughness = 0.62F;
-    settings.snowColor = QVector3D(0.94F, 0.96F, 1.0F);
+
+    settings.snow_coverage = 0.55F;
+    settings.moisture_level = 0.45F;
+    settings.crack_intensity = 0.10F;
+    settings.rock_exposure = 0.60F;
+    settings.grass_saturation = 0.80F;
+    settings.soil_roughness = 0.62F;
+    settings.snow_color = QVector3D(0.94F, 0.96F, 1.0F);
     break;
 
   case GroundType::SoilFertile:
-    // Dark Fertile Farmland Soil
-    // Rich dark earth with lush green grass, ideal for agriculture
-    settings.grassPrimary = QVector3D(0.25F, 0.55F, 0.22F);
-    settings.grassSecondary = QVector3D(0.35F, 0.65F, 0.30F);
-    settings.grassDry = QVector3D(0.52F, 0.48F, 0.32F);
-    settings.soilColor = QVector3D(0.20F, 0.16F, 0.12F);
-    settings.rockLow = QVector3D(0.38F, 0.36F, 0.34F);
-    settings.rockHigh = QVector3D(0.52F, 0.50F, 0.48F);
-    settings.terrainAmbientBoost = 1.02F;
-    settings.terrainRockDetailStrength = 0.22F;
-    // Grass/vegetation properties - thick healthy grass
-    settings.patchDensity = 5.2F;
-    settings.patchJitter = 0.90F;
-    settings.backgroundBladeDensity = 0.80F;
-    settings.bladeHeightMin = 0.55F;
-    settings.bladeHeightMax = 1.25F;
-    settings.bladeWidthMin = 0.030F;
-    settings.bladeWidthMax = 0.062F;
+
+    settings.grass_primary = QVector3D(0.25F, 0.55F, 0.22F);
+    settings.grass_secondary = QVector3D(0.35F, 0.65F, 0.30F);
+    settings.grass_dry = QVector3D(0.52F, 0.48F, 0.32F);
+    settings.soil_color = QVector3D(0.20F, 0.16F, 0.12F);
+    settings.rock_low = QVector3D(0.38F, 0.36F, 0.34F);
+    settings.rock_high = QVector3D(0.52F, 0.50F, 0.48F);
+    settings.terrain_ambient_boost = 1.02F;
+    settings.terrain_rock_detail_strength = 0.22F;
+
+    settings.patch_density = 5.2F;
+    settings.patch_jitter = 0.90F;
+    settings.background_blade_density = 0.80F;
+    settings.blade_height_min = 0.55F;
+    settings.blade_height_max = 1.25F;
+    settings.blade_width_min = 0.030F;
+    settings.blade_width_max = 0.062F;
     settings.sway_strength = 0.32F;
     settings.sway_speed = 1.2F;
-    // Terrain noise - smooth fertile soil
-    settings.terrainMacroNoiseScale = 0.025F;
-    settings.terrainDetailNoiseScale = 0.10F;
-    settings.terrainSoilHeight = 0.75F;
-    settings.terrainSoilSharpness = 2.8F;
-    settings.terrainRockThreshold = 0.58F;
-    settings.terrainRockSharpness = 2.2F;
-    // Ground irregularity - low for flat farmland
-    settings.groundIrregularityEnabled = true;
-    settings.irregularityScale = 0.08F;
-    settings.irregularityAmplitude = 0.05F;
+
+    settings.terrain_macro_noise_scale = 0.025F;
+    settings.terrain_detail_noise_scale = 0.10F;
+    settings.terrain_soil_height = 0.75F;
+    settings.terrain_soil_sharpness = 2.8F;
+    settings.terrain_rock_threshold = 0.58F;
+    settings.terrain_rock_sharpness = 2.2F;
+
+    settings.ground_irregularity_enabled = true;
+    settings.irregularity_scale = 0.08F;
+    settings.irregularity_amplitude = 0.05F;
     settings.plant_density = 0.45F;
-    // Ground-type-specific shader parameters - soil_fertile
-    settings.snowCoverage = 0.0F;
-    settings.moistureLevel = 0.80F;
-    settings.crackIntensity = 0.0F;
-    settings.rockExposure = 0.12F;
-    settings.grassSaturation = 1.15F;
-    settings.soilRoughness = 0.42F;
-    settings.snowColor = QVector3D(0.92F, 0.94F, 0.98F);
+
+    settings.snow_coverage = 0.0F;
+    settings.moisture_level = 0.80F;
+    settings.crack_intensity = 0.0F;
+    settings.rock_exposure = 0.12F;
+    settings.grass_saturation = 1.15F;
+    settings.soil_roughness = 0.42F;
+    settings.snow_color = QVector3D(0.92F, 0.94F, 0.98F);
     break;
   }
 }

render/gl/backend.cpp

@@ -305,23 +305,23 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         m_terrainPipeline->m_grassShader->setUniform(
             m_terrainPipeline->m_grassUniforms.time, grass.params.time);
       }
-      if (m_terrainPipeline->m_grassUniforms.windStrength !=
+      if (m_terrainPipeline->m_grassUniforms.wind_strength !=
           Shader::InvalidUniform) {
         m_terrainPipeline->m_grassShader->setUniform(
-            m_terrainPipeline->m_grassUniforms.windStrength,
-            grass.params.windStrength);
+            m_terrainPipeline->m_grassUniforms.wind_strength,
+            grass.params.wind_strength);
       }
-      if (m_terrainPipeline->m_grassUniforms.windSpeed !=
+      if (m_terrainPipeline->m_grassUniforms.wind_speed !=
           Shader::InvalidUniform) {
         m_terrainPipeline->m_grassShader->setUniform(
-            m_terrainPipeline->m_grassUniforms.windSpeed,
-            grass.params.windSpeed);
+            m_terrainPipeline->m_grassUniforms.wind_speed,
+            grass.params.wind_speed);
       }
-      if (m_terrainPipeline->m_grassUniforms.soilColor !=
+      if (m_terrainPipeline->m_grassUniforms.soil_color !=
           Shader::InvalidUniform) {
         m_terrainPipeline->m_grassShader->setUniform(
-            m_terrainPipeline->m_grassUniforms.soilColor,
-            grass.params.soilColor);
+            m_terrainPipeline->m_grassUniforms.soil_color,
+            grass.params.soil_color);
       }
       if (m_terrainPipeline->m_grassUniforms.light_dir !=
           Shader::InvalidUniform) {
@@ -456,17 +456,17 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         plant_shader->setUniform(m_vegetationPipeline->m_plantUniforms.time,
                                  plant.params.time);
       }
-      if (m_vegetationPipeline->m_plantUniforms.windStrength !=
+      if (m_vegetationPipeline->m_plantUniforms.wind_strength !=
           Shader::InvalidUniform) {
         plant_shader->setUniform(
-            m_vegetationPipeline->m_plantUniforms.windStrength,
-            plant.params.windStrength);
+            m_vegetationPipeline->m_plantUniforms.wind_strength,
+            plant.params.wind_strength);
       }
-      if (m_vegetationPipeline->m_plantUniforms.windSpeed !=
+      if (m_vegetationPipeline->m_plantUniforms.wind_speed !=
           Shader::InvalidUniform) {
         plant_shader->setUniform(
-            m_vegetationPipeline->m_plantUniforms.windSpeed,
-            plant.params.windSpeed);
+            m_vegetationPipeline->m_plantUniforms.wind_speed,
+            plant.params.wind_speed);
       }
       if (m_vegetationPipeline->m_plantUniforms.light_direction !=
           Shader::InvalidUniform) {
@@ -543,16 +543,16 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         pine_shader->setUniform(m_vegetationPipeline->m_pineUniforms.time,
                                 pine.params.time);
       }
-      if (m_vegetationPipeline->m_pineUniforms.windStrength !=
+      if (m_vegetationPipeline->m_pineUniforms.wind_strength !=
           Shader::InvalidUniform) {
         pine_shader->setUniform(
-            m_vegetationPipeline->m_pineUniforms.windStrength,
-            pine.params.windStrength);
+            m_vegetationPipeline->m_pineUniforms.wind_strength,
+            pine.params.wind_strength);
       }
-      if (m_vegetationPipeline->m_pineUniforms.windSpeed !=
+      if (m_vegetationPipeline->m_pineUniforms.wind_speed !=
           Shader::InvalidUniform) {
-        pine_shader->setUniform(m_vegetationPipeline->m_pineUniforms.windSpeed,
-                                pine.params.windSpeed);
+        pine_shader->setUniform(m_vegetationPipeline->m_pineUniforms.wind_speed,
+                                pine.params.wind_speed);
       }
       if (m_vegetationPipeline->m_pineUniforms.light_direction !=
           Shader::InvalidUniform) {
@@ -710,7 +710,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
     case TerrainChunkCmdIndex: {
       const auto &terrain = std::get<TerrainChunkCmdIndex>(cmd);
 
-      Shader *active_shader = terrain.params.isGroundPlane
+      Shader *active_shader = terrain.params.is_ground_plane
                                   ? m_terrainPipeline->m_groundShader
                                   : m_terrainPipeline->m_terrainShader;
 
@@ -726,7 +726,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
 
       const QMatrix4x4 mvp = view_proj * terrain.model;
 
-      if (terrain.params.isGroundPlane) {
+      if (terrain.params.is_ground_plane) {
 
         if (m_terrainPipeline->m_groundUniforms.mvp != Shader::InvalidUniform) {
           active_shader->setUniform(m_terrainPipeline->m_groundUniforms.mvp,
@@ -737,40 +737,40 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           active_shader->setUniform(m_terrainPipeline->m_groundUniforms.model,
                                     terrain.model);
         }
-        if (m_terrainPipeline->m_groundUniforms.grassPrimary !=
+        if (m_terrainPipeline->m_groundUniforms.grass_primary !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.grassPrimary,
-              terrain.params.grassPrimary);
+              m_terrainPipeline->m_groundUniforms.grass_primary,
+              terrain.params.grass_primary);
         }
-        if (m_terrainPipeline->m_groundUniforms.grassSecondary !=
+        if (m_terrainPipeline->m_groundUniforms.grass_secondary !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.grassSecondary,
-              terrain.params.grassSecondary);
+              m_terrainPipeline->m_groundUniforms.grass_secondary,
+              terrain.params.grass_secondary);
         }
-        if (m_terrainPipeline->m_groundUniforms.grassDry !=
+        if (m_terrainPipeline->m_groundUniforms.grass_dry !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.grassDry,
-              terrain.params.grassDry);
+              m_terrainPipeline->m_groundUniforms.grass_dry,
+              terrain.params.grass_dry);
         }
-        if (m_terrainPipeline->m_groundUniforms.soilColor !=
+        if (m_terrainPipeline->m_groundUniforms.soil_color !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.soilColor,
-              terrain.params.soilColor);
+              m_terrainPipeline->m_groundUniforms.soil_color,
+              terrain.params.soil_color);
         }
         if (m_terrainPipeline->m_groundUniforms.tint !=
             Shader::InvalidUniform) {
           active_shader->setUniform(m_terrainPipeline->m_groundUniforms.tint,
                                     terrain.params.tint);
         }
-        if (m_terrainPipeline->m_groundUniforms.noiseOffset !=
+        if (m_terrainPipeline->m_groundUniforms.noise_offset !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.noiseOffset,
-              terrain.params.noiseOffset);
+              m_terrainPipeline->m_groundUniforms.noise_offset,
+              terrain.params.noise_offset);
         }
         if (m_terrainPipeline->m_groundUniforms.tile_size !=
             Shader::InvalidUniform) {
@@ -778,47 +778,47 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
               m_terrainPipeline->m_groundUniforms.tile_size,
               terrain.params.tile_size);
         }
-        if (m_terrainPipeline->m_groundUniforms.macroNoiseScale !=
+        if (m_terrainPipeline->m_groundUniforms.macro_noise_scale !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.macroNoiseScale,
-              terrain.params.macroNoiseScale);
+              m_terrainPipeline->m_groundUniforms.macro_noise_scale,
+              terrain.params.macro_noise_scale);
         }
-        if (m_terrainPipeline->m_groundUniforms.detail_noiseScale !=
+        if (m_terrainPipeline->m_groundUniforms.detail_noise_scale !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.detail_noiseScale,
-              terrain.params.detail_noiseScale);
+              m_terrainPipeline->m_groundUniforms.detail_noise_scale,
+              terrain.params.detail_noise_scale);
         }
-        if (m_terrainPipeline->m_groundUniforms.soilBlendHeight !=
+        if (m_terrainPipeline->m_groundUniforms.soil_blend_height !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.soilBlendHeight,
-              terrain.params.soilBlendHeight);
+              m_terrainPipeline->m_groundUniforms.soil_blend_height,
+              terrain.params.soil_blend_height);
         }
-        if (m_terrainPipeline->m_groundUniforms.soilBlendSharpness !=
+        if (m_terrainPipeline->m_groundUniforms.soil_blend_sharpness !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.soilBlendSharpness,
-              terrain.params.soilBlendSharpness);
+              m_terrainPipeline->m_groundUniforms.soil_blend_sharpness,
+              terrain.params.soil_blend_sharpness);
         }
-        if (m_terrainPipeline->m_groundUniforms.heightNoiseStrength !=
+        if (m_terrainPipeline->m_groundUniforms.height_noise_strength !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.heightNoiseStrength,
-              terrain.params.heightNoiseStrength);
+              m_terrainPipeline->m_groundUniforms.height_noise_strength,
+              terrain.params.height_noise_strength);
         }
-        if (m_terrainPipeline->m_groundUniforms.heightNoiseFrequency !=
+        if (m_terrainPipeline->m_groundUniforms.height_noise_frequency !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.heightNoiseFrequency,
-              terrain.params.heightNoiseFrequency);
+              m_terrainPipeline->m_groundUniforms.height_noise_frequency,
+              terrain.params.height_noise_frequency);
         }
-        if (m_terrainPipeline->m_groundUniforms.ambientBoost !=
+        if (m_terrainPipeline->m_groundUniforms.ambient_boost !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.ambientBoost,
-              terrain.params.ambientBoost);
+              m_terrainPipeline->m_groundUniforms.ambient_boost,
+              terrain.params.ambient_boost);
         }
         if (m_terrainPipeline->m_groundUniforms.light_dir !=
             Shader::InvalidUniform) {
@@ -829,48 +829,48 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           active_shader->setUniform(
               m_terrainPipeline->m_groundUniforms.light_dir, light_dir);
         }
-        // Ground-type-specific uniforms
-        if (m_terrainPipeline->m_groundUniforms.snowCoverage !=
+
+        if (m_terrainPipeline->m_groundUniforms.snow_coverage !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.snowCoverage,
-              terrain.params.snowCoverage);
+              m_terrainPipeline->m_groundUniforms.snow_coverage,
+              terrain.params.snow_coverage);
         }
-        if (m_terrainPipeline->m_groundUniforms.moistureLevel !=
+        if (m_terrainPipeline->m_groundUniforms.moisture_level !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.moistureLevel,
-              terrain.params.moistureLevel);
+              m_terrainPipeline->m_groundUniforms.moisture_level,
+              terrain.params.moisture_level);
         }
-        if (m_terrainPipeline->m_groundUniforms.crackIntensity !=
+        if (m_terrainPipeline->m_groundUniforms.crack_intensity !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.crackIntensity,
-              terrain.params.crackIntensity);
+              m_terrainPipeline->m_groundUniforms.crack_intensity,
+              terrain.params.crack_intensity);
         }
-        if (m_terrainPipeline->m_groundUniforms.rockExposure !=
+        if (m_terrainPipeline->m_groundUniforms.rock_exposure !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.rockExposure,
-              terrain.params.rockExposure);
+              m_terrainPipeline->m_groundUniforms.rock_exposure,
+              terrain.params.rock_exposure);
         }
-        if (m_terrainPipeline->m_groundUniforms.grassSaturation !=
+        if (m_terrainPipeline->m_groundUniforms.grass_saturation !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.grassSaturation,
-              terrain.params.grassSaturation);
+              m_terrainPipeline->m_groundUniforms.grass_saturation,
+              terrain.params.grass_saturation);
         }
-        if (m_terrainPipeline->m_groundUniforms.soilRoughness !=
+        if (m_terrainPipeline->m_groundUniforms.soil_roughness !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.soilRoughness,
-              terrain.params.soilRoughness);
+              m_terrainPipeline->m_groundUniforms.soil_roughness,
+              terrain.params.soil_roughness);
         }
-        if (m_terrainPipeline->m_groundUniforms.snowColor !=
+        if (m_terrainPipeline->m_groundUniforms.snow_color !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_groundUniforms.snowColor,
-              terrain.params.snowColor);
+              m_terrainPipeline->m_groundUniforms.snow_color,
+              terrain.params.snow_color);
         }
       } else {
 
@@ -884,52 +884,52 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           active_shader->setUniform(m_terrainPipeline->m_terrainUniforms.model,
                                     terrain.model);
         }
-        if (m_terrainPipeline->m_terrainUniforms.grassPrimary !=
+        if (m_terrainPipeline->m_terrainUniforms.grass_primary !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.grassPrimary,
-              terrain.params.grassPrimary);
+              m_terrainPipeline->m_terrainUniforms.grass_primary,
+              terrain.params.grass_primary);
         }
-        if (m_terrainPipeline->m_terrainUniforms.grassSecondary !=
+        if (m_terrainPipeline->m_terrainUniforms.grass_secondary !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.grassSecondary,
-              terrain.params.grassSecondary);
+              m_terrainPipeline->m_terrainUniforms.grass_secondary,
+              terrain.params.grass_secondary);
         }
-        if (m_terrainPipeline->m_terrainUniforms.grassDry !=
+        if (m_terrainPipeline->m_terrainUniforms.grass_dry !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.grassDry,
-              terrain.params.grassDry);
+              m_terrainPipeline->m_terrainUniforms.grass_dry,
+              terrain.params.grass_dry);
         }
-        if (m_terrainPipeline->m_terrainUniforms.soilColor !=
+        if (m_terrainPipeline->m_terrainUniforms.soil_color !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.soilColor,
-              terrain.params.soilColor);
+              m_terrainPipeline->m_terrainUniforms.soil_color,
+              terrain.params.soil_color);
         }
-        if (m_terrainPipeline->m_terrainUniforms.rockLow !=
+        if (m_terrainPipeline->m_terrainUniforms.rock_low !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.rockLow,
-              terrain.params.rockLow);
+              m_terrainPipeline->m_terrainUniforms.rock_low,
+              terrain.params.rock_low);
         }
-        if (m_terrainPipeline->m_terrainUniforms.rockHigh !=
+        if (m_terrainPipeline->m_terrainUniforms.rock_high !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.rockHigh,
-              terrain.params.rockHigh);
+              m_terrainPipeline->m_terrainUniforms.rock_high,
+              terrain.params.rock_high);
         }
         if (m_terrainPipeline->m_terrainUniforms.tint !=
             Shader::InvalidUniform) {
           active_shader->setUniform(m_terrainPipeline->m_terrainUniforms.tint,
                                     terrain.params.tint);
         }
-        if (m_terrainPipeline->m_terrainUniforms.noiseOffset !=
+        if (m_terrainPipeline->m_terrainUniforms.noise_offset !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.noiseOffset,
-              terrain.params.noiseOffset);
+              m_terrainPipeline->m_terrainUniforms.noise_offset,
+              terrain.params.noise_offset);
         }
         if (m_terrainPipeline->m_terrainUniforms.tile_size !=
             Shader::InvalidUniform) {
@@ -937,65 +937,65 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
               m_terrainPipeline->m_terrainUniforms.tile_size,
               terrain.params.tile_size);
         }
-        if (m_terrainPipeline->m_terrainUniforms.macroNoiseScale !=
+        if (m_terrainPipeline->m_terrainUniforms.macro_noise_scale !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.macroNoiseScale,
-              terrain.params.macroNoiseScale);
+              m_terrainPipeline->m_terrainUniforms.macro_noise_scale,
+              terrain.params.macro_noise_scale);
         }
-        if (m_terrainPipeline->m_terrainUniforms.detail_noiseScale !=
+        if (m_terrainPipeline->m_terrainUniforms.detail_noise_scale !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.detail_noiseScale,
-              terrain.params.detail_noiseScale);
+              m_terrainPipeline->m_terrainUniforms.detail_noise_scale,
+              terrain.params.detail_noise_scale);
         }
-        if (m_terrainPipeline->m_terrainUniforms.slopeRockThreshold !=
+        if (m_terrainPipeline->m_terrainUniforms.slope_rock_threshold !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.slopeRockThreshold,
-              terrain.params.slopeRockThreshold);
+              m_terrainPipeline->m_terrainUniforms.slope_rock_threshold,
+              terrain.params.slope_rock_threshold);
         }
-        if (m_terrainPipeline->m_terrainUniforms.slopeRockSharpness !=
+        if (m_terrainPipeline->m_terrainUniforms.slope_rock_sharpness !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.slopeRockSharpness,
-              terrain.params.slopeRockSharpness);
+              m_terrainPipeline->m_terrainUniforms.slope_rock_sharpness,
+              terrain.params.slope_rock_sharpness);
         }
-        if (m_terrainPipeline->m_terrainUniforms.soilBlendHeight !=
+        if (m_terrainPipeline->m_terrainUniforms.soil_blend_height !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.soilBlendHeight,
-              terrain.params.soilBlendHeight);
+              m_terrainPipeline->m_terrainUniforms.soil_blend_height,
+              terrain.params.soil_blend_height);
         }
-        if (m_terrainPipeline->m_terrainUniforms.soilBlendSharpness !=
+        if (m_terrainPipeline->m_terrainUniforms.soil_blend_sharpness !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.soilBlendSharpness,
-              terrain.params.soilBlendSharpness);
+              m_terrainPipeline->m_terrainUniforms.soil_blend_sharpness,
+              terrain.params.soil_blend_sharpness);
         }
-        if (m_terrainPipeline->m_terrainUniforms.heightNoiseStrength !=
+        if (m_terrainPipeline->m_terrainUniforms.height_noise_strength !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.heightNoiseStrength,
-              terrain.params.heightNoiseStrength);
+              m_terrainPipeline->m_terrainUniforms.height_noise_strength,
+              terrain.params.height_noise_strength);
         }
-        if (m_terrainPipeline->m_terrainUniforms.heightNoiseFrequency !=
+        if (m_terrainPipeline->m_terrainUniforms.height_noise_frequency !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.heightNoiseFrequency,
-              terrain.params.heightNoiseFrequency);
+              m_terrainPipeline->m_terrainUniforms.height_noise_frequency,
+              terrain.params.height_noise_frequency);
         }
-        if (m_terrainPipeline->m_terrainUniforms.ambientBoost !=
+        if (m_terrainPipeline->m_terrainUniforms.ambient_boost !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.ambientBoost,
-              terrain.params.ambientBoost);
+              m_terrainPipeline->m_terrainUniforms.ambient_boost,
+              terrain.params.ambient_boost);
         }
-        if (m_terrainPipeline->m_terrainUniforms.rockDetailStrength !=
+        if (m_terrainPipeline->m_terrainUniforms.rock_detail_strength !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.rockDetailStrength,
-              terrain.params.rockDetailStrength);
+              m_terrainPipeline->m_terrainUniforms.rock_detail_strength,
+              terrain.params.rock_detail_strength);
         }
         if (m_terrainPipeline->m_terrainUniforms.light_dir !=
             Shader::InvalidUniform) {
@@ -1006,48 +1006,48 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           active_shader->setUniform(
               m_terrainPipeline->m_terrainUniforms.light_dir, light_dir);
         }
-        // Ground-type-specific uniforms
-        if (m_terrainPipeline->m_terrainUniforms.snowCoverage !=
+
+        if (m_terrainPipeline->m_terrainUniforms.snow_coverage !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.snowCoverage,
-              terrain.params.snowCoverage);
+              m_terrainPipeline->m_terrainUniforms.snow_coverage,
+              terrain.params.snow_coverage);
         }
-        if (m_terrainPipeline->m_terrainUniforms.moistureLevel !=
+        if (m_terrainPipeline->m_terrainUniforms.moisture_level !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.moistureLevel,
-              terrain.params.moistureLevel);
+              m_terrainPipeline->m_terrainUniforms.moisture_level,
+              terrain.params.moisture_level);
         }
-        if (m_terrainPipeline->m_terrainUniforms.crackIntensity !=
+        if (m_terrainPipeline->m_terrainUniforms.crack_intensity !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.crackIntensity,
-              terrain.params.crackIntensity);
+              m_terrainPipeline->m_terrainUniforms.crack_intensity,
+              terrain.params.crack_intensity);
         }
-        if (m_terrainPipeline->m_terrainUniforms.rockExposure !=
+        if (m_terrainPipeline->m_terrainUniforms.rock_exposure !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.rockExposure,
-              terrain.params.rockExposure);
+              m_terrainPipeline->m_terrainUniforms.rock_exposure,
+              terrain.params.rock_exposure);
         }
-        if (m_terrainPipeline->m_terrainUniforms.grassSaturation !=
+        if (m_terrainPipeline->m_terrainUniforms.grass_saturation !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.grassSaturation,
-              terrain.params.grassSaturation);
+              m_terrainPipeline->m_terrainUniforms.grass_saturation,
+              terrain.params.grass_saturation);
         }
-        if (m_terrainPipeline->m_terrainUniforms.soilRoughness !=
+        if (m_terrainPipeline->m_terrainUniforms.soil_roughness !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.soilRoughness,
-              terrain.params.soilRoughness);
+              m_terrainPipeline->m_terrainUniforms.soil_roughness,
+              terrain.params.soil_roughness);
         }
-        if (m_terrainPipeline->m_terrainUniforms.snowColor !=
+        if (m_terrainPipeline->m_terrainUniforms.snow_color !=
             Shader::InvalidUniform) {
           active_shader->setUniform(
-              m_terrainPipeline->m_terrainUniforms.snowColor,
-              terrain.params.snowColor);
+              m_terrainPipeline->m_terrainUniforms.snow_color,
+              terrain.params.snow_color);
         }
       }
 

render/gl/backend/terrain_pipeline.cpp

@@ -70,9 +70,10 @@ void TerrainPipeline::cacheGrassUniforms() {
 
   m_grassUniforms.view_proj = m_grassShader->uniformHandle("u_viewProj");
   m_grassUniforms.time = m_grassShader->uniformHandle("u_time");
-  m_grassUniforms.windStrength = m_grassShader->uniformHandle("u_windStrength");
-  m_grassUniforms.windSpeed = m_grassShader->uniformHandle("u_windSpeed");
-  m_grassUniforms.soilColor = m_grassShader->uniformHandle("u_soilColor");
+  m_grassUniforms.wind_strength =
+      m_grassShader->uniformHandle("u_windStrength");
+  m_grassUniforms.wind_speed = m_grassShader->uniformHandle("u_windSpeed");
+  m_grassUniforms.soil_color = m_grassShader->uniformHandle("u_soilColor");
   m_grassUniforms.light_dir = m_grassShader->uniformHandle("u_lightDir");
 }
 
@@ -83,44 +84,45 @@ void TerrainPipeline::cacheGroundUniforms() {
 
   m_groundUniforms.mvp = m_groundShader->uniformHandle("u_mvp");
   m_groundUniforms.model = m_groundShader->uniformHandle("u_model");
-  m_groundUniforms.grassPrimary =
+  m_groundUniforms.grass_primary =
       m_groundShader->uniformHandle("u_grassPrimary");
-  m_groundUniforms.grassSecondary =
+  m_groundUniforms.grass_secondary =
       m_groundShader->uniformHandle("u_grassSecondary");
-  m_groundUniforms.grassDry = m_groundShader->uniformHandle("u_grassDry");
-  m_groundUniforms.soilColor = m_groundShader->uniformHandle("u_soilColor");
+  m_groundUniforms.grass_dry = m_groundShader->uniformHandle("u_grassDry");
+  m_groundUniforms.soil_color = m_groundShader->uniformHandle("u_soilColor");
   m_groundUniforms.tint = m_groundShader->uniformHandle("u_tint");
-  m_groundUniforms.noiseOffset = m_groundShader->uniformHandle("u_noiseOffset");
+  m_groundUniforms.noise_offset =
+      m_groundShader->uniformHandle("u_noiseOffset");
   m_groundUniforms.tile_size = m_groundShader->uniformHandle("u_tileSize");
-  m_groundUniforms.macroNoiseScale =
+  m_groundUniforms.macro_noise_scale =
       m_groundShader->uniformHandle("u_macroNoiseScale");
-  m_groundUniforms.detail_noiseScale =
+  m_groundUniforms.detail_noise_scale =
       m_groundShader->uniformHandle("u_detailNoiseScale");
-  m_groundUniforms.soilBlendHeight =
+  m_groundUniforms.soil_blend_height =
       m_groundShader->uniformHandle("u_soilBlendHeight");
-  m_groundUniforms.soilBlendSharpness =
+  m_groundUniforms.soil_blend_sharpness =
       m_groundShader->uniformHandle("u_soilBlendSharpness");
-  m_groundUniforms.heightNoiseStrength =
+  m_groundUniforms.height_noise_strength =
       m_groundShader->uniformHandle("u_heightNoiseStrength");
-  m_groundUniforms.heightNoiseFrequency =
+  m_groundUniforms.height_noise_frequency =
       m_groundShader->uniformHandle("u_heightNoiseFrequency");
-  m_groundUniforms.ambientBoost =
+  m_groundUniforms.ambient_boost =
       m_groundShader->uniformHandle("u_ambientBoost");
   m_groundUniforms.light_dir = m_groundShader->uniformHandle("u_lightDir");
-  // Ground-type-specific uniforms
-  m_groundUniforms.snowCoverage =
+
+  m_groundUniforms.snow_coverage =
       m_groundShader->uniformHandle("u_snowCoverage");
-  m_groundUniforms.moistureLevel =
+  m_groundUniforms.moisture_level =
       m_groundShader->uniformHandle("u_moistureLevel");
-  m_groundUniforms.crackIntensity =
+  m_groundUniforms.crack_intensity =
       m_groundShader->uniformHandle("u_crackIntensity");
-  m_groundUniforms.rockExposure =
+  m_groundUniforms.rock_exposure =
       m_groundShader->uniformHandle("u_rockExposure");
-  m_groundUniforms.grassSaturation =
+  m_groundUniforms.grass_saturation =
       m_groundShader->uniformHandle("u_grassSaturation");
-  m_groundUniforms.soilRoughness =
+  m_groundUniforms.soil_roughness =
       m_groundShader->uniformHandle("u_soilRoughness");
-  m_groundUniforms.snowColor = m_groundShader->uniformHandle("u_snowColor");
+  m_groundUniforms.snow_color = m_groundShader->uniformHandle("u_snowColor");
 }
 
 void TerrainPipeline::cacheTerrainUniforms() {
@@ -130,53 +132,53 @@ void TerrainPipeline::cacheTerrainUniforms() {
 
   m_terrainUniforms.mvp = m_terrainShader->uniformHandle("u_mvp");
   m_terrainUniforms.model = m_terrainShader->uniformHandle("u_model");
-  m_terrainUniforms.grassPrimary =
+  m_terrainUniforms.grass_primary =
       m_terrainShader->uniformHandle("u_grassPrimary");
-  m_terrainUniforms.grassSecondary =
+  m_terrainUniforms.grass_secondary =
       m_terrainShader->uniformHandle("u_grassSecondary");
-  m_terrainUniforms.grassDry = m_terrainShader->uniformHandle("u_grassDry");
-  m_terrainUniforms.soilColor = m_terrainShader->uniformHandle("u_soilColor");
-  m_terrainUniforms.rockLow = m_terrainShader->uniformHandle("u_rockLow");
-  m_terrainUniforms.rockHigh = m_terrainShader->uniformHandle("u_rockHigh");
+  m_terrainUniforms.grass_dry = m_terrainShader->uniformHandle("u_grassDry");
+  m_terrainUniforms.soil_color = m_terrainShader->uniformHandle("u_soilColor");
+  m_terrainUniforms.rock_low = m_terrainShader->uniformHandle("u_rockLow");
+  m_terrainUniforms.rock_high = m_terrainShader->uniformHandle("u_rockHigh");
   m_terrainUniforms.tint = m_terrainShader->uniformHandle("u_tint");
-  m_terrainUniforms.noiseOffset =
+  m_terrainUniforms.noise_offset =
       m_terrainShader->uniformHandle("u_noiseOffset");
   m_terrainUniforms.tile_size = m_terrainShader->uniformHandle("u_tileSize");
-  m_terrainUniforms.macroNoiseScale =
+  m_terrainUniforms.macro_noise_scale =
       m_terrainShader->uniformHandle("u_macroNoiseScale");
-  m_terrainUniforms.detail_noiseScale =
+  m_terrainUniforms.detail_noise_scale =
       m_terrainShader->uniformHandle("u_detailNoiseScale");
-  m_terrainUniforms.slopeRockThreshold =
+  m_terrainUniforms.slope_rock_threshold =
       m_terrainShader->uniformHandle("u_slopeRockThreshold");
-  m_terrainUniforms.slopeRockSharpness =
+  m_terrainUniforms.slope_rock_sharpness =
       m_terrainShader->uniformHandle("u_slopeRockSharpness");
-  m_terrainUniforms.soilBlendHeight =
+  m_terrainUniforms.soil_blend_height =
       m_terrainShader->uniformHandle("u_soilBlendHeight");
-  m_terrainUniforms.soilBlendSharpness =
+  m_terrainUniforms.soil_blend_sharpness =
       m_terrainShader->uniformHandle("u_soilBlendSharpness");
-  m_terrainUniforms.heightNoiseStrength =
+  m_terrainUniforms.height_noise_strength =
       m_terrainShader->uniformHandle("u_heightNoiseStrength");
-  m_terrainUniforms.heightNoiseFrequency =
+  m_terrainUniforms.height_noise_frequency =
       m_terrainShader->uniformHandle("u_heightNoiseFrequency");
-  m_terrainUniforms.ambientBoost =
+  m_terrainUniforms.ambient_boost =
       m_terrainShader->uniformHandle("u_ambientBoost");
-  m_terrainUniforms.rockDetailStrength =
+  m_terrainUniforms.rock_detail_strength =
       m_terrainShader->uniformHandle("u_rockDetailStrength");
   m_terrainUniforms.light_dir = m_terrainShader->uniformHandle("u_lightDir");
-  // Ground-type-specific uniforms
-  m_terrainUniforms.snowCoverage =
+
+  m_terrainUniforms.snow_coverage =
       m_terrainShader->uniformHandle("u_snowCoverage");
-  m_terrainUniforms.moistureLevel =
+  m_terrainUniforms.moisture_level =
       m_terrainShader->uniformHandle("u_moistureLevel");
-  m_terrainUniforms.crackIntensity =
+  m_terrainUniforms.crack_intensity =
       m_terrainShader->uniformHandle("u_crackIntensity");
-  m_terrainUniforms.rockExposure =
+  m_terrainUniforms.rock_exposure =
       m_terrainShader->uniformHandle("u_rockExposure");
-  m_terrainUniforms.grassSaturation =
+  m_terrainUniforms.grass_saturation =
       m_terrainShader->uniformHandle("u_grassSaturation");
-  m_terrainUniforms.soilRoughness =
+  m_terrainUniforms.soil_roughness =
       m_terrainShader->uniformHandle("u_soilRoughness");
-  m_terrainUniforms.snowColor = m_terrainShader->uniformHandle("u_snowColor");
+  m_terrainUniforms.snow_color = m_terrainShader->uniformHandle("u_snowColor");
 }
 
 void TerrainPipeline::initializeGrassGeometry() {

render/gl/backend/terrain_pipeline.h

@@ -26,71 +26,73 @@ public:
   struct GrassUniforms {
     GL::Shader::UniformHandle view_proj{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle time{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windStrength{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windSpeed{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilColor{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_strength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_speed{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_color{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle light_dir{GL::Shader::InvalidUniform};
   };
 
   struct GroundUniforms {
     GL::Shader::UniformHandle mvp{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle model{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassPrimary{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassSecondary{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassDry{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilColor{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_primary{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_secondary{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_dry{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_color{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle tint{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle noiseOffset{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle noise_offset{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle tile_size{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle macroNoiseScale{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle detail_noiseScale{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilBlendHeight{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilBlendSharpness{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle heightNoiseStrength{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle heightNoiseFrequency{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle ambientBoost{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle macro_noise_scale{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle detail_noise_scale{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_blend_height{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_blend_sharpness{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle height_noise_strength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle height_noise_frequency{
+        GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle ambient_boost{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle light_dir{GL::Shader::InvalidUniform};
-    // Ground-type-specific uniforms
-    GL::Shader::UniformHandle snowCoverage{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle moistureLevel{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle crackIntensity{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle rockExposure{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassSaturation{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilRoughness{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle snowColor{GL::Shader::InvalidUniform};
+
+    GL::Shader::UniformHandle snow_coverage{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle moisture_level{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle crack_intensity{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle rock_exposure{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_saturation{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_roughness{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle snow_color{GL::Shader::InvalidUniform};
   };
 
   struct TerrainUniforms {
     GL::Shader::UniformHandle mvp{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle model{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassPrimary{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassSecondary{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassDry{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilColor{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle rockLow{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle rockHigh{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_primary{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_secondary{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_dry{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_color{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle rock_low{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle rock_high{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle tint{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle noiseOffset{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle noise_offset{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle tile_size{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle macroNoiseScale{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle detail_noiseScale{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle slopeRockThreshold{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle slopeRockSharpness{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilBlendHeight{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilBlendSharpness{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle heightNoiseStrength{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle heightNoiseFrequency{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle ambientBoost{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle rockDetailStrength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle macro_noise_scale{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle detail_noise_scale{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle slope_rock_threshold{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle slope_rock_sharpness{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_blend_height{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_blend_sharpness{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle height_noise_strength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle height_noise_frequency{
+        GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle ambient_boost{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle rock_detail_strength{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle light_dir{GL::Shader::InvalidUniform};
-    // Ground-type-specific uniforms
-    GL::Shader::UniformHandle snowCoverage{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle moistureLevel{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle crackIntensity{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle rockExposure{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle grassSaturation{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle soilRoughness{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle snowColor{GL::Shader::InvalidUniform};
+
+    GL::Shader::UniformHandle snow_coverage{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle moisture_level{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle crack_intensity{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle rock_exposure{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle grass_saturation{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle soil_roughness{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle snow_color{GL::Shader::InvalidUniform};
   };
 
   GL::Shader *m_grassShader = nullptr;

render/gl/backend/vegetation_pipeline.cpp

@@ -78,9 +78,9 @@ void VegetationPipeline::cacheUniforms() {
   if (m_plantShader != nullptr) {
     m_plantUniforms.view_proj = m_plantShader->uniformHandle("uViewProj");
     m_plantUniforms.time = m_plantShader->uniformHandle("uTime");
-    m_plantUniforms.windStrength =
+    m_plantUniforms.wind_strength =
         m_plantShader->uniformHandle("uWindStrength");
-    m_plantUniforms.windSpeed = m_plantShader->uniformHandle("uWindSpeed");
+    m_plantUniforms.wind_speed = m_plantShader->uniformHandle("uWindSpeed");
     m_plantUniforms.light_direction =
         m_plantShader->uniformHandle("uLightDirection");
   }
@@ -88,8 +88,8 @@ void VegetationPipeline::cacheUniforms() {
   if (m_pineShader != nullptr) {
     m_pineUniforms.view_proj = m_pineShader->uniformHandle("uViewProj");
     m_pineUniforms.time = m_pineShader->uniformHandle("uTime");
-    m_pineUniforms.windStrength = m_pineShader->uniformHandle("uWindStrength");
-    m_pineUniforms.windSpeed = m_pineShader->uniformHandle("uWindSpeed");
+    m_pineUniforms.wind_strength = m_pineShader->uniformHandle("uWindStrength");
+    m_pineUniforms.wind_speed = m_pineShader->uniformHandle("uWindSpeed");
     m_pineUniforms.light_direction =
         m_pineShader->uniformHandle("uLightDirection");
   }

render/gl/backend/vegetation_pipeline.h

@@ -39,16 +39,16 @@ public:
   struct PlantUniforms {
     GL::Shader::UniformHandle view_proj{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle time{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windStrength{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windSpeed{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_strength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_speed{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle light_direction{GL::Shader::InvalidUniform};
   } m_plantUniforms;
 
   struct PineUniforms {
     GL::Shader::UniformHandle view_proj{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle time{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windStrength{GL::Shader::InvalidUniform};
-    GL::Shader::UniformHandle windSpeed{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_strength{GL::Shader::InvalidUniform};
+    GL::Shader::UniformHandle wind_speed{GL::Shader::InvalidUniform};
     GL::Shader::UniformHandle light_direction{GL::Shader::InvalidUniform};
   } m_pineUniforms;
 

render/ground/biome_renderer.cpp

@@ -77,9 +77,9 @@ void BiomeRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
   m_grassInstanceCount = 0;
   m_grassInstancesDirty = false;
 
-  m_grassParams.soilColor = m_biomeSettings.soilColor;
-  m_grassParams.windStrength = m_biomeSettings.sway_strength;
-  m_grassParams.windSpeed = m_biomeSettings.sway_speed;
+  m_grassParams.soil_color = m_biomeSettings.soil_color;
+  m_grassParams.wind_strength = m_biomeSettings.sway_strength;
+  m_grassParams.wind_speed = m_biomeSettings.sway_speed;
   m_grassParams.light_direction = QVector3D(0.35F, 0.8F, 0.45F);
   m_grassParams.time = 0.0F;
 
@@ -130,7 +130,7 @@ void BiomeRenderer::generateGrassInstances() {
     return;
   }
 
-  if (m_biomeSettings.patchDensity < 0.01F) {
+  if (m_biomeSettings.patch_density < 0.01F) {
     m_grassInstanceCount = 0;
     m_grassInstancesDirty = false;
     return;
@@ -141,7 +141,7 @@ void BiomeRenderer::generateGrassInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawnEdgePadding, 0.0F, 0.5F);
+      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -262,16 +262,16 @@ void BiomeRenderer::generateGrassInstances() {
     float const dryness =
         std::clamp(dryness_noise * 0.6F + slope * 0.4F, 0.0F, 1.0F);
     QVector3D const lush_mix =
-        m_biomeSettings.grassPrimary * (1.0F - lush_noise) +
-        m_biomeSettings.grassSecondary * lush_noise;
+        m_biomeSettings.grass_primary * (1.0F - lush_noise) +
+        m_biomeSettings.grass_secondary * lush_noise;
     QVector3D const color =
-        lush_mix * (1.0F - dryness) + m_biomeSettings.grassDry * dryness;
+        lush_mix * (1.0F - dryness) + m_biomeSettings.grass_dry * dryness;
 
-    float const height = remap(rand_01(state), m_biomeSettings.bladeHeightMin,
-                               m_biomeSettings.bladeHeightMax) *
+    float const height = remap(rand_01(state), m_biomeSettings.blade_height_min,
+                               m_biomeSettings.blade_height_max) *
                          tile_safe * 0.5F;
-    float const width = remap(rand_01(state), m_biomeSettings.bladeWidthMin,
-                              m_biomeSettings.bladeWidthMax) *
+    float const width = remap(rand_01(state), m_biomeSettings.blade_width_min,
+                              m_biomeSettings.blade_width_max) *
                         tile_safe;
 
     float const sway_strength = remap(rand_01(state), 0.75F, 1.25F);
@@ -376,7 +376,7 @@ void BiomeRenderer::generateGrassInstances() {
       float const type_bias = 1.0F;
       constexpr float k_cluster_boost = 1.35F;
       float const expected_clusters =
-          std::max(0.0F, m_biomeSettings.patchDensity * k_cluster_boost *
+          std::max(0.0F, m_biomeSettings.patch_density * k_cluster_boost *
                              slope_penalty * type_bias * usable_coverage);
       int cluster_count = static_cast<int>(std::floor(expected_clusters));
       float const frac = expected_clusters - float(cluster_count);
@@ -387,7 +387,8 @@ void BiomeRenderer::generateGrassInstances() {
       if (cluster_count > 0) {
         auto chunk_span_x = float(chunk_max_x - chunk_x + 1);
         auto chunk_span_z = float(chunk_max_z - chunk_z + 1);
-        float const scatter_base = std::max(0.25F, m_biomeSettings.patchJitter);
+        float const scatter_base =
+            std::max(0.25F, m_biomeSettings.patch_jitter);
 
         auto pick_cluster_center =
             [&](uint32_t &rng) -> std::optional<QVector2D> {
@@ -449,7 +450,7 @@ void BiomeRenderer::generateGrassInstances() {
   }
 
   const float background_density =
-      std::max(0.0F, m_biomeSettings.backgroundBladeDensity);
+      std::max(0.0F, m_biomeSettings.background_blade_density);
   if (background_density > 0.0F) {
     for (int z = 0; z < m_height; ++z) {
       for (int x = 0; x < m_width; ++x) {

render/ground/firecamp_renderer.cpp

@@ -242,7 +242,7 @@ void FireCampRenderer::generateFireCampInstances() {
   const float tile_safe = std::max(0.1F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawnEdgePadding, 0.0F, 0.5F);
+      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 

render/ground/grass_gpu.h

@@ -21,18 +21,18 @@ struct GrassBatchParams {
   static constexpr float kDefaultLightDirZ = 0.45F;
   static constexpr float kDefaultWindSpeed = 1.4F;
 
-  static auto defaultSoilColor() -> QVector3D {
+  static auto default_soil_color() -> QVector3D {
     return {kDefaultSoilColorR, kDefaultSoilColorG, kDefaultSoilColorB};
   }
 
-  static auto defaultLightDirection() -> QVector3D {
+  static auto default_light_direction() -> QVector3D {
     return {kDefaultLightDirX, kDefaultLightDirY, kDefaultLightDirZ};
   }
 
-  QVector3D soilColor = defaultSoilColor();
-  float windStrength{kDefaultWindStrength};
-  QVector3D light_direction = defaultLightDirection();
-  float windSpeed{kDefaultWindSpeed};
+  QVector3D soil_color = default_soil_color();
+  float wind_strength{kDefaultWindStrength};
+  QVector3D light_direction = default_light_direction();
+  float wind_speed{kDefaultWindSpeed};
   float time{0.0F};
   float pad0{0.0F};
   float pad1{0.0F};

render/ground/ground_renderer.cpp

@@ -64,80 +64,83 @@ auto GroundRenderer::buildParams() const -> TerrainChunkParams {
 
   TerrainChunkParams params;
 
-  const QVector3D primary = m_biomeSettings.grassPrimary * 0.97F;
-  const QVector3D secondary = m_biomeSettings.grassSecondary * 0.93F;
-  const QVector3D dry = m_biomeSettings.grassDry * 0.90F;
-  const QVector3D soil = m_biomeSettings.soilColor * 0.68F;
-
-  params.grassPrimary = saturate(primary);
-  params.grassSecondary = saturate(secondary);
-  params.grassDry = saturate(dry);
-  params.soilColor = saturate(soil);
-  params.rockLow = saturate(m_biomeSettings.rockLow);
-  params.rockHigh = saturate(m_biomeSettings.rockHigh);
+  const QVector3D primary = m_biomeSettings.grass_primary * 0.97F;
+  const QVector3D secondary = m_biomeSettings.grass_secondary * 0.93F;
+  const QVector3D dry = m_biomeSettings.grass_dry * 0.90F;
+  const QVector3D soil = m_biomeSettings.soil_color * 0.68F;
+
+  params.grass_primary = saturate(primary);
+  params.grass_secondary = saturate(secondary);
+  params.grass_dry = saturate(dry);
+  params.soil_color = saturate(soil);
+  params.rock_low = saturate(m_biomeSettings.rock_low);
+  params.rock_high = saturate(m_biomeSettings.rock_high);
 
   params.tint = QVector3D(0.96F, 0.98F, 0.96F);
 
   params.tile_size = std::max(0.25F, m_tile_size);
 
-  params.macroNoiseScale =
-      std::max(0.012F, m_biomeSettings.terrainMacroNoiseScale * 0.60F);
-  params.detail_noiseScale =
-      std::max(0.045F, m_biomeSettings.terrainDetailNoiseScale * 0.75F);
+  params.macro_noise_scale =
+      std::max(0.012F, m_biomeSettings.terrain_macro_noise_scale * 0.60F);
+  params.detail_noise_scale =
+      std::max(0.045F, m_biomeSettings.terrain_detail_noise_scale * 0.75F);
 
-  params.slopeRockThreshold =
-      std::clamp(m_biomeSettings.terrainRockThreshold + 0.30F, 0.40F, 0.90F);
-  params.slopeRockSharpness =
-      std::clamp(m_biomeSettings.terrainRockSharpness + 1.5F, 2.0F, 6.0F);
+  params.slope_rock_threshold =
+      std::clamp(m_biomeSettings.terrain_rock_threshold + 0.30F, 0.40F, 0.90F);
+  params.slope_rock_sharpness =
+      std::clamp(m_biomeSettings.terrain_rock_sharpness + 1.5F, 2.0F, 6.0F);
 
-  params.soilBlendHeight = m_biomeSettings.terrainSoilHeight - 1.25F;
-  params.soilBlendSharpness =
-      std::clamp(m_biomeSettings.terrainSoilSharpness * 0.75F, 1.5F, 5.0F);
+  params.soil_blend_height = m_biomeSettings.terrain_soil_height - 1.25F;
+  params.soil_blend_sharpness =
+      std::clamp(m_biomeSettings.terrain_soil_sharpness * 0.75F, 1.5F, 5.0F);
 
-  params.noiseOffset = m_noiseOffset;
-  params.noiseAngle = m_noiseAngle;
+  params.noise_offset = m_noiseOffset;
+  params.noise_angle = m_noiseAngle;
 
   float target_amp;
   float target_freq;
-  if (m_biomeSettings.groundIrregularityEnabled) {
+  if (m_biomeSettings.ground_irregularity_enabled) {
 
-    target_amp =
-        std::clamp(m_biomeSettings.irregularityAmplitude * 0.85F, 0.15F, 0.70F);
-    target_freq = std::max(0.45F, m_biomeSettings.irregularityScale * 2.5F);
+    target_amp = std::clamp(m_biomeSettings.irregularity_amplitude * 0.85F,
+                            0.15F, 0.70F);
+    target_freq = std::max(0.45F, m_biomeSettings.irregularity_scale * 2.5F);
   } else {
 
-    target_amp =
-        std::clamp(m_biomeSettings.heightNoiseAmplitude * 0.22F, 0.10F, 0.20F);
-    target_freq = std::max(0.6F, m_biomeSettings.heightNoiseFrequency * 1.05F);
+    target_amp = std::clamp(m_biomeSettings.height_noise_amplitude * 0.22F,
+                            0.10F, 0.20F);
+    target_freq =
+        std::max(0.6F, m_biomeSettings.height_noise_frequency * 1.05F);
   }
-  params.heightNoiseStrength = target_amp;
-  params.heightNoiseFrequency = target_freq;
+  params.height_noise_strength = target_amp;
+  params.height_noise_frequency = target_freq;
 
-  params.microBumpAmp = 0.07F;
-  params.microBumpFreq = 2.2F;
-  params.microNormalWeight = 0.65F;
+  params.micro_bump_amp = 0.07F;
+  params.micro_bump_freq = 2.2F;
+  params.micro_normal_weight = 0.65F;
 
-  params.albedoJitter = 0.05F;
+  params.albedo_jitter = 0.05F;
 
-  params.ambientBoost = m_biomeSettings.terrainAmbientBoost * 0.85F;
+  params.ambient_boost = m_biomeSettings.terrain_ambient_boost * 0.85F;
 
-  params.rockDetailStrength = m_biomeSettings.terrainRockDetailStrength * 0.18F;
+  params.rock_detail_strength =
+      m_biomeSettings.terrain_rock_detail_strength * 0.18F;
 
   QVector3D const l(0.35F, 0.85F, 0.42F);
   params.light_direction = l.normalized();
 
-  params.isGroundPlane = true;
+  params.is_ground_plane = true;
 
-  // Ground-type-specific shader parameters
-  params.snowCoverage = std::clamp(m_biomeSettings.snowCoverage, 0.0F, 1.0F);
-  params.moistureLevel = std::clamp(m_biomeSettings.moistureLevel, 0.0F, 1.0F);
-  params.crackIntensity =
-      std::clamp(m_biomeSettings.crackIntensity, 0.0F, 1.0F);
-  params.rockExposure = std::clamp(m_biomeSettings.rockExposure, 0.0F, 1.0F);
-  params.grassSaturation =
-      std::clamp(m_biomeSettings.grassSaturation, 0.0F, 1.5F);
-  params.soilRoughness = std::clamp(m_biomeSettings.soilRoughness, 0.0F, 1.0F);
-  params.snowColor = saturate(m_biomeSettings.snowColor);
+  params.snow_coverage = std::clamp(m_biomeSettings.snow_coverage, 0.0F, 1.0F);
+  params.moisture_level =
+      std::clamp(m_biomeSettings.moisture_level, 0.0F, 1.0F);
+  params.crack_intensity =
+      std::clamp(m_biomeSettings.crack_intensity, 0.0F, 1.0F);
+  params.rock_exposure = std::clamp(m_biomeSettings.rock_exposure, 0.0F, 1.0F);
+  params.grass_saturation =
+      std::clamp(m_biomeSettings.grass_saturation, 0.0F, 1.5F);
+  params.soil_roughness =
+      std::clamp(m_biomeSettings.soil_roughness, 0.0F, 1.0F);
+  params.snow_color = saturate(m_biomeSettings.snow_color);
 
   m_cachedParams = params;
   m_cachedParamsValid = true;
@@ -195,29 +198,29 @@ void GroundRenderer::syncBiomeFromService() {
 
 auto GroundRenderer::biomeEquals(const Game::Map::BiomeSettings &a,
                                  const Game::Map::BiomeSettings &b) -> bool {
-  return a.groundType == b.groundType && a.grassPrimary == b.grassPrimary &&
-         a.grassSecondary == b.grassSecondary && a.grassDry == b.grassDry &&
-         a.soilColor == b.soilColor && a.rockLow == b.rockLow &&
-         a.rockHigh == b.rockHigh &&
-         a.terrainMacroNoiseScale == b.terrainMacroNoiseScale &&
-         a.terrainDetailNoiseScale == b.terrainDetailNoiseScale &&
-         a.terrainSoilHeight == b.terrainSoilHeight &&
-         a.terrainSoilSharpness == b.terrainSoilSharpness &&
-         a.terrainRockThreshold == b.terrainRockThreshold &&
-         a.terrainRockSharpness == b.terrainRockSharpness &&
-         a.terrainAmbientBoost == b.terrainAmbientBoost &&
-         a.terrainRockDetailStrength == b.terrainRockDetailStrength &&
-         a.heightNoiseAmplitude == b.heightNoiseAmplitude &&
-         a.heightNoiseFrequency == b.heightNoiseFrequency &&
-         a.groundIrregularityEnabled == b.groundIrregularityEnabled &&
-         a.irregularityScale == b.irregularityScale &&
-         a.irregularityAmplitude == b.irregularityAmplitude &&
-         a.seed == b.seed && a.snowCoverage == b.snowCoverage &&
-         a.moistureLevel == b.moistureLevel &&
-         a.crackIntensity == b.crackIntensity &&
-         a.rockExposure == b.rockExposure &&
-         a.grassSaturation == b.grassSaturation &&
-         a.soilRoughness == b.soilRoughness && a.snowColor == b.snowColor;
+  return a.ground_type == b.ground_type && a.grass_primary == b.grass_primary &&
+         a.grass_secondary == b.grass_secondary && a.grass_dry == b.grass_dry &&
+         a.soil_color == b.soil_color && a.rock_low == b.rock_low &&
+         a.rock_high == b.rock_high &&
+         a.terrain_macro_noise_scale == b.terrain_macro_noise_scale &&
+         a.terrain_detail_noise_scale == b.terrain_detail_noise_scale &&
+         a.terrain_soil_height == b.terrain_soil_height &&
+         a.terrain_soil_sharpness == b.terrain_soil_sharpness &&
+         a.terrain_rock_threshold == b.terrain_rock_threshold &&
+         a.terrain_rock_sharpness == b.terrain_rock_sharpness &&
+         a.terrain_ambient_boost == b.terrain_ambient_boost &&
+         a.terrain_rock_detail_strength == b.terrain_rock_detail_strength &&
+         a.height_noise_amplitude == b.height_noise_amplitude &&
+         a.height_noise_frequency == b.height_noise_frequency &&
+         a.ground_irregularity_enabled == b.ground_irregularity_enabled &&
+         a.irregularity_scale == b.irregularity_scale &&
+         a.irregularity_amplitude == b.irregularity_amplitude &&
+         a.seed == b.seed && a.snow_coverage == b.snow_coverage &&
+         a.moisture_level == b.moisture_level &&
+         a.crack_intensity == b.crack_intensity &&
+         a.rock_exposure == b.rock_exposure &&
+         a.grass_saturation == b.grass_saturation &&
+         a.soil_roughness == b.soil_roughness && a.snow_color == b.snow_color;
 }
 
 } // namespace Render::GL

render/ground/pine_gpu.h

@@ -19,14 +19,14 @@ struct PineBatchParams {
   static constexpr float kDefaultWindStrength = 0.3F;
   static constexpr float kDefaultWindSpeed = 0.5F;
 
-  static auto defaultLightDirection() -> QVector3D {
+  static auto default_light_direction() -> QVector3D {
     return {kDefaultLightDirX, kDefaultLightDirY, kDefaultLightDirZ};
   }
 
-  QVector3D light_direction = defaultLightDirection();
+  QVector3D light_direction = default_light_direction();
   float time = 0.0F;
-  float windStrength = kDefaultWindStrength;
-  float windSpeed = kDefaultWindSpeed;
+  float wind_strength = kDefaultWindStrength;
+  float wind_speed = kDefaultWindSpeed;
 };
 
 } // namespace Render::GL

render/ground/pine_renderer.cpp

@@ -61,8 +61,8 @@ void PineRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
 
   m_pineParams.light_direction = QVector3D(0.35F, 0.8F, 0.45F);
   m_pineParams.time = 0.0F;
-  m_pineParams.windStrength = 0.3F;
-  m_pineParams.windSpeed = 0.5F;
+  m_pineParams.wind_strength = 0.3F;
+  m_pineParams.wind_speed = 0.5F;
 
   generatePineInstances();
 }
@@ -130,7 +130,7 @@ void PineRenderer::generatePineInstances() {
   const float tile_safe = std::max(0.1F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawnEdgePadding, 0.0F, 0.5F);
+      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 

render/ground/plant_gpu.h

@@ -18,14 +18,14 @@ struct PlantBatchParams {
   static constexpr float kDefaultWindStrength = 0.25F;
   static constexpr float kDefaultWindSpeed = 1.4F;
 
-  static auto defaultLightDirection() -> QVector3D {
+  static auto default_light_direction() -> QVector3D {
     return {kDefaultLightDirX, kDefaultLightDirY, kDefaultLightDirZ};
   }
 
-  QVector3D light_direction = defaultLightDirection();
+  QVector3D light_direction = default_light_direction();
   float time = 0.0F;
-  float windStrength = kDefaultWindStrength;
-  float windSpeed = kDefaultWindSpeed;
+  float wind_strength = kDefaultWindStrength;
+  float wind_speed = kDefaultWindSpeed;
   float pad0 = 0.0F;
   float pad1 = 0.0F;
 };

render/ground/plant_renderer.cpp

@@ -61,8 +61,8 @@ void PlantRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
 
   m_plantParams.light_direction = QVector3D(0.35F, 0.8F, 0.45F);
   m_plantParams.time = 0.0F;
-  m_plantParams.windStrength = m_biomeSettings.sway_strength;
-  m_plantParams.windSpeed = m_biomeSettings.sway_speed;
+  m_plantParams.wind_strength = m_biomeSettings.sway_strength;
+  m_plantParams.wind_speed = m_biomeSettings.sway_speed;
 
   generatePlantInstances();
 }
@@ -158,7 +158,7 @@ void PlantRenderer::generatePlantInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawnEdgePadding, 0.0F, 0.5F);
+      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -268,8 +268,8 @@ void PlantRenderer::generatePlantInstances() {
     float const plant_type = std::floor(rand_01(state) * 4.0F);
 
     float const color_var = remap(rand_01(state), 0.0F, 1.0F);
-    QVector3D const base_color = m_biomeSettings.grassPrimary * 0.7F;
-    QVector3D const var_color = m_biomeSettings.grassSecondary * 0.8F;
+    QVector3D const base_color = m_biomeSettings.grass_primary * 0.7F;
+    QVector3D const var_color = m_biomeSettings.grass_secondary * 0.8F;
     QVector3D tint_color =
         base_color * (1.0F - color_var) + var_color * color_var;
 

render/ground/stone_renderer.cpp

@@ -111,7 +111,7 @@ void StoneRenderer::generateStoneInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawnEdgePadding, 0.0F, 0.5F);
+      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -212,8 +212,8 @@ void StoneRenderer::generateStoneInstances() {
     float const scale = remap(rand_01(state), 0.08F, 0.25F) * tile_safe;
 
     float const color_var = remap(rand_01(state), 0.0F, 1.0F);
-    QVector3D const base_rock = m_biomeSettings.rockLow;
-    QVector3D const high_rock = m_biomeSettings.rockHigh;
+    QVector3D const base_rock = m_biomeSettings.rock_low;
+    QVector3D const high_rock = m_biomeSettings.rock_high;
     QVector3D color = base_rock * (1.0F - color_var) + high_rock * color_var;
 
     float const brown_mix = remap(rand_01(state), 0.0F, 0.4F);

render/ground/terrain_gpu.h

@@ -43,7 +43,7 @@ struct TerrainChunkParams {
   static constexpr float kDefaultMicroBumpFreq = 2.2F;
   static constexpr float kDefaultMicroNormalWeight = 0.65F;
   static constexpr float kDefaultAlbedoJitter = 0.05F;
-  // Ground-type-specific defaults
+
   static constexpr float kDefaultSnowCoverage = 0.0F;
   static constexpr float kDefaultMoistureLevel = 0.5F;
   static constexpr float kDefaultCrackIntensity = 0.0F;
@@ -54,77 +54,76 @@ struct TerrainChunkParams {
   static constexpr float kDefaultSnowColorG = 0.94F;
   static constexpr float kDefaultSnowColorB = 0.98F;
 
-  static auto defaultGrassPrimary() -> QVector3D {
+  static auto default_grass_primary() -> QVector3D {
     return {kDefaultGrassPrimaryR, kDefaultGrassPrimaryG,
             kDefaultGrassPrimaryB};
   }
-  static auto defaultGrassSecondary() -> QVector3D {
+  static auto default_grass_secondary() -> QVector3D {
     return {kDefaultGrassSecondaryR, kDefaultGrassSecondaryG,
             kDefaultGrassSecondaryB};
   }
-  static auto defaultGrassDry() -> QVector3D {
+  static auto default_grass_dry() -> QVector3D {
     return {kDefaultGrassDryR, kDefaultGrassDryG, kDefaultGrassDryB};
   }
-  static auto defaultSoilColor() -> QVector3D {
+  static auto default_soil_color() -> QVector3D {
     return {kDefaultSoilColorR, kDefaultSoilColorG, kDefaultSoilColorB};
   }
-  static auto defaultRockLow() -> QVector3D {
+  static auto default_rock_low() -> QVector3D {
     return {kDefaultRockLowR, kDefaultRockLowG, kDefaultRockLowB};
   }
-  static auto defaultRockHigh() -> QVector3D {
+  static auto default_rock_high() -> QVector3D {
     return {kDefaultRockHighR, kDefaultRockHighG, kDefaultRockHighB};
   }
-  static auto defaultTint() -> QVector3D {
+  static auto default_tint() -> QVector3D {
     return {kDefaultTintComponent, kDefaultTintComponent,
             kDefaultTintComponent};
   }
-  static auto defaultLightDirection() -> QVector3D {
+  static auto default_light_direction() -> QVector3D {
     return {kDefaultLightDirX, kDefaultLightDirY, kDefaultLightDirZ};
   }
-  static auto defaultSnowColor() -> QVector3D {
+  static auto default_snow_color() -> QVector3D {
     return {kDefaultSnowColorR, kDefaultSnowColorG, kDefaultSnowColorB};
   }
 
-  QVector3D grassPrimary = defaultGrassPrimary();
+  QVector3D grass_primary = default_grass_primary();
   float tile_size = kDefaultTileSize;
-  QVector3D grassSecondary = defaultGrassSecondary();
-  float macroNoiseScale = kDefaultMacroNoiseScale;
-  QVector3D grassDry = defaultGrassDry();
-  float detail_noiseScale = kDefaultDetailNoiseScale;
-  QVector3D soilColor = defaultSoilColor();
-  float slopeRockThreshold = kDefaultSlopeRockThreshold;
-  QVector3D rockLow = defaultRockLow();
-  float slopeRockSharpness = kDefaultSlopeRockSharpness;
-  QVector3D rockHigh = defaultRockHigh();
-  float soilBlendHeight = kDefaultSoilBlendHeight;
-  QVector3D tint = defaultTint();
-  float soilBlendSharpness = kDefaultSoilBlendSharpness;
+  QVector3D grass_secondary = default_grass_secondary();
+  float macro_noise_scale = kDefaultMacroNoiseScale;
+  QVector3D grass_dry = default_grass_dry();
+  float detail_noise_scale = kDefaultDetailNoiseScale;
+  QVector3D soil_color = default_soil_color();
+  float slope_rock_threshold = kDefaultSlopeRockThreshold;
+  QVector3D rock_low = default_rock_low();
+  float slope_rock_sharpness = kDefaultSlopeRockSharpness;
+  QVector3D rock_high = default_rock_high();
+  float soil_blend_height = kDefaultSoilBlendHeight;
+  QVector3D tint = default_tint();
+  float soil_blend_sharpness = kDefaultSoilBlendSharpness;
 
-  QVector2D noiseOffset{0.0F, 0.0F};
-  float heightNoiseStrength = kDefaultHeightNoiseStrength;
-  float heightNoiseFrequency = kDefaultHeightNoiseFrequency;
-  float ambientBoost = kDefaultAmbientBoost;
-  float rockDetailStrength = kDefaultRockDetailStrength;
-  QVector3D light_direction = defaultLightDirection();
+  QVector2D noise_offset{0.0F, 0.0F};
+  float height_noise_strength = kDefaultHeightNoiseStrength;
+  float height_noise_frequency = kDefaultHeightNoiseFrequency;
+  float ambient_boost = kDefaultAmbientBoost;
+  float rock_detail_strength = kDefaultRockDetailStrength;
+  QVector3D light_direction = default_light_direction();
 
-  float noiseAngle = 0.0F;
+  float noise_angle = 0.0F;
 
-  float microBumpAmp = kDefaultMicroBumpAmp;
-  float microBumpFreq = kDefaultMicroBumpFreq;
-  float microNormalWeight = kDefaultMicroNormalWeight;
+  float micro_bump_amp = kDefaultMicroBumpAmp;
+  float micro_bump_freq = kDefaultMicroBumpFreq;
+  float micro_normal_weight = kDefaultMicroNormalWeight;
 
-  float albedoJitter = kDefaultAlbedoJitter;
+  float albedo_jitter = kDefaultAlbedoJitter;
 
-  bool isGroundPlane = false;
+  bool is_ground_plane = false;
 
-  // Ground-type-specific shader parameters
-  float snowCoverage = kDefaultSnowCoverage;
-  float moistureLevel = kDefaultMoistureLevel;
-  float crackIntensity = kDefaultCrackIntensity;
-  float rockExposure = kDefaultRockExposure;
-  float grassSaturation = kDefaultGrassSaturation;
-  float soilRoughness = kDefaultSoilRoughness;
-  QVector3D snowColor = defaultSnowColor();
+  float snow_coverage = kDefaultSnowCoverage;
+  float moisture_level = kDefaultMoistureLevel;
+  float crack_intensity = kDefaultCrackIntensity;
+  float rock_exposure = kDefaultRockExposure;
+  float grass_saturation = kDefaultGrassSaturation;
+  float soil_roughness = kDefaultSoilRoughness;
+  QVector3D snow_color = default_snow_color();
 };
 
 } // namespace Render::GL

render/ground/terrain_renderer.cpp

@@ -551,7 +551,7 @@ void TerrainRenderer::buildMeshes() {
 
         QVector3D const base_color =
             getTerrainColor(chunk.type, chunk.averageHeight);
-        QVector3D const rock_tint = m_biomeSettings.rockLow;
+        QVector3D const rock_tint = m_biomeSettings.rock_low;
 
         float slope_mix = std::clamp(
             avg_slope * ((chunk.type == Game::Map::TerrainType::Flat) ? 0.30F
@@ -612,18 +612,18 @@ void TerrainRenderer::buildMeshes() {
         auto tint_color = [&](const QVector3D &base) {
           return clamp01(applyTint(base, chunk.tint));
         };
-        params.grassPrimary = tint_color(m_biomeSettings.grassPrimary);
-        params.grassSecondary = tint_color(m_biomeSettings.grassSecondary);
-        params.grassDry = tint_color(m_biomeSettings.grassDry);
-        params.soilColor = tint_color(m_biomeSettings.soilColor);
-        params.rockLow = tint_color(m_biomeSettings.rockLow);
-        params.rockHigh = tint_color(m_biomeSettings.rockHigh);
+        params.grass_primary = tint_color(m_biomeSettings.grass_primary);
+        params.grass_secondary = tint_color(m_biomeSettings.grass_secondary);
+        params.grass_dry = tint_color(m_biomeSettings.grass_dry);
+        params.soil_color = tint_color(m_biomeSettings.soil_color);
+        params.rock_low = tint_color(m_biomeSettings.rock_low);
+        params.rock_high = tint_color(m_biomeSettings.rock_high);
 
         params.tile_size = std::max(0.001F, m_tile_size);
-        params.macroNoiseScale = m_biomeSettings.terrainMacroNoiseScale;
-        params.detail_noiseScale = m_biomeSettings.terrainDetailNoiseScale;
+        params.macro_noise_scale = m_biomeSettings.terrain_macro_noise_scale;
+        params.detail_noise_scale = m_biomeSettings.terrain_detail_noise_scale;
 
-        float slope_threshold = m_biomeSettings.terrainRockThreshold;
+        float slope_threshold = m_biomeSettings.terrain_rock_threshold;
         float sharpness_mul = 1.0F;
         if (chunk.type == Game::Map::TerrainType::Hill) {
           slope_threshold -= 0.08F;
@@ -638,21 +638,21 @@ void TerrainRenderer::buildMeshes() {
             slope_threshold - std::clamp(avg_slope * 0.20F, 0.0F, 0.12F), 0.05F,
             0.9F);
 
-        params.slopeRockThreshold = slope_threshold;
-        params.slopeRockSharpness = std::max(
-            1.0F, m_biomeSettings.terrainRockSharpness * sharpness_mul);
+        params.slope_rock_threshold = slope_threshold;
+        params.slope_rock_sharpness = std::max(
+            1.0F, m_biomeSettings.terrain_rock_sharpness * sharpness_mul);
 
-        float soil_height = m_biomeSettings.terrainSoilHeight;
+        float soil_height = m_biomeSettings.terrain_soil_height;
         if (chunk.type == Game::Map::TerrainType::Hill) {
           soil_height -= 0.06F;
         } else if (chunk.type == Game::Map::TerrainType::Mountain) {
           soil_height -= 0.12F;
         }
         soil_height += 0.05F * entrance_factor - 0.03F * plateau_factor;
-        params.soilBlendHeight = soil_height;
+        params.soil_blend_height = soil_height;
 
-        params.soilBlendSharpness =
-            std::max(0.75F, m_biomeSettings.terrainSoilSharpness *
+        params.soil_blend_sharpness =
+            std::max(0.75F, m_biomeSettings.terrain_soil_sharpness *
                                 (chunk.type == Game::Map::TerrainType::Mountain
                                      ? 0.80F
                                      : 0.95F));
@@ -662,26 +662,26 @@ void TerrainRenderer::buildMeshes() {
         const uint32_t noise_key_b =
             hash_coords(chunk.minX, chunk.minZ, m_noiseSeed ^ 0x68E31DA4U);
         constexpr float k_noise_offset_scale = 256.0F;
-        params.noiseOffset =
+        params.noise_offset =
             QVector2D(hash_to_01(noise_key_a) * k_noise_offset_scale,
                       hash_to_01(noise_key_b) * k_noise_offset_scale);
 
         float base_amp =
-            m_biomeSettings.heightNoiseAmplitude *
+            m_biomeSettings.height_noise_amplitude *
             (0.7F + 0.3F * std::clamp(roughness * 0.6F, 0.0F, 1.0F));
         if (chunk.type == Game::Map::TerrainType::Mountain) {
           base_amp *= 1.25F;
         }
         base_amp *= (1.0F + 0.10F * edge_factor - 0.08F * plateau_factor -
                      0.06F * entrance_factor);
-        params.heightNoiseStrength = base_amp;
-        params.heightNoiseFrequency = m_biomeSettings.heightNoiseFrequency;
+        params.height_noise_strength = base_amp;
+        params.height_noise_frequency = m_biomeSettings.height_noise_frequency;
 
-        params.ambientBoost =
-            m_biomeSettings.terrainAmbientBoost *
+        params.ambient_boost =
+            m_biomeSettings.terrain_ambient_boost *
             ((chunk.type == Game::Map::TerrainType::Mountain) ? 0.90F : 0.95F);
-        params.rockDetailStrength =
-            m_biomeSettings.terrainRockDetailStrength *
+        params.rock_detail_strength =
+            m_biomeSettings.terrain_rock_detail_strength *
             (0.75F + 0.35F * std::clamp(avg_slope * 1.2F, 0.0F, 1.0F) +
              0.15F * edge_factor - 0.10F * plateau_factor -
              0.08F * entrance_factor);
@@ -703,25 +703,25 @@ auto TerrainRenderer::getTerrainColor(Game::Map::TerrainType type,
   switch (type) {
   case Game::Map::TerrainType::Mountain:
     if (height > 4.0F) {
-      return m_biomeSettings.rockHigh;
+      return m_biomeSettings.rock_high;
     }
-    return m_biomeSettings.rockLow;
+    return m_biomeSettings.rock_low;
   case Game::Map::TerrainType::Hill: {
     float const t = std::clamp(height / 3.0F, 0.0F, 1.0F);
-    QVector3D const grass = m_biomeSettings.grassSecondary * (1.0F - t) +
-                            m_biomeSettings.grassDry * t;
+    QVector3D const grass = m_biomeSettings.grass_secondary * (1.0F - t) +
+                            m_biomeSettings.grass_dry * t;
     QVector3D const rock =
-        m_biomeSettings.rockLow * (1.0F - t) + m_biomeSettings.rockHigh * t;
+        m_biomeSettings.rock_low * (1.0F - t) + m_biomeSettings.rock_high * t;
     float const rock_blend = std::clamp(0.25F + 0.5F * t, 0.0F, 0.75F);
     return grass * (1.0F - rock_blend) + rock * rock_blend;
   }
   case Game::Map::TerrainType::Flat:
   default: {
     float const moisture = std::clamp((height - 0.5F) * 0.2F, 0.0F, 0.4F);
-    QVector3D const base = m_biomeSettings.grassPrimary * (1.0F - moisture) +
-                           m_biomeSettings.grassSecondary * moisture;
+    QVector3D const base = m_biomeSettings.grass_primary * (1.0F - moisture) +
+                           m_biomeSettings.grass_secondary * moisture;
     float const dry_blend = std::clamp((height - 2.0F) * 0.12F, 0.0F, 0.3F);
-    return base * (1.0F - dry_blend) + m_biomeSettings.grassDry * dry_blend;
+    return base * (1.0F - dry_blend) + m_biomeSettings.grass_dry * dry_blend;
   }
   }
 }

tests/core/ground_type_test.cpp

@@ -1,5 +1,6 @@
 #include "map/map_loader.h"
 #include "map/terrain.h"
+#include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QTemporaryFile>
@@ -14,129 +15,129 @@ protected:
 };
 
 TEST_F(GroundTypeTest, GroundTypeEnumToString) {
-  EXPECT_EQ(groundTypeToQString(GroundType::ForestMud),
+  EXPECT_EQ(ground_type_to_qstring(GroundType::ForestMud),
             QStringLiteral("forest_mud"));
-  EXPECT_EQ(groundTypeToQString(GroundType::GrassDry),
+  EXPECT_EQ(ground_type_to_qstring(GroundType::GrassDry),
             QStringLiteral("grass_dry"));
-  EXPECT_EQ(groundTypeToQString(GroundType::SoilRocky),
+  EXPECT_EQ(ground_type_to_qstring(GroundType::SoilRocky),
             QStringLiteral("soil_rocky"));
-  EXPECT_EQ(groundTypeToQString(GroundType::AlpineMix),
+  EXPECT_EQ(ground_type_to_qstring(GroundType::AlpineMix),
             QStringLiteral("alpine_mix"));
-  EXPECT_EQ(groundTypeToQString(GroundType::SoilFertile),
+  EXPECT_EQ(ground_type_to_qstring(GroundType::SoilFertile),
             QStringLiteral("soil_fertile"));
 }
 
 TEST_F(GroundTypeTest, GroundTypeStringToEnum) {
   GroundType result;
 
-  EXPECT_TRUE(tryParseGroundType("forest_mud", result));
+  EXPECT_TRUE(try_parse_ground_type("forest_mud", result));
   EXPECT_EQ(result, GroundType::ForestMud);
 
-  EXPECT_TRUE(tryParseGroundType("grass_dry", result));
+  EXPECT_TRUE(try_parse_ground_type("grass_dry", result));
   EXPECT_EQ(result, GroundType::GrassDry);
 
-  EXPECT_TRUE(tryParseGroundType("soil_rocky", result));
+  EXPECT_TRUE(try_parse_ground_type("soil_rocky", result));
   EXPECT_EQ(result, GroundType::SoilRocky);
 
-  EXPECT_TRUE(tryParseGroundType("alpine_mix", result));
+  EXPECT_TRUE(try_parse_ground_type("alpine_mix", result));
   EXPECT_EQ(result, GroundType::AlpineMix);
 
-  EXPECT_TRUE(tryParseGroundType("soil_fertile", result));
+  EXPECT_TRUE(try_parse_ground_type("soil_fertile", result));
   EXPECT_EQ(result, GroundType::SoilFertile);
 }
 
 TEST_F(GroundTypeTest, GroundTypeParsingCaseInsensitive) {
   GroundType result;
 
-  EXPECT_TRUE(tryParseGroundType("FOREST_MUD", result));
+  EXPECT_TRUE(try_parse_ground_type("FOREST_MUD", result));
   EXPECT_EQ(result, GroundType::ForestMud);
 
-  EXPECT_TRUE(tryParseGroundType("Forest_Mud", result));
+  EXPECT_TRUE(try_parse_ground_type("Forest_Mud", result));
   EXPECT_EQ(result, GroundType::ForestMud);
 
-  EXPECT_TRUE(tryParseGroundType("  grass_dry  ", result));
+  EXPECT_TRUE(try_parse_ground_type("  grass_dry  ", result));
   EXPECT_EQ(result, GroundType::GrassDry);
 }
 
 TEST_F(GroundTypeTest, GroundTypeParsingInvalidReturnsDefault) {
   GroundType result = GroundType::ForestMud;
 
-  EXPECT_FALSE(tryParseGroundType("invalid_type", result));
-  EXPECT_FALSE(tryParseGroundType("", result));
-  EXPECT_FALSE(tryParseGroundType("unknown", result));
+  EXPECT_FALSE(try_parse_ground_type("invalid_type", result));
+  EXPECT_FALSE(try_parse_ground_type("", result));
+  EXPECT_FALSE(try_parse_ground_type("unknown", result));
 }
 
 TEST_F(GroundTypeTest, ApplyGroundTypeDefaultsForestMud) {
   BiomeSettings settings;
-  applyGroundTypeDefaults(settings, GroundType::ForestMud);
-
-  EXPECT_EQ(settings.groundType, GroundType::ForestMud);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.x(), 0.30F);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.y(), 0.60F);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.z(), 0.28F);
-  EXPECT_FLOAT_EQ(settings.soilColor.x(), 0.28F);
-  EXPECT_FLOAT_EQ(settings.soilColor.y(), 0.24F);
-  EXPECT_FLOAT_EQ(settings.soilColor.z(), 0.18F);
+  apply_ground_type_defaults(settings, GroundType::ForestMud);
+
+  EXPECT_EQ(settings.ground_type, GroundType::ForestMud);
+  EXPECT_FLOAT_EQ(settings.grass_primary.x(), 0.30F);
+  EXPECT_FLOAT_EQ(settings.grass_primary.y(), 0.60F);
+  EXPECT_FLOAT_EQ(settings.grass_primary.z(), 0.28F);
+  EXPECT_FLOAT_EQ(settings.soil_color.x(), 0.28F);
+  EXPECT_FLOAT_EQ(settings.soil_color.y(), 0.24F);
+  EXPECT_FLOAT_EQ(settings.soil_color.z(), 0.18F);
 }
 
 TEST_F(GroundTypeTest, ApplyGroundTypeDefaultsGrassDry) {
   BiomeSettings settings;
-  applyGroundTypeDefaults(settings, GroundType::GrassDry);
+  apply_ground_type_defaults(settings, GroundType::GrassDry);
 
-  EXPECT_EQ(settings.groundType, GroundType::GrassDry);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.x(), 0.58F);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.y(), 0.54F);
-  EXPECT_FLOAT_EQ(settings.grassPrimary.z(), 0.32F);
-  EXPECT_FLOAT_EQ(settings.terrainAmbientBoost, 1.18F);
+  EXPECT_EQ(settings.ground_type, GroundType::GrassDry);
+  EXPECT_FLOAT_EQ(settings.grass_primary.x(), 0.58F);
+  EXPECT_FLOAT_EQ(settings.grass_primary.y(), 0.54F);
+  EXPECT_FLOAT_EQ(settings.grass_primary.z(), 0.32F);
+  EXPECT_FLOAT_EQ(settings.terrain_ambient_boost, 1.18F);
   // Check ground-type-specific parameters
-  EXPECT_FLOAT_EQ(settings.crackIntensity, 0.65F);
-  EXPECT_FLOAT_EQ(settings.moistureLevel, 0.15F);
-  EXPECT_FLOAT_EQ(settings.grassSaturation, 0.75F);
+  EXPECT_FLOAT_EQ(settings.crack_intensity, 0.65F);
+  EXPECT_FLOAT_EQ(settings.moisture_level, 0.15F);
+  EXPECT_FLOAT_EQ(settings.grass_saturation, 0.75F);
 }
 
 TEST_F(GroundTypeTest, ApplyGroundTypeDefaultsSoilRocky) {
   BiomeSettings settings;
-  applyGroundTypeDefaults(settings, GroundType::SoilRocky);
+  apply_ground_type_defaults(settings, GroundType::SoilRocky);
 
-  EXPECT_EQ(settings.groundType, GroundType::SoilRocky);
-  EXPECT_FLOAT_EQ(settings.soilColor.x(), 0.55F);
-  EXPECT_FLOAT_EQ(settings.soilColor.y(), 0.48F);
-  EXPECT_FLOAT_EQ(settings.soilColor.z(), 0.38F);
-  EXPECT_FLOAT_EQ(settings.terrainRockDetailStrength, 0.65F);
+  EXPECT_EQ(settings.ground_type, GroundType::SoilRocky);
+  EXPECT_FLOAT_EQ(settings.soil_color.x(), 0.55F);
+  EXPECT_FLOAT_EQ(settings.soil_color.y(), 0.48F);
+  EXPECT_FLOAT_EQ(settings.soil_color.z(), 0.38F);
+  EXPECT_FLOAT_EQ(settings.terrain_rock_detail_strength, 0.65F);
   // Check ground-type-specific parameters
-  EXPECT_FLOAT_EQ(settings.rockExposure, 0.75F);
-  EXPECT_FLOAT_EQ(settings.soilRoughness, 0.85F);
+  EXPECT_FLOAT_EQ(settings.rock_exposure, 0.75F);
+  EXPECT_FLOAT_EQ(settings.soil_roughness, 0.85F);
 }
 
 TEST_F(GroundTypeTest, ApplyGroundTypeDefaultsAlpineMix) {
   BiomeSettings settings;
-  applyGroundTypeDefaults(settings, GroundType::AlpineMix);
+  apply_ground_type_defaults(settings, GroundType::AlpineMix);
 
-  EXPECT_EQ(settings.groundType, GroundType::AlpineMix);
-  EXPECT_FLOAT_EQ(settings.rockHigh.x(), 0.88F);
-  EXPECT_FLOAT_EQ(settings.rockHigh.y(), 0.90F);
-  EXPECT_FLOAT_EQ(settings.rockHigh.z(), 0.94F);
-  EXPECT_FLOAT_EQ(settings.terrainAmbientBoost, 1.25F);
+  EXPECT_EQ(settings.ground_type, GroundType::AlpineMix);
+  EXPECT_FLOAT_EQ(settings.rock_high.x(), 0.88F);
+  EXPECT_FLOAT_EQ(settings.rock_high.y(), 0.90F);
+  EXPECT_FLOAT_EQ(settings.rock_high.z(), 0.94F);
+  EXPECT_FLOAT_EQ(settings.terrain_ambient_boost, 1.25F);
   // Check ground-type-specific parameters
-  EXPECT_FLOAT_EQ(settings.snowCoverage, 0.55F);
-  EXPECT_FLOAT_EQ(settings.snowColor.x(), 0.94F);
-  EXPECT_FLOAT_EQ(settings.snowColor.y(), 0.96F);
-  EXPECT_FLOAT_EQ(settings.snowColor.z(), 1.0F);
+  EXPECT_FLOAT_EQ(settings.snow_coverage, 0.55F);
+  EXPECT_FLOAT_EQ(settings.snow_color.x(), 0.94F);
+  EXPECT_FLOAT_EQ(settings.snow_color.y(), 0.96F);
+  EXPECT_FLOAT_EQ(settings.snow_color.z(), 1.0F);
 }
 
 TEST_F(GroundTypeTest, ApplyGroundTypeDefaultsSoilFertile) {
   BiomeSettings settings;
-  applyGroundTypeDefaults(settings, GroundType::SoilFertile);
+  apply_ground_type_defaults(settings, GroundType::SoilFertile);
 
-  EXPECT_EQ(settings.groundType, GroundType::SoilFertile);
-  EXPECT_FLOAT_EQ(settings.soilColor.x(), 0.20F);
-  EXPECT_FLOAT_EQ(settings.soilColor.y(), 0.16F);
-  EXPECT_FLOAT_EQ(settings.soilColor.z(), 0.12F);
-  EXPECT_FLOAT_EQ(settings.terrainRockDetailStrength, 0.22F);
+  EXPECT_EQ(settings.ground_type, GroundType::SoilFertile);
+  EXPECT_FLOAT_EQ(settings.soil_color.x(), 0.20F);
+  EXPECT_FLOAT_EQ(settings.soil_color.y(), 0.16F);
+  EXPECT_FLOAT_EQ(settings.soil_color.z(), 0.12F);
+  EXPECT_FLOAT_EQ(settings.terrain_rock_detail_strength, 0.22F);
   // Check ground-type-specific parameters
-  EXPECT_FLOAT_EQ(settings.moistureLevel, 0.80F);
-  EXPECT_FLOAT_EQ(settings.grassSaturation, 1.15F);
-  EXPECT_FLOAT_EQ(settings.rockExposure, 0.12F);
+  EXPECT_FLOAT_EQ(settings.moisture_level, 0.80F);
+  EXPECT_FLOAT_EQ(settings.grass_saturation, 1.15F);
+  EXPECT_FLOAT_EQ(settings.rock_exposure, 0.12F);
 }
 
 TEST_F(GroundTypeTest, MapLoaderWithGroundType) {
@@ -163,10 +164,11 @@ TEST_F(GroundTypeTest, MapLoaderWithGroundType) {
 
   MapDefinition map_def;
   QString error;
-  bool success = MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
+  bool success =
+      MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
 
   ASSERT_TRUE(success) << "Failed to load map: " << error.toStdString();
-  EXPECT_EQ(map_def.biome.groundType, GroundType::GrassDry);
+  EXPECT_EQ(map_def.biome.ground_type, GroundType::GrassDry);
   EXPECT_EQ(map_def.biome.seed, 12345U);
 }
 
@@ -193,10 +195,11 @@ TEST_F(GroundTypeTest, MapLoaderWithoutGroundTypeUsesDefault) {
 
   MapDefinition map_def;
   QString error;
-  bool success = MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
+  bool success =
+      MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
 
   ASSERT_TRUE(success) << "Failed to load map: " << error.toStdString();
-  EXPECT_EQ(map_def.biome.groundType, GroundType::ForestMud);
+  EXPECT_EQ(map_def.biome.ground_type, GroundType::ForestMud);
   EXPECT_EQ(map_def.biome.seed, 54321U);
 }
 
@@ -230,38 +233,39 @@ TEST_F(GroundTypeTest, MapLoaderGroundTypeOverriddenByExplicitValues) {
 
   MapDefinition map_def;
   QString error;
-  bool success = MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
+  bool success =
+      MapLoader::loadFromJsonFile(temp_file.fileName(), map_def, &error);
 
   ASSERT_TRUE(success) << "Failed to load map: " << error.toStdString();
-  EXPECT_EQ(map_def.biome.groundType, GroundType::AlpineMix);
+  EXPECT_EQ(map_def.biome.ground_type, GroundType::AlpineMix);
   EXPECT_EQ(map_def.biome.seed, 99999U);
   // Grass primary should be the overridden values, not the alpine_mix defaults
-  EXPECT_NEAR(map_def.biome.grassPrimary.x(), 0.10F, 0.001F);
-  EXPECT_NEAR(map_def.biome.grassPrimary.y(), 0.20F, 0.001F);
-  EXPECT_NEAR(map_def.biome.grassPrimary.z(), 0.30F, 0.001F);
+  EXPECT_NEAR(map_def.biome.grass_primary.x(), 0.10F, 0.001F);
+  EXPECT_NEAR(map_def.biome.grass_primary.y(), 0.20F, 0.001F);
+  EXPECT_NEAR(map_def.biome.grass_primary.z(), 0.30F, 0.001F);
 }
 
 TEST_F(GroundTypeTest, AllGroundTypesFromString) {
-  auto forest_mud = groundTypeFromString("forest_mud");
+  auto forest_mud = ground_type_from_string("forest_mud");
   ASSERT_TRUE(forest_mud.has_value());
   EXPECT_EQ(forest_mud.value(), GroundType::ForestMud);
 
-  auto grass_dry = groundTypeFromString("grass_dry");
+  auto grass_dry = ground_type_from_string("grass_dry");
   ASSERT_TRUE(grass_dry.has_value());
   EXPECT_EQ(grass_dry.value(), GroundType::GrassDry);
 
-  auto soil_rocky = groundTypeFromString("soil_rocky");
+  auto soil_rocky = ground_type_from_string("soil_rocky");
   ASSERT_TRUE(soil_rocky.has_value());
   EXPECT_EQ(soil_rocky.value(), GroundType::SoilRocky);
 
-  auto alpine_mix = groundTypeFromString("alpine_mix");
+  auto alpine_mix = ground_type_from_string("alpine_mix");
   ASSERT_TRUE(alpine_mix.has_value());
   EXPECT_EQ(alpine_mix.value(), GroundType::AlpineMix);
 
-  auto soil_fertile = groundTypeFromString("soil_fertile");
+  auto soil_fertile = ground_type_from_string("soil_fertile");
   ASSERT_TRUE(soil_fertile.has_value());
   EXPECT_EQ(soil_fertile.value(), GroundType::SoilFertile);
 
-  auto invalid = groundTypeFromString("invalid");
+  auto invalid = ground_type_from_string("invalid");
   EXPECT_FALSE(invalid.has_value());
 }