Convert ground renderer GPU struct members to snake_case

Co-authored-by: djeada <[email protected]>

render/ground/biome_renderer.cpp

@@ -286,9 +286,9 @@ void BiomeRenderer::generateGrassInstances() {
     float const orientation = rand_01(state) * MathConstants::k_two_pi;
 
     GrassInstanceGpu instance;
-    instance.posHeight = QVector4D(world_x, world_y, world_z, height);
-    instance.colorWidth = QVector4D(color.x(), color.y(), color.z(), width);
-    instance.swayParams =
+    instance.pos_height = QVector4D(world_x, world_y, world_z, height);
+    instance.color_width = QVector4D(color.x(), color.y(), color.z(), width);
+    instance.sway_params =
         QVector4D(sway_strength, sway_speed, sway_phase, orientation);
     m_grassInstances.push_back(instance);
     return true;

render/ground/firecamp_gpu.h

@@ -17,9 +17,9 @@ struct FireCampBatchParams {
   static constexpr float kDefaultGlowStrength = 1.25F;
 
   float time = 0.0F;
-  float flickerSpeed = kDefaultFlickerSpeed;
-  float flickerAmount = kDefaultFlickerAmount;
-  float glowStrength = kDefaultGlowStrength;
+  float flicker_speed = kDefaultFlickerSpeed;
+  float flicker_amount = kDefaultFlickerAmount;
+  float glow_strength = kDefaultGlowStrength;
 };
 
 } // namespace Render::GL

render/ground/firecamp_renderer.cpp

@@ -73,9 +73,9 @@ void FireCampRenderer::configure(
   m_fireCampInstancesDirty = false;
 
   m_fireCampParams.time = 0.0F;
-  m_fireCampParams.flickerSpeed = 5.0F;
-  m_fireCampParams.flickerAmount = 0.02F;
-  m_fireCampParams.glowStrength = 1.1F;
+  m_fireCampParams.flicker_speed = 5.0F;
+  m_fireCampParams.flicker_amount = 0.02F;
+  m_fireCampParams.glow_strength = 1.1F;
 
   generateFireCampInstances();
 }
@@ -135,9 +135,9 @@ void FireCampRenderer::submit(Renderer &renderer, ResourceManager *resources) {
 
   FireCampBatchParams params = m_fireCampParams;
   params.time = renderer.getAnimationTime();
-  params.flickerAmount = m_fireCampParams.flickerAmount *
+  params.flicker_amount = m_fireCampParams.flicker_amount *
                          (0.9F + 0.25F * std::sin(params.time * 1.3F));
-  params.glowStrength = m_fireCampParams.glowStrength *
+  params.glow_strength = m_fireCampParams.glow_strength *
                         (0.85F + 0.2F * std::sin(params.time * 1.7F + 1.2F));
   renderer.firecampBatch(m_fireCampInstanceBuffer.get(), visible_count, params);
 

render/ground/grass_gpu.h

@@ -6,9 +6,9 @@
 namespace Render::GL {
 
 struct GrassInstanceGpu {
-  QVector4D posHeight{0.0F, 0.0F, 0.0F, 0.0F};
-  QVector4D colorWidth{0.0F, 0.0F, 0.0F, 0.0F};
-  QVector4D swayParams{0.0F, 0.0F, 0.0F, 0.0F};
+  QVector4D pos_height{0.0F, 0.0F, 0.0F, 0.0F};
+  QVector4D color_width{0.0F, 0.0F, 0.0F, 0.0F};
+  QVector4D sway_params{0.0F, 0.0F, 0.0F, 0.0F};
 };
 
 struct GrassBatchParams {

render/ground/pine_gpu.h

@@ -7,8 +7,8 @@
 namespace Render::GL {
 
 struct PineInstanceGpu {
-  QVector4D posScale;
-  QVector4D colorSway;
+  QVector4D pos_scale;
+  QVector4D color_sway;
   QVector4D rotation;
 };
 

render/ground/pine_renderer.cpp

@@ -93,8 +93,8 @@ void PineRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     if (use_visibility) {
       m_visibleInstances.reserve(m_pineInstanceCount);
       for (const auto &instance : m_pineInstances) {
-        float const world_x = instance.posScale.x();
-        float const world_z = instance.posScale.z();
+        float const world_x = instance.pos_scale.x();
+        float const world_z = instance.pos_scale.z();
         if (visibility.isVisibleWorld(world_x, world_z)) {
           m_visibleInstances.push_back(instance);
         }
@@ -238,8 +238,8 @@ void PineRenderer::generatePineInstances() {
 
     PineInstanceGpu instance;
 
-    instance.posScale = QVector4D(world_x, world_y, world_z, scale);
-    instance.colorSway =
+    instance.pos_scale = QVector4D(world_x, world_y, world_z, scale);
+    instance.color_sway =
         QVector4D(tint_color.x(), tint_color.y(), tint_color.z(), sway_phase);
     instance.rotation =
         QVector4D(rotation, silhouette_seed, needle_seed, bark_seed);

render/ground/plant_gpu.h

@@ -6,9 +6,9 @@
 namespace Render::GL {
 
 struct PlantInstanceGpu {
-  QVector4D posScale;
-  QVector4D colorSway;
-  QVector4D typeParams;
+  QVector4D pos_scale;
+  QVector4D color_sway;
+  QVector4D type_params;
 };
 
 struct PlantBatchParams {

render/ground/plant_renderer.cpp

@@ -93,8 +93,8 @@ void PlantRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     if (use_visibility) {
       m_visibleInstances.reserve(m_plantInstanceCount);
       for (const auto &instance : m_plantInstances) {
-        float const world_x = instance.posScale.x();
-        float const world_z = instance.posScale.z();
+        float const world_x = instance.pos_scale.x();
+        float const world_z = instance.pos_scale.z();
         if (visibility.isVisibleWorld(world_x, world_z)) {
           m_visibleInstances.push_back(instance);
         }
@@ -292,10 +292,10 @@ void PlantRenderer::generatePlantInstances() {
 
     PlantInstanceGpu instance;
 
-    instance.posScale = QVector4D(world_x, world_y + 0.05F, world_z, scale);
-    instance.colorSway =
+    instance.pos_scale = QVector4D(world_x, world_y + 0.05F, world_z, scale);
+    instance.color_sway =
         QVector4D(tint_color.x(), tint_color.y(), tint_color.z(), sway_phase);
-    instance.typeParams =
+    instance.type_params =
         QVector4D(plant_type, rotation, sway_strength, sway_speed);
     m_plantInstances.push_back(instance);
     return true;

render/ground/riverbank_asset_gpu.h

@@ -10,7 +10,7 @@ struct RiverbankAssetInstanceGpu {
   std::array<float, 3> scale;
   std::array<float, 4> rotation;
   std::array<float, 3> color;
-  float assetType;
+  float asset_type;
 };
 
 struct RiverbankAssetBatchParams {

render/ground/riverbank_asset_renderer.cpp

@@ -230,7 +230,7 @@ void RiverbankAssetRenderer::generateAssetInstances() {
         float const type_rand = rand_01(rng);
         if (type_rand < 0.7F) {
 
-          instance.assetType = 0.0F;
+          instance.asset_type = 0.0F;
           float const size = 0.05F + rand_01(rng) * 0.1F;
           instance.scale[0] = size * (0.8F + rand_01(rng) * 0.4F);
           instance.scale[1] = size * (0.6F + rand_01(rng) * 0.3F);
@@ -242,7 +242,7 @@ void RiverbankAssetRenderer::generateAssetInstances() {
           instance.color[2] = color_var * 0.85F;
         } else if (type_rand < 0.9F) {
 
-          instance.assetType = 1.0F;
+          instance.asset_type = 1.0F;
           float const size = 0.1F + rand_01(rng) * 0.15F;
           instance.scale[0] = size;
           instance.scale[1] = size * (0.7F + rand_01(rng) * 0.4F);
@@ -258,7 +258,7 @@ void RiverbankAssetRenderer::generateAssetInstances() {
             continue;
           }
 
-          instance.assetType = 2.0F;
+          instance.asset_type = 2.0F;
           float const size = 0.3F + rand_01(rng) * 0.4F;
           instance.scale[0] = size * 0.3F;
           instance.scale[1] = size;

render/ground/stone_gpu.h

@@ -6,8 +6,8 @@
 namespace Render::GL {
 
 struct StoneInstanceGpu {
-  QVector4D posScale;
-  QVector4D colorRot;
+  QVector4D pos_scale;
+  QVector4D color_rot;
 };
 
 struct StoneBatchParams {
@@ -15,11 +15,11 @@ struct StoneBatchParams {
   static constexpr float kDefaultLightDirY = 0.8F;
   static constexpr float kDefaultLightDirZ = 0.45F;
 
-  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;
 };
 

render/ground/stone_renderer.cpp

@@ -223,8 +223,8 @@ void StoneRenderer::generateStoneInstances() {
     float const rotation = rand_01(state) * MathConstants::k_two_pi;
 
     StoneInstanceGpu instance;
-    instance.posScale = QVector4D(world_x, world_y + 0.01F, world_z, scale);
-    instance.colorRot = QVector4D(color.x(), color.y(), color.z(), rotation);
+    instance.pos_scale = QVector4D(world_x, world_y + 0.01F, world_z, scale);
+    instance.color_rot = QVector4D(color.x(), color.y(), color.z(), rotation);
     m_stoneInstances.push_back(instance);
     return true;
   };