Fix compilation errors

app/core/game_engine.cpp

@@ -672,7 +672,7 @@ void GameEngine::update(float dt) {
   }
 
   if (m_renderer) {
-    m_renderer->updateAnimationTime(dt);
+    m_renderer->update_animation_time(dt);
   }
 
   if (m_camera) {
@@ -754,12 +754,12 @@ void GameEngine::render(int pixelWidth, int pixelHeight) {
     }
   }
   if (m_renderer && m_hoverTracker) {
-    m_renderer->setHoveredEntityId(m_hoverTracker->getLastHoveredEntity());
+    m_renderer->set_hovered_entity_id(m_hoverTracker->getLastHoveredEntity());
   }
   if (m_renderer) {
-    m_renderer->setLocalOwnerId(m_runtime.localOwnerId);
+    m_renderer->set_local_owner_id(m_runtime.localOwnerId);
   }
-  m_renderer->renderWorld(m_world.get());
+  m_renderer->render_world(m_world.get());
   if (auto *arrow_system = m_world->getSystem<Game::Systems::ArrowSystem>()) {
     if (auto *res = m_renderer->resources()) {
       Render::GL::renderArrows(m_renderer.get(), res, *arrow_system);

game/map/environment.cpp

@@ -16,10 +16,10 @@ void Environment::apply(const MapDefinition &def,
   camera.setPerspective(def.camera.fovY, 16.0F / 9.0F, def.camera.near_plane,
                         def.camera.far_plane);
   Render::GL::Renderer::GridParams gp;
-  gp.cellSize = def.grid.tile_size;
+  gp.cell_size = def.grid.tile_size;
   gp.extent =
       std::max(def.grid.width, def.grid.height) * def.grid.tile_size * 0.5F;
-  renderer.setGridParams(gp);
+  renderer.set_grid_params(gp);
 }
 
 void Environment::applyDefault(Render::GL::Renderer &renderer,
@@ -30,9 +30,9 @@ void Environment::applyDefault(Render::GL::Renderer &renderer,
 
   camera.setPerspective(45.0F, 16.0F / 9.0F, 1.0F, 200.0F);
   Render::GL::Renderer::GridParams gp;
-  gp.cellSize = 1.0F;
+  gp.cell_size = 1.0F;
   gp.extent = 50.0F;
-  renderer.setGridParams(gp);
+  renderer.set_grid_params(gp);
 }
 
 } // namespace Game::Map

game/map/map_transformer.cpp

@@ -39,7 +39,7 @@ auto MapTransformer::getFactoryRegistry()
   return s_registry;
 }
 
-void MapTransformer::setLocalOwnerId(int owner_id) {
+void MapTransformer::set_local_owner_id(int owner_id) {
   auto &owners = Game::Systems::OwnerRegistry::instance();
   owners.setLocalPlayerId(owner_id);
 }

game/map/map_transformer.h

@@ -30,7 +30,7 @@ public:
   static auto
   getFactoryRegistry() -> std::shared_ptr<Game::Units::UnitFactoryRegistry>;
 
-  static void setLocalOwnerId(int owner_id);
+  static void set_local_owner_id(int owner_id);
   static auto localOwnerId() -> int;
 
   static void

game/map/skirmish_loader.cpp

@@ -70,9 +70,9 @@ void SkirmishLoader::resetGameState() {
   }
 
   m_renderer.pause();
-  m_renderer.lockWorldForModification();
-  m_renderer.setSelectedEntities({});
-  m_renderer.setHoveredEntityId(0);
+  m_renderer.lock_world_for_modification();
+  m_renderer.set_selected_entities({});
+  m_renderer.set_hovered_entity_id(0);
 
   m_world.clear();
 
@@ -214,13 +214,13 @@ auto SkirmishLoader::start(const QString &map_path,
   if (team_overrides.size() >= 2 && unique_teams.size() < 2) {
     result.errorMessage = "Invalid team configuration: At least two teams must "
                           "be selected to start a match.";
-    m_renderer.unlockWorldForModification();
+    m_renderer.unlock_world_for_modification();
     m_renderer.resume();
     qWarning() << "SkirmishLoader: " << result.errorMessage;
     return result;
   }
 
-  Game::Map::MapTransformer::setLocalOwnerId(player_owner_id);
+  Game::Map::MapTransformer::set_local_owner_id(player_owner_id);
   Game::Map::MapTransformer::setPlayerTeamOverrides(team_overrides);
 
   auto &nation_registry = Game::Systems::NationRegistry::instance();
@@ -251,7 +251,7 @@ auto SkirmishLoader::start(const QString &map_path,
 
   if (!level_result.ok && !level_result.errorMessage.isEmpty()) {
     result.errorMessage = level_result.errorMessage;
-    m_renderer.unlockWorldForModification();
+    m_renderer.unlock_world_for_modification();
     m_renderer.resume();
     return result;
   }
@@ -453,7 +453,7 @@ auto SkirmishLoader::start(const QString &map_path,
     m_biome->refreshGrass();
   }
 
-  m_renderer.unlockWorldForModification();
+  m_renderer.unlock_world_for_modification();
   m_renderer.resume();
 
   Engine::Core::Entity *focus_entity = nullptr;

render/draw_queue.h

@@ -234,14 +234,14 @@ private:
   void radix_sort_two_pass(std::size_t count) {
     constexpr int BUCKETS = 256;
 
-    m_tempIndices.resize(count);
+    m_temp_indices.resize(count);
 
     {
       int histogram[BUCKETS] = {0};
 
       for (std::size_t i = 0; i < count; ++i) {
         auto const bucket =
-            static_cast<uint8_t>(m_sortKeys[i] >> k_sort_key_bucket_shift);
+            static_cast<uint8_t>(m_sort_keys[i] >> k_sort_key_bucket_shift);
         ++histogram[bucket];
       }
 
@@ -252,9 +252,9 @@ private:
       }
 
       for (std::size_t i = 0; i < count; ++i) {
-        auto const bucket = static_cast<uint8_t>(m_sortKeys[m_sortIndices[i]] >>
-                                                 k_sort_key_bucket_shift);
-        m_tempIndices[offsets[bucket]++] = m_sortIndices[i];
+        auto const bucket = static_cast<uint8_t>(
+            m_sort_keys[m_sort_indices[i]] >> k_sort_key_bucket_shift);
+        m_temp_indices[offsets[bucket]++] = m_sort_indices[i];
       }
     }
 
@@ -263,7 +263,7 @@ private:
 
       for (std::size_t i = 0; i < count; ++i) {
         uint8_t const bucket =
-            static_cast<uint8_t>(m_sortKeys[m_tempIndices[i]] >> 48) & 0xFF;
+            static_cast<uint8_t>(m_sort_keys[m_temp_indices[i]] >> 48) & 0xFF;
         ++histogram[bucket];
       }
 
@@ -275,13 +275,13 @@ private:
 
       for (std::size_t i = 0; i < count; ++i) {
         uint8_t const bucket =
-            static_cast<uint8_t>(m_sortKeys[m_tempIndices[i]] >> 48) & 0xFF;
-        m_sortIndices[offsets[bucket]++] = m_tempIndices[i];
+            static_cast<uint8_t>(m_sort_keys[m_temp_indices[i]] >> 48) & 0xFF;
+        m_sort_indices[offsets[bucket]++] = m_temp_indices[i];
       }
     }
   }
 
-  [[nodiscard]] static auto computeSortKey(const DrawCmd &cmd) -> uint64_t {
+  [[nodiscard]] static auto compute_sort_key(const DrawCmd &cmd) -> uint64_t {
 
     enum class RenderOrder : uint8_t {
       TerrainChunk = 0,
@@ -352,7 +352,8 @@ private:
     } else if (cmd.index() == PineBatchCmdIndex) {
       const auto &pine = std::get<PineBatchCmdIndex>(cmd);
       uint64_t const bufferPtr =
-          reinterpret_cast<uintptr_t>(pine.instance_buffer) & 0x0000FFFFFFFFFFFF;
+          reinterpret_cast<uintptr_t>(pine.instance_buffer) &
+          0x0000FFFFFFFFFFFF;
       key |= bufferPtr;
     } else if (cmd.index() == OliveBatchCmdIndex) {
       const auto &olive = std::get<OliveBatchCmdIndex>(cmd);

render/entity/horse_archer_renderer_base.cpp

@@ -68,7 +68,7 @@ void HorseArcherRendererBase::adjust_variation(
 
 void HorseArcherRendererBase::get_variant(const DrawContext &ctx, uint32_t seed,
                                           HumanoidVariant &v) const {
-  QVector3D const team_tint = resolveTeamTint(ctx);
+  QVector3D const team_tint = resolve_team_tint(ctx);
   v.palette = makeHumanoidPalette(team_tint, seed);
 }
 

render/entity/horse_renderer.cpp

@@ -18,7 +18,7 @@ void HorseRenderer::setAttachments(
   m_attachments = attachments;
 }
 
-void HorseRenderer::drawAttachments(
+void HorseRenderer::draw_attachments(
     const DrawContext &ctx, const AnimationInputs &anim,
     const HumanoidAnimationContext &, HorseProfile &profile,
     const MountedAttachmentFrame &, float phase, float bob, float,

render/entity/horse_renderer.h

@@ -20,13 +20,13 @@ public:
       const std::vector<std::shared_ptr<IHorseEquipmentRenderer>> &attachments);
 
 protected:
-  void drawAttachments(const DrawContext &ctx, const AnimationInputs &anim,
-                       const HumanoidAnimationContext &rider_ctx,
-                       HorseProfile &profile,
-                       const MountedAttachmentFrame &mount, float phase,
-                       float bob, float rein_slack,
-                       const HorseBodyFrames &frames,
-                       ISubmitter &out) const override;
+  void draw_attachments(const DrawContext &ctx, const AnimationInputs &anim,
+                        const HumanoidAnimationContext &rider_ctx,
+                        HorseProfile &profile,
+                        const MountedAttachmentFrame &mount, float phase,
+                        float bob, float rein_slack,
+                        const HorseBodyFrames &frames,
+                        ISubmitter &out) const override;
 
 private:
   std::vector<std::shared_ptr<IHorseEquipmentRenderer>> m_attachments;

render/entity/horse_spearman_renderer_base.cpp

@@ -70,7 +70,7 @@ void HorseSpearmanRendererBase::adjust_variation(
 void HorseSpearmanRendererBase::get_variant(const DrawContext &ctx,
                                             uint32_t seed,
                                             HumanoidVariant &v) const {
-  QVector3D const team_tint = resolveTeamTint(ctx);
+  QVector3D const team_tint = resolve_team_tint(ctx);
   v.palette = makeHumanoidPalette(team_tint, seed);
 }
 

render/entity/mounted_humanoid_renderer_base.cpp

@@ -56,7 +56,7 @@ auto MountedHumanoidRendererBase::resolve_entity_ground_offset(
   }
 
   HorseDimensions dims = get_scaled_horse_dimensions(horse_seed);
-  float offset = -dims.barrel_centerY;
+  float offset = -dims.barrel_center_y;
   if (transform_comp != nullptr) {
     offset *= transform_comp->scale.y;
   }
@@ -103,7 +103,7 @@ void MountedHumanoidRendererBase::customize_pose(
   mounted_controller.finalizeHeadSync(mount, "customize_pose_final_sync");
 }
 
-void MountedHumanoidRendererBase::addAttachments(
+void MountedHumanoidRendererBase::add_attachments(
     const DrawContext &ctx, const HumanoidVariant &v, const HumanoidPose &pose,
     const HumanoidAnimationContext &anim_ctx, ISubmitter &out) const {
   static uint64_t s_mounted_frame_counter = 0;

render/entity/mounted_humanoid_renderer_base.h

@@ -17,10 +17,10 @@ public:
                       const HumanoidAnimationContext &anim_ctx, uint32_t seed,
                       HumanoidPose &pose) const override;
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override;
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override;
 
   virtual auto get_mount_scale() const -> float = 0;
 

render/entity/mounted_knight_pose.h

@@ -40,14 +40,14 @@ inline void tuneMountedKnightFrame(const HorseDimensions &dims,
     float const side = is_left ? -1.0F : 1.0F;
     QVector3D attach =
         mount.seat_position +
-        mount.seat_right * (side * dims.bodyWidth * cfg.stirrupInsetFactor) +
-        mount.seat_forward * (dims.bodyLength * cfg.stirrupForwardBias +
-                              dims.seatForwardOffset * 0.20F) -
-        mount.seat_up * (dims.stirrupDrop * cfg.stirrupHeightBias);
+        mount.seat_right * (side * dims.body_width * cfg.stirrupInsetFactor) +
+        mount.seat_forward * (dims.body_length * cfg.stirrupForwardBias +
+                              dims.seat_forward_offset * 0.20F) -
+        mount.seat_up * (dims.stirrup_drop * cfg.stirrupHeightBias);
     QVector3D bottom =
-        attach - mount.seat_up * (dims.stirrupDrop * cfg.stirrupDropScale) +
-        mount.seat_forward * (dims.bodyLength * cfg.stirrupBackOffset) +
-        mount.seat_right * (side * dims.bodyWidth * cfg.stirrupOutwardBias);
+        attach - mount.seat_up * (dims.stirrup_drop * cfg.stirrupDropScale) +
+        mount.seat_forward * (dims.body_length * cfg.stirrupBackOffset) +
+        mount.seat_right * (side * dims.body_width * cfg.stirrupOutwardBias);
 
     if (is_left) {
       mount.stirrup_attach_left = attach;
@@ -78,9 +78,9 @@ inline void applyMountedKnightLowerBody(
     QVector3D pelvis_to_stirrup = stirrup - pelvis;
     QVector3D thigh_target =
         pelvis + pelvis_to_stirrup * cfg.kneeAlong +
-        mount.seat_right * (side * dims.bodyWidth * cfg.thighWrapFactor);
+        mount.seat_right * (side * dims.body_width * cfg.thighWrapFactor);
     float const knee_contact_plane =
-        mount.seat_position.x() + side * dims.bodyWidth * 0.56F;
+        mount.seat_position.x() + side * dims.body_width * 0.56F;
     thigh_target.setX(thigh_target.x() * (1.0F - cfg.kneePlaneLerp) +
                       knee_contact_plane * cfg.kneePlaneLerp);
     knee = knee * (1.0F - cfg.kneeBlend) + thigh_target * cfg.kneeBlend;
@@ -90,13 +90,13 @@ inline void applyMountedKnightLowerBody(
     base_foot += mount.ground_offset;
 
     QVector3D calf_surface =
-        knee + mount.seat_right * (side * dims.bodyWidth * cfg.calfOutOffset) +
-        mount.seat_forward * (dims.bodyLength * cfg.calfBackOffset) -
-        mount.seat_up * (dims.stirrupDrop * cfg.calfDownExtra);
+        knee + mount.seat_right * (side * dims.body_width * cfg.calfOutOffset) +
+        mount.seat_forward * (dims.body_length * cfg.calfBackOffset) -
+        mount.seat_up * (dims.stirrup_drop * cfg.calfDownExtra);
     QVector3D calf_from_foot =
         base_foot +
-        mount.seat_forward * (dims.bodyLength * cfg.calfBehindGirth) -
-        mount.seat_up * (dims.stirrupDrop * cfg.calfRelax);
+        mount.seat_forward * (dims.body_length * cfg.calfBehindGirth) -
+        mount.seat_up * (dims.stirrup_drop * cfg.calfRelax);
 
     QVector3D calf_target = calf_from_foot * (1.0F - cfg.calfSurfaceBlend) +
                             calf_surface * cfg.calfSurfaceBlend;
@@ -107,8 +107,8 @@ inline void applyMountedKnightLowerBody(
 
     QVector3D foot_target =
         calf_target +
-        mount.seat_forward * (dims.bodyLength * cfg.footBackOffset) -
-        mount.seat_up * (dims.stirrupDrop * cfg.footDownOffset);
+        mount.seat_forward * (dims.body_length * cfg.footBackOffset) -
+        mount.seat_up * (dims.stirrup_drop * cfg.footDownOffset);
     foot = foot * (1.0F - cfg.footBlend) + foot_target * cfg.footBlend;
   };
 

render/entity/mounted_knight_renderer_base.cpp

@@ -69,7 +69,7 @@ void MountedKnightRendererBase::adjust_variation(
 void MountedKnightRendererBase::get_variant(const DrawContext &ctx,
                                             uint32_t seed,
                                             HumanoidVariant &v) const {
-  QVector3D const team_tint = resolveTeamTint(ctx);
+  QVector3D const team_tint = resolve_team_tint(ctx);
   v.palette = makeHumanoidPalette(team_tint, seed);
 }
 
@@ -82,7 +82,7 @@ void MountedKnightRendererBase::apply_riding_animation(
   float const speed_norm = anim_ctx.locomotion_normalized_speed();
   float const speed_lean = 0.0F;
   float const forward_lean =
-      (dims.seatForwardOffset * 0.08F + speed_lean) / 0.15F;
+      (dims.seat_forward_offset * 0.08F + speed_lean) / 0.15F;
 
   MountedPoseController::MountedRiderPoseRequest pose_request;
   pose_request.dims = dims;

render/entity/nations/carthage/archer_renderer.cpp

@@ -97,7 +97,7 @@ public:
 
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -179,15 +179,15 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     using HP = HumanProportions;
 
     auto const &style = resolve_style(ctx);
     const AnimationInputs &anim = anim_ctx.inputs;
-    QVector3D team_tint = resolveTeamTint(ctx);
+    QVector3D team_tint = resolve_team_tint(ctx);
     uint32_t seed = 0U;
     if (ctx.entity != nullptr) {
       auto *unit = ctx.entity->getComponent<Engine::Core::UnitComponent>();
@@ -388,11 +388,11 @@ void registerArcherRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (archer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(archer_shader);
+          scene_renderer->set_current_shader(archer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/ballista_renderer.cpp

@@ -258,8 +258,8 @@ void register_ballista_renderer(EntityRendererRegistry &registry) {
           white = p.resources->white();
         }
         if (auto *scene_renderer = dynamic_cast<Renderer *>(&out)) {
-          unit = scene_renderer->getMeshCube();
-          white = scene_renderer->getWhiteTexture();
+          unit = scene_renderer->get_mesh_cube();
+          white = scene_renderer->get_white_texture();
         }
 
         if (unit == nullptr || white == nullptr) {

render/entity/nations/carthage/barracks_renderer.cpp

@@ -322,9 +322,9 @@ void draw_selection(const DrawContext &p, ISubmitter &out) {
   m.translate(pos.x(), 0.0F, pos.z());
   m.scale(2.6F, 1.0F, 2.2F);
   if (p.selected) {
-    out.selectionSmoke(m, QVector3D(0.2F, 0.85F, 0.2F), 0.35F);
+    out.selection_smoke(m, QVector3D(0.2F, 0.85F, 0.2F), 0.35F);
   } else if (p.hovered) {
-    out.selectionSmoke(m, QVector3D(0.95F, 0.92F, 0.25F), 0.22F);
+    out.selection_smoke(m, QVector3D(0.95F, 0.92F, 0.25F), 0.22F);
   }
 }
 

render/entity/nations/carthage/catapult_renderer.cpp

@@ -224,8 +224,8 @@ void register_catapult_renderer(EntityRendererRegistry &registry) {
         Texture *white_tex = nullptr;
 
         if (auto *scene_renderer = dynamic_cast<Renderer *>(&out)) {
-          unit_cube = scene_renderer->getMeshCube();
-          white_tex = scene_renderer->getWhiteTexture();
+          unit_cube = scene_renderer->get_mesh_cube();
+          white_tex = scene_renderer->get_white_texture();
         }
 
         if (unit_cube == nullptr || white_tex == nullptr) {
@@ -245,7 +245,8 @@ void register_catapult_renderer(EntityRendererRegistry &registry) {
         drawBaseFrame(p, out, unit_cube, white_tex, palette);
         drawWheels(p, out, unit_cube, white_tex, palette);
         drawTorsionMechanism(p, out, unit_cube, white_tex, palette);
-        drawThrowingArm(p, out, unit_cube, white_tex, palette, p.animation_time);
+        drawThrowingArm(p, out, unit_cube, white_tex, palette,
+                        p.animation_time);
         drawWindlass(p, out, unit_cube, white_tex, palette);
         drawDecorations(p, out, unit_cube, white_tex, palette);
       });

render/entity/nations/carthage/healer_renderer.cpp

@@ -81,7 +81,7 @@ public:
 
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -161,10 +161,10 @@ public:
     controller.placeHandAt(false, idle_hand_r);
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {}
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {}
 
   void draw_helmet(const DrawContext &ctx, const HumanoidVariant &v,
                    const HumanoidPose &pose, ISubmitter &out) const override {
@@ -207,7 +207,7 @@ public:
       return;
     }
 
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     QVector3D const robe_cream(0.46F, 0.46F, 0.48F);
     QVector3D const robe_light(0.42F, 0.42F, 0.44F);
     QVector3D const robe_tan(0.38F, 0.38F, 0.40F);
@@ -456,11 +456,11 @@ void registerHealerRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (healer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(healer_shader);
+          scene_renderer->set_current_shader(healer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/horse_archer_renderer.cpp

@@ -52,11 +52,11 @@ void register_horse_archer_renderer(EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (horse_archer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_archer_shader);
+          scene_renderer->set_current_shader(horse_archer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/horse_spearman_renderer.cpp

@@ -46,11 +46,11 @@ void register_horse_spearman_renderer(EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (horse_spearman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_spearman_shader);
+          scene_renderer->set_current_shader(horse_spearman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/horse_swordsman_renderer.cpp

@@ -37,7 +37,7 @@ public:
                    HumanoidVariant &v) const override {
     MountedKnightRendererBase::get_variant(ctx, seed, v);
     const KnightStyleConfig style = carthage_style();
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
 
     auto apply_color = [&](const std::optional<QVector3D> &override_color,
                            QVector3D &target) {
@@ -97,11 +97,11 @@ void registerMountedKnightRenderer(EntityRendererRegistry &registry) {
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) &&
             (horse_swordsman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_swordsman_shader);
+          scene_renderer->set_current_shader(horse_swordsman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/spearman_renderer.cpp

@@ -124,7 +124,7 @@ private:
 public:
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -235,14 +235,14 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     const AnimationInputs &anim = anim_ctx.inputs;
     uint32_t const seed = reinterpret_cast<uintptr_t>(ctx.entity) & 0xFFFFFFFFU;
     auto const &style = resolve_style(ctx);
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
 
     SpearmanExtras extras;
     auto it = m_extrasCache.find(seed);
@@ -438,11 +438,11 @@ void registerSpearmanRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (spearman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(spearman_shader);
+          scene_renderer->set_current_shader(spearman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/carthage/swordsman_renderer.cpp

@@ -115,7 +115,7 @@ private:
 public:
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -149,14 +149,14 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     const AnimationInputs &anim = anim_ctx.inputs;
     uint32_t const seed = reinterpret_cast<uintptr_t>(ctx.entity) & 0xFFFFFFFFU;
     auto const &style = resolve_style(ctx);
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
 
     KnightExtras extras;
     auto it = m_extrasCache.find(seed);
@@ -390,11 +390,11 @@ void registerKnightRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (swordsman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(swordsman_shader);
+          scene_renderer->set_current_shader(swordsman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/archer_renderer.cpp

@@ -88,7 +88,7 @@ public:
 
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -157,14 +157,14 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     using HP = HumanProportions;
 
     auto const &style = resolve_style(ctx);
-    QVector3D team_tint = resolveTeamTint(ctx);
+    QVector3D team_tint = resolve_team_tint(ctx);
 
     auto tint = [&](float k) {
       return QVector3D(clamp01(team_tint.x() * k), clamp01(team_tint.y() * k),
@@ -349,11 +349,11 @@ void registerArcherRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (archer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(archer_shader);
+          scene_renderer->set_current_shader(archer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/ballista_renderer.cpp

@@ -241,8 +241,8 @@ void register_ballista_renderer(EntityRendererRegistry &registry) {
           white = p.resources->white();
         }
         if (auto *scene_renderer = dynamic_cast<Renderer *>(&out)) {
-          unit = scene_renderer->getMeshCube();
-          white = scene_renderer->getWhiteTexture();
+          unit = scene_renderer->get_mesh_cube();
+          white = scene_renderer->get_white_texture();
         }
 
         if (unit == nullptr || white == nullptr) {

render/entity/nations/roman/barracks_renderer.cpp

@@ -282,9 +282,9 @@ void draw_selection(const DrawContext &p, ISubmitter &out) {
   m.translate(pos.x(), 0.0F, pos.z());
   m.scale(2.4F, 1.0F, 2.0F);
   if (p.selected) {
-    out.selectionSmoke(m, QVector3D(0.2F, 0.85F, 0.2F), 0.35F);
+    out.selection_smoke(m, QVector3D(0.2F, 0.85F, 0.2F), 0.35F);
   } else if (p.hovered) {
-    out.selectionSmoke(m, QVector3D(0.95F, 0.92F, 0.25F), 0.22F);
+    out.selection_smoke(m, QVector3D(0.95F, 0.92F, 0.25F), 0.22F);
   }
 }
 

render/entity/nations/roman/catapult_renderer.cpp

@@ -203,37 +203,37 @@ void drawWindlass(const DrawContext &p, ISubmitter &out, Mesh *unit,
 } // namespace
 
 void register_catapult_renderer(EntityRendererRegistry &registry) {
-  registry.register_renderer(
-      "troops/roman/catapult", [](const DrawContext &p, ISubmitter &out) {
-        Mesh *unit_cube = getUnitCube();
-        Texture *white_tex = nullptr;
-
-        if (auto *scene_renderer = dynamic_cast<Renderer *>(&out)) {
-          unit_cube = scene_renderer->getMeshCube();
-          white_tex = scene_renderer->getWhiteTexture();
-        }
-
-        if (unit_cube == nullptr || white_tex == nullptr) {
-          return;
-        }
-
-        QVector3D team_color{0.8F, 0.2F, 0.2F};
-        if (p.entity != nullptr) {
-          if (auto *r =
-                  p.entity->getComponent<Engine::Core::RenderableComponent>()) {
-            team_color = QVector3D(r->color[0], r->color[1], r->color[2]);
-          }
-        }
-
-        auto palette = make_palette(team_color);
-
-        drawBaseFrame(p, out, unit_cube, white_tex, palette);
-        drawWheels(p, out, unit_cube, white_tex, palette);
-        drawTorsionMechanism(p, out, unit_cube, white_tex, palette);
-        drawThrowingArm(p, out, unit_cube, white_tex, palette, p.animation_time);
-        drawWindlass(p, out, unit_cube, white_tex, palette);
-        drawDecorations(p, out, unit_cube, white_tex, palette);
-      });
+  registry.register_renderer("troops/roman/catapult", [](const DrawContext &p,
+                                                         ISubmitter &out) {
+    Mesh *unit_cube = getUnitCube();
+    Texture *white_tex = nullptr;
+
+    if (auto *scene_renderer = dynamic_cast<Renderer *>(&out)) {
+      unit_cube = scene_renderer->get_mesh_cube();
+      white_tex = scene_renderer->get_white_texture();
+    }
+
+    if (unit_cube == nullptr || white_tex == nullptr) {
+      return;
+    }
+
+    QVector3D team_color{0.8F, 0.2F, 0.2F};
+    if (p.entity != nullptr) {
+      if (auto *r =
+              p.entity->getComponent<Engine::Core::RenderableComponent>()) {
+        team_color = QVector3D(r->color[0], r->color[1], r->color[2]);
+      }
+    }
+
+    auto palette = make_palette(team_color);
+
+    drawBaseFrame(p, out, unit_cube, white_tex, palette);
+    drawWheels(p, out, unit_cube, white_tex, palette);
+    drawTorsionMechanism(p, out, unit_cube, white_tex, palette);
+    drawThrowingArm(p, out, unit_cube, white_tex, palette, p.animation_time);
+    drawWindlass(p, out, unit_cube, white_tex, palette);
+    drawDecorations(p, out, unit_cube, white_tex, palette);
+  });
 }
 
 } // namespace Render::GL::Roman

render/entity/nations/roman/healer_renderer.cpp

@@ -81,7 +81,7 @@ public:
 
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -109,10 +109,10 @@ public:
     controller.placeHandAt(false, idle_hand_r);
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {}
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {}
 
   void draw_helmet(const DrawContext &ctx, const HumanoidVariant &v,
                    const HumanoidPose &pose, ISubmitter &out) const override {
@@ -467,11 +467,11 @@ void registerHealerRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (healer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(healer_shader);
+          scene_renderer->set_current_shader(healer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/horse_archer_renderer.cpp

@@ -51,11 +51,11 @@ void register_horse_archer_renderer(EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (horse_archer_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_archer_shader);
+          scene_renderer->set_current_shader(horse_archer_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/horse_spearman_renderer.cpp

@@ -46,11 +46,11 @@ void register_horse_spearman_renderer(EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (horse_spearman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_spearman_shader);
+          scene_renderer->set_current_shader(horse_spearman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/horse_swordsman_renderer.cpp

@@ -48,11 +48,11 @@ void registerMountedKnightRenderer(EntityRendererRegistry &registry) {
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) &&
             (horse_swordsman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(horse_swordsman_shader);
+          scene_renderer->set_current_shader(horse_swordsman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/spearman_renderer.cpp

@@ -119,7 +119,7 @@ private:
 public:
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -177,14 +177,14 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     const AnimationInputs &anim = anim_ctx.inputs;
     uint32_t const seed = reinterpret_cast<uintptr_t>(ctx.entity) & 0xFFFFFFFFU;
     auto const &style = resolve_style(ctx);
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
 
     SpearmanExtras extras;
     auto it = m_extrasCache.find(seed);
@@ -375,11 +375,11 @@ void registerSpearmanRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (spearman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(spearman_shader);
+          scene_renderer->set_current_shader(spearman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/entity/nations/roman/swordsman_renderer.cpp

@@ -114,7 +114,7 @@ private:
 public:
   void get_variant(const DrawContext &ctx, uint32_t seed,
                    HumanoidVariant &v) const override {
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
     v.palette = makeHumanoidPalette(team_tint, seed);
     auto const &style = resolve_style(ctx);
     apply_palette_overrides(style, team_tint, v);
@@ -148,14 +148,14 @@ public:
     }
   }
 
-  void addAttachments(const DrawContext &ctx, const HumanoidVariant &v,
-                      const HumanoidPose &pose,
-                      const HumanoidAnimationContext &anim_ctx,
-                      ISubmitter &out) const override {
+  void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
+                       const HumanoidPose &pose,
+                       const HumanoidAnimationContext &anim_ctx,
+                       ISubmitter &out) const override {
     const AnimationInputs &anim = anim_ctx.inputs;
     uint32_t const seed = reinterpret_cast<uintptr_t>(ctx.entity) & 0xFFFFFFFFU;
     auto const &style = resolve_style(ctx);
-    QVector3D const team_tint = resolveTeamTint(ctx);
+    QVector3D const team_tint = resolve_team_tint(ctx);
 
     KnightExtras extras;
     auto it = m_extrasCache.find(seed);
@@ -394,11 +394,11 @@ void registerKnightRenderer(Render::GL::EntityRendererRegistry &registry) {
         }
         auto *scene_renderer = dynamic_cast<Renderer *>(&out);
         if ((scene_renderer != nullptr) && (swordsman_shader != nullptr)) {
-          scene_renderer->setCurrentShader(swordsman_shader);
+          scene_renderer->set_current_shader(swordsman_shader);
         }
         static_renderer.render(ctx, out);
         if (scene_renderer != nullptr) {
-          scene_renderer->setCurrentShader(nullptr);
+          scene_renderer->set_current_shader(nullptr);
         }
       });
 }

render/equipment/helmets/carthage_heavy_helmet.cpp

@@ -37,7 +37,7 @@ void CarthageHeavyHelmetRenderer::render(const DrawContext &ctx,
   const float helmet_scale = 1.08f;
   auto head_point = [&](const QVector3D &n) {
     QVector3D scaled = n * helmet_scale;
-    return HumanoidRendererBase::frameLocalPosition(head, scaled) +
+    return HumanoidRendererBase::frame_local_position(head, scaled) +
            head.up * lift;
   };
 

render/equipment/helmets/carthage_light_helmet.cpp

@@ -114,7 +114,7 @@ void CarthageLightHelmetRenderer::render_bowl(const DrawContext &ctx,
   QVector3D const helmet_origin = head.origin + helmet_offset;
   auto head_point = [&](const QVector3D &n) {
     QVector3D p = n * helmet_scale;
-    return HumanoidRendererBase::frameLocalPosition(head, p) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, p) + helmet_offset;
   };
 
   QVector3D cap_center = helmet_origin + up * (R * 0.62F);
@@ -183,7 +183,7 @@ void CarthageLightHelmetRenderer::render_brim(const DrawContext &ctx,
   const float R = base_r * helmet_scale;
   QVector3D const helmet_offset = helmet_lift_vector(head);
   auto head_point = [&](const QVector3D &n) {
-    return HumanoidRendererBase::frameLocalPosition(head, n) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, n) + helmet_offset;
   };
 
   auto blade = [&](float sx) {
@@ -219,7 +219,7 @@ void CarthageLightHelmetRenderer::render_cheek_guards(
   const float R = base_r * helmet_scale;
   QVector3D const helmet_offset = helmet_lift_vector(head);
   auto head_point = [&](const QVector3D &n) {
-    return HumanoidRendererBase::frameLocalPosition(head, n) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, n) + helmet_offset;
   };
 
   auto side = [&](float sx) {
@@ -261,7 +261,7 @@ void CarthageLightHelmetRenderer::render_nasal_guard(
   const float R = head.radius;
   QVector3D const helmet_offset = helmet_lift_vector(head);
   auto head_point = [&](const QVector3D &n) {
-    return HumanoidRendererBase::frameLocalPosition(head, n) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, n) + helmet_offset;
   };
 
   QVector3D top = head_point(QVector3D(0.0f, 0.70f, 0.80f));
@@ -292,7 +292,7 @@ void CarthageLightHelmetRenderer::render_crest(const DrawContext &ctx,
   const float R = head.radius;
   QVector3D const helmet_offset = helmet_lift_vector(head);
   auto head_point = [&](const QVector3D &n) {
-    return HumanoidRendererBase::frameLocalPosition(head, n) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, n) + helmet_offset;
   };
 
   QVector3D left = head_point(QVector3D(-0.95f, 1.02f, 0.02f));
@@ -326,7 +326,7 @@ void CarthageLightHelmetRenderer::render_rivets(const DrawContext &ctx,
   const float R = head.radius;
   QVector3D const helmet_offset = helmet_lift_vector(head);
   auto head_point = [&](const QVector3D &n) {
-    return HumanoidRendererBase::frameLocalPosition(head, n) + helmet_offset;
+    return HumanoidRendererBase::frame_local_position(head, n) + helmet_offset;
   };
   QVector3D col = m_config.bronze_color * 1.25f;
 

render/equipment/helmets/headwrap.cpp

@@ -28,7 +28,7 @@ void HeadwrapRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
   }
 
   auto headPoint = [&](const QVector3D &normalized) -> QVector3D {
-    return HumanoidRendererBase::frameLocalPosition(head, normalized);
+    return HumanoidRendererBase::frame_local_position(head, normalized);
   };
 
   QVector3D const band_top = headPoint(QVector3D(0.0F, 0.70F, 0.0F));

render/equipment/helmets/roman_heavy_helmet.cpp

@@ -62,7 +62,7 @@ void RomanHeavyHelmetRenderer::render(const DrawContext &ctx,
   }
 
   auto head_point = [&](const QVector3D &n) {
-    QVector3D p = HumanoidRendererBase::frameLocalPosition(head, n);
+    QVector3D p = HumanoidRendererBase::frame_local_position(head, n);
     return p + head.up * helmet_y_offset;
   };
 

render/equipment/helmets/roman_light_helmet.cpp

@@ -30,7 +30,7 @@ void RomanLightHelmetRenderer::render(const DrawContext &ctx,
   }
 
   auto headPoint = [&](const QVector3D &normalized) -> QVector3D {
-    return HumanoidRendererBase::frameLocalPosition(head, normalized);
+    return HumanoidRendererBase::frame_local_position(head, normalized);
   };
 
   QVector3D const helmet_color =

render/equipment/horse/armor/leather_barding_renderer.cpp

@@ -12,7 +12,7 @@ void LeatherBardingRenderer::render(const DrawContext &ctx,
                                     const HorseAnimationContext &,
                                     ISubmitter &out) const {
 
-  QVector3D const armor_color = variant.saddleColor * 0.90F;
+  QVector3D const armor_color = variant.saddle_color * 0.90F;
 
   const HorseAttachmentFrame &chest = frames.chest;
   QMatrix4x4 chest_armor = chest.make_local_transform(

render/equipment/horse/decorations/plume_renderer.cpp

@@ -16,7 +16,7 @@ void PlumeRenderer::render(const DrawContext &ctx,
 
   const HorseAttachmentFrame &head = frames.head;
 
-  QVector3D const plume_color = variant.blanketColor;
+  QVector3D const plume_color = variant.blanket_color;
   float const sway = std::sin(anim.time * 2.5F) * 0.08F;
 
   QVector3D const base_pos =

render/equipment/horse/decorations/saddle_bag_renderer.cpp

@@ -14,7 +14,7 @@ void SaddleBagRenderer::render(const DrawContext &ctx,
 
   const HorseAttachmentFrame &back = frames.back_center;
 
-  QVector3D const bag_color = variant.saddleColor * 0.85F;
+  QVector3D const bag_color = variant.saddle_color * 0.85F;
 
   for (int i = 0; i < 2; ++i) {
     float const side = (i == 0) ? 1.0F : -1.0F;

render/equipment/horse/decorations/tail_ribbon_renderer.cpp

@@ -15,7 +15,7 @@ void TailRibbonRenderer::render(const DrawContext &ctx,
 
   const HorseAttachmentFrame &tail = frames.tail_base;
 
-  QVector3D const ribbon_color = variant.blanketColor;
+  QVector3D const ribbon_color = variant.blanket_color;
 
   QVector3D const ribbon_start = tail.origin + tail.up * 0.05F;
   QVector3D const ribbon_end =

render/equipment/horse/saddles/carthage_saddle_renderer.cpp

@@ -19,17 +19,17 @@ void CarthageSaddleRenderer::render(const DrawContext &ctx,
 
   QMatrix4x4 seat = saddle_transform;
   seat.scale(0.38F, 0.14F, 1.20F);
-  out.mesh(getUnitSphere(), seat, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), seat, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 pommel = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.020F, 0.18F), 0.19F);
   pommel.scale(0.12F, 0.42F, 0.38F);
-  out.mesh(getUnitSphere(), pommel, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), pommel, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 cantle = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.028F, -0.16F), 0.21F);
   cantle.scale(0.16F, 0.58F, 0.48F);
-  out.mesh(getUnitSphere(), cantle, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), cantle, variant.saddle_color, nullptr, 1.0F, 4);
 }
 
 } // namespace Render::GL

render/equipment/horse/saddles/light_cavalry_saddle_renderer.cpp

@@ -19,17 +19,17 @@ void LightCavalrySaddleRenderer::render(const DrawContext &ctx,
 
   QMatrix4x4 seat = saddle_transform;
   seat.scale(0.32F, 0.12F, 1.05F);
-  out.mesh(getUnitSphere(), seat, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), seat, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 pommel = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.015F, 0.15F), 0.17F);
   pommel.scale(0.10F, 0.35F, 0.35F);
-  out.mesh(getUnitSphere(), pommel, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), pommel, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 cantle = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.020F, -0.15F), 0.17F);
   cantle.scale(0.10F, 0.38F, 0.35F);
-  out.mesh(getUnitSphere(), cantle, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), cantle, variant.saddle_color, nullptr, 1.0F, 4);
 }
 
 } // namespace Render::GL

render/equipment/horse/saddles/roman_saddle_renderer.cpp

@@ -19,24 +19,24 @@ void RomanSaddleRenderer::render(const DrawContext &ctx,
 
   QMatrix4x4 seat = saddle_transform;
   seat.scale(0.34F, 0.15F, 1.10F);
-  out.mesh(getUnitSphere(), seat, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), seat, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 pommel = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.025F, 0.16F), 0.20F);
   pommel.scale(0.14F, 0.48F, 0.40F);
-  out.mesh(getUnitSphere(), pommel, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), pommel, variant.saddle_color, nullptr, 1.0F, 4);
 
   QMatrix4x4 cantle = back.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.03F, -0.12F), 0.22F);
   cantle.scale(0.18F, 0.60F, 0.52F);
-  out.mesh(getUnitSphere(), cantle, variant.saddleColor, nullptr, 1.0F, 4);
+  out.mesh(getUnitSphere(), cantle, variant.saddle_color, nullptr, 1.0F, 4);
 
   for (int i = 0; i < 2; ++i) {
     float const side = (i == 0) ? 1.0F : -1.0F;
     QMatrix4x4 horn = back.make_local_transform(
         ctx.model, QVector3D(0.0F, 0.04F, side * 0.08F), 0.15F);
     horn.scale(0.15F, 0.45F, 0.15F);
-    out.mesh(getUnitSphere(), horn, variant.saddleColor, nullptr, 1.0F, 4);
+    out.mesh(getUnitSphere(), horn, variant.saddle_color, nullptr, 1.0F, 4);
   }
 }
 

render/equipment/horse/tack/blanket_renderer.cpp

@@ -18,7 +18,7 @@ void BlanketRenderer::render(const DrawContext &ctx,
       back.make_local_transform(ctx.model, QVector3D(0.0F, 0.0F, 0.0F), 1.0F);
 
   blanket_transform.scale(0.48F, 0.02F, 0.60F);
-  out.mesh(getUnitSphere(), blanket_transform, variant.blanketColor, nullptr,
+  out.mesh(getUnitSphere(), blanket_transform, variant.blanket_color, nullptr,
            1.0F);
 
   for (int i = 0; i < 2; ++i) {
@@ -26,7 +26,7 @@ void BlanketRenderer::render(const DrawContext &ctx,
     QMatrix4x4 drape = back.make_local_transform(
         ctx.model, QVector3D(side * 0.30F, -0.08F, 0.0F), 0.8F);
     drape.scale(0.22F, 0.15F, 0.55F);
-    out.mesh(getUnitSphere(), drape, variant.blanketColor, nullptr, 1.0F, 4);
+    out.mesh(getUnitSphere(), drape, variant.blanket_color, nullptr, 1.0F, 4);
   }
 }
 

render/gl/backend.cpp

@@ -199,7 +199,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
   const std::size_t count = queue.size();
   std::size_t i = 0;
   while (i < count) {
-    const auto &cmd = queue.getSorted(i);
+    const auto &cmd = queue.get_sorted(i);
     switch (cmd.index()) {
     case CylinderCmdIndex: {
       if (!m_cylinderPipeline) {
@@ -208,7 +208,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       m_cylinderPipeline->m_cylinderScratch.clear();
       do {
-        const auto &cy = std::get<CylinderCmdIndex>(queue.getSorted(i));
+        const auto &cy = std::get<CylinderCmdIndex>(queue.get_sorted(i));
         BackendPipelines::CylinderPipeline::CylinderInstanceGpu gpu{};
         gpu.start = cy.start;
         gpu.end = cy.end;
@@ -217,7 +217,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         gpu.color = cy.color;
         m_cylinderPipeline->m_cylinderScratch.emplace_back(gpu);
         ++i;
-      } while (i < count && queue.getSorted(i).index() == CylinderCmdIndex);
+      } while (i < count && queue.get_sorted(i).index() == CylinderCmdIndex);
 
       const std::size_t instance_count =
           m_cylinderPipeline->m_cylinderScratch.size();
@@ -285,7 +285,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
     }
     case GrassBatchCmdIndex: {
       const auto &grass = std::get<GrassBatchCmdIndex>(cmd);
-      if ((grass.instanceBuffer == nullptr) || grass.instance_count == 0 ||
+      if ((grass.instance_buffer == nullptr) || grass.instance_count == 0 ||
           (m_terrainPipeline->m_grassShader == nullptr) ||
           (m_terrainPipeline->m_grassVao == 0U) ||
           m_terrainPipeline->m_grassVertexCount == 0) {
@@ -344,18 +344,18 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_terrainPipeline->m_grassVao);
-      grass.instanceBuffer->bind();
+      grass.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(GrassInstanceGpu));
       glVertexAttribPointer(
           TexCoord, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, posHeight)));
+          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, pos_height)));
       glVertexAttribPointer(
           InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, colorWidth)));
+          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, color_width)));
       glVertexAttribPointer(
           InstanceScale, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, swayParams)));
-      grass.instanceBuffer->unbind();
+          reinterpret_cast<void *>(offsetof(GrassInstanceGpu, sway_params)));
+      grass.instance_buffer->unbind();
 
       glDrawArraysInstanced(GL_TRIANGLES, 0,
                             m_terrainPipeline->m_grassVertexCount,
@@ -374,7 +374,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         continue;
       }
       const auto &stone = std::get<StoneBatchCmdIndex>(cmd);
-      if ((stone.instanceBuffer == nullptr) || stone.instance_count == 0 ||
+      if ((stone.instance_buffer == nullptr) || stone.instance_count == 0 ||
           (m_vegetationPipeline->stoneShader() == nullptr) ||
           (m_vegetationPipeline->m_stoneVao == 0U) ||
           m_vegetationPipeline->m_stoneIndexCount == 0) {
@@ -407,15 +407,15 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_vegetationPipeline->m_stoneVao);
-      stone.instanceBuffer->bind();
+      stone.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(StoneInstanceGpu));
       glVertexAttribPointer(
           TexCoord, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(StoneInstanceGpu, posScale)));
+          reinterpret_cast<void *>(offsetof(StoneInstanceGpu, pos_scale)));
       glVertexAttribPointer(
           InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(StoneInstanceGpu, colorRot)));
-      stone.instanceBuffer->unbind();
+          reinterpret_cast<void *>(offsetof(StoneInstanceGpu, color_rot)));
+      stone.instance_buffer->unbind();
 
       glDrawElementsInstanced(GL_TRIANGLES,
                               m_vegetationPipeline->m_stoneIndexCount,
@@ -432,7 +432,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       const auto &plant = std::get<PlantBatchCmdIndex>(cmd);
 
-      if ((plant.instanceBuffer == nullptr) || plant.instance_count == 0 ||
+      if ((plant.instance_buffer == nullptr) || plant.instance_count == 0 ||
           (m_vegetationPipeline->plantShader() == nullptr) ||
           (m_vegetationPipeline->m_plantVao == 0U) ||
           m_vegetationPipeline->m_plantIndexCount == 0) {
@@ -489,18 +489,18 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_vegetationPipeline->m_plantVao);
-      plant.instanceBuffer->bind();
+      plant.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(PlantInstanceGpu));
       glVertexAttribPointer(
           InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, posScale)));
+          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, pos_scale)));
       glVertexAttribPointer(
           InstanceScale, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, colorSway)));
+          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, color_sway)));
       glVertexAttribPointer(
           InstanceColor, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, typeParams)));
-      plant.instanceBuffer->unbind();
+          reinterpret_cast<void *>(offsetof(PlantInstanceGpu, type_params)));
+      plant.instance_buffer->unbind();
 
       glDrawElementsInstanced(GL_TRIANGLES,
                               m_vegetationPipeline->m_plantIndexCount,
@@ -521,7 +521,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       const auto &pine = std::get<PineBatchCmdIndex>(cmd);
 
-      if ((pine.instanceBuffer == nullptr) || pine.instance_count == 0 ||
+      if ((pine.instance_buffer == nullptr) || pine.instance_count == 0 ||
           (m_vegetationPipeline->pineShader() == nullptr) ||
           (m_vegetationPipeline->m_pineVao == 0U) ||
           m_vegetationPipeline->m_pineIndexCount == 0) {
@@ -575,18 +575,18 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_vegetationPipeline->m_pineVao);
-      pine.instanceBuffer->bind();
+      pine.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(PineInstanceGpu));
       glVertexAttribPointer(
           InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(PineInstanceGpu, posScale)));
+          reinterpret_cast<void *>(offsetof(PineInstanceGpu, pos_scale)));
       glVertexAttribPointer(
           InstanceScale, Vec4, GL_FLOAT, GL_FALSE, stride,
-          reinterpret_cast<void *>(offsetof(PineInstanceGpu, colorSway)));
+          reinterpret_cast<void *>(offsetof(PineInstanceGpu, color_sway)));
       glVertexAttribPointer(
           InstanceColor, Vec4, GL_FLOAT, GL_FALSE, stride,
           reinterpret_cast<void *>(offsetof(PineInstanceGpu, rotation)));
-      pine.instanceBuffer->unbind();
+      pine.instance_buffer->unbind();
 
       glDrawElementsInstanced(GL_TRIANGLES,
                               m_vegetationPipeline->m_pineIndexCount,
@@ -607,7 +607,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       const auto &olive = std::get<OliveBatchCmdIndex>(cmd);
 
-      if ((olive.instanceBuffer == nullptr) || olive.instance_count == 0 ||
+      if ((olive.instance_buffer == nullptr) || olive.instance_count == 0 ||
           (m_vegetationPipeline->oliveShader() == nullptr) ||
           (m_vegetationPipeline->m_oliveVao == 0U) ||
           m_vegetationPipeline->m_oliveIndexCount == 0) {
@@ -663,7 +663,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_vegetationPipeline->m_oliveVao);
-      olive.instanceBuffer->bind();
+      olive.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(OliveInstanceGpu));
       glVertexAttribPointer(
           InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
@@ -674,7 +674,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       glVertexAttribPointer(
           InstanceColor, Vec4, GL_FLOAT, GL_FALSE, stride,
           reinterpret_cast<void *>(offsetof(OliveInstanceGpu, rotation)));
-      olive.instanceBuffer->unbind();
+      olive.instance_buffer->unbind();
 
       glDrawElementsInstanced(GL_TRIANGLES,
                               m_vegetationPipeline->m_oliveIndexCount,
@@ -695,7 +695,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       const auto &firecamp = std::get<FireCampBatchCmdIndex>(cmd);
 
-      if ((firecamp.instanceBuffer == nullptr) ||
+      if ((firecamp.instance_buffer == nullptr) ||
           firecamp.instance_count == 0 ||
           (m_vegetationPipeline->firecampShader() == nullptr) ||
           (m_vegetationPipeline->m_firecampVao == 0U) ||
@@ -734,19 +734,19 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           Shader::InvalidUniform) {
         firecamp_shader->setUniform(
             m_vegetationPipeline->m_firecampUniforms.flickerSpeed,
-            firecamp.params.flickerSpeed);
+            firecamp.params.flicker_speed);
       }
       if (m_vegetationPipeline->m_firecampUniforms.flickerAmount !=
           Shader::InvalidUniform) {
         firecamp_shader->setUniform(
             m_vegetationPipeline->m_firecampUniforms.flickerAmount,
-            firecamp.params.flickerAmount);
+            firecamp.params.flicker_amount);
       }
       if (m_vegetationPipeline->m_firecampUniforms.glowStrength !=
           Shader::InvalidUniform) {
         firecamp_shader->setUniform(
             m_vegetationPipeline->m_firecampUniforms.glowStrength,
-            firecamp.params.glowStrength);
+            firecamp.params.glow_strength);
       }
       if (m_vegetationPipeline->m_firecampUniforms.camera_right !=
           Shader::InvalidUniform) {
@@ -783,7 +783,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
 
       glBindVertexArray(m_vegetationPipeline->m_firecampVao);
-      firecamp.instanceBuffer->bind();
+      firecamp.instance_buffer->bind();
       const auto stride = static_cast<GLsizei>(sizeof(FireCampInstanceGpu));
       glVertexAttribPointer(InstancePosition, Vec4, GL_FLOAT, GL_FALSE, stride,
                             reinterpret_cast<void *>(
@@ -791,7 +791,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       glVertexAttribPointer(InstanceScale, Vec4, GL_FLOAT, GL_FALSE, stride,
                             reinterpret_cast<void *>(
                                 offsetof(FireCampInstanceGpu, radius_phase)));
-      firecamp.instanceBuffer->unbind();
+      firecamp.instance_buffer->unbind();
 
       glDrawElementsInstanced(GL_TRIANGLES,
                               m_vegetationPipeline->m_firecampIndexCount,
@@ -1424,7 +1424,8 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       case PrimitiveType::Sphere:
         m_primitiveBatchPipeline->uploadSphereInstances(data,
                                                         batch.instance_count());
-        m_primitiveBatchPipeline->drawSpheres(batch.instance_count(), view_proj);
+        m_primitiveBatchPipeline->drawSpheres(batch.instance_count(),
+                                              view_proj);
         break;
       case PrimitiveType::Cylinder:
         m_primitiveBatchPipeline->uploadCylinderInstances(

render/gl/backend/primitive_batch_pipeline.cpp

@@ -80,9 +80,9 @@ void PrimitiveBatchPipeline::setupInstanceAttributes(GLuint vao,
   glVertexAttribDivisor(5, 1);
 
   glEnableVertexAttribArray(6);
-  glVertexAttribPointer(
-      6, Vec4, GL_FLOAT, GL_FALSE, stride,
-      reinterpret_cast<void *>(offsetof(GL::PrimitiveInstanceGpu, color_alpha)));
+  glVertexAttribPointer(6, Vec4, GL_FLOAT, GL_FALSE, stride,
+                        reinterpret_cast<void *>(
+                            offsetof(GL::PrimitiveInstanceGpu, color_alpha)));
   glVertexAttribDivisor(6, 1);
 
   glBindVertexArray(0);

render/ground/biome_renderer.cpp

@@ -104,9 +104,9 @@ void BiomeRenderer::submit(Renderer &renderer, ResourceManager *resources) {
 
   if (m_grassInstanceBuffer && m_grassInstanceCount > 0) {
     GrassBatchParams params = m_grassParams;
-    params.time = renderer.getAnimationTime();
-    renderer.grassBatch(m_grassInstanceBuffer.get(), m_grassInstanceCount,
-                        params);
+    params.time = renderer.get_animation_time();
+    renderer.grass_batch(m_grassInstanceBuffer.get(), m_grassInstanceCount,
+                         params);
   }
 }
 

render/ground/bridge_renderer.cpp

@@ -222,15 +222,15 @@ void BridgeRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   auto &visibility = Game::Map::VisibilityService::instance();
   const bool use_visibility = visibility.isInitialized();
 
-  auto *shader = renderer.getShader("bridge");
+  auto *shader = renderer.get_shader("bridge");
   if (shader == nullptr) {
-    shader = renderer.getShader("basic");
+    shader = renderer.get_shader("basic");
     if (shader == nullptr) {
       return;
     }
   }
 
-  renderer.setCurrentShader(shader);
+  renderer.set_current_shader(shader);
 
   QMatrix4x4 model;
   model.setToIdentity();
@@ -291,7 +291,7 @@ void BridgeRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     renderer.mesh(mesh, model, final_color, nullptr, alpha);
   }
 
-  renderer.setCurrentShader(nullptr);
+  renderer.set_current_shader(nullptr);
 }
 
 } // namespace Render::GL

render/ground/firecamp_renderer.cpp

@@ -134,12 +134,13 @@ void FireCampRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   FireCampBatchParams params = m_fireCampParams;
-  params.time = renderer.getAnimationTime();
+  params.time = renderer.get_animation_time();
   params.flicker_amount = m_fireCampParams.flicker_amount *
-                         (0.9F + 0.25F * std::sin(params.time * 1.3F));
+                          (0.9F + 0.25F * std::sin(params.time * 1.3F));
   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);
+                         (0.85F + 0.2F * std::sin(params.time * 1.7F + 1.2F));
+  renderer.firecamp_batch(m_fireCampInstanceBuffer.get(), visible_count,
+                          params);
 
   const QVector3D log_color(0.26F, 0.15F, 0.08F);
   const QVector3D char_color(0.08F, 0.05F, 0.03F);

render/ground/fog_renderer.cpp

@@ -40,7 +40,7 @@ void FogRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   (void)resources;
 
   if (!m_instances.empty()) {
-    renderer.fogBatch(m_instances.data(), m_instances.size());
+    renderer.fog_batch(m_instances.data(), m_instances.size());
   }
 }
 

render/ground/ground_renderer.cpp

@@ -166,7 +166,7 @@ void GroundRenderer::submit(Renderer &renderer, ResourceManager *resources) {
       (void)model_changed;
       (void)state_changed;
 
-      renderer.terrainChunk(plane, m_model, params, 0x0040U, true, +0.0008F);
+      renderer.terrain_chunk(plane, m_model, params, 0x0040U, true, +0.0008F);
 
       m_lastSubmittedModel = m_model;
       m_modelDirty = false;

render/ground/olive_renderer.cpp

@@ -120,8 +120,8 @@ void OliveRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   OliveBatchParams params = m_oliveParams;
-  params.time = renderer.getAnimationTime();
-  renderer.oliveBatch(m_oliveInstanceBuffer.get(), visible_count, params);
+  params.time = renderer.get_animation_time();
+  renderer.olive_batch(m_oliveInstanceBuffer.get(), visible_count, params);
 }
 
 void OliveRenderer::clear() {

render/ground/pine_renderer.cpp

@@ -120,8 +120,8 @@ void PineRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   PineBatchParams params = m_pineParams;
-  params.time = renderer.getAnimationTime();
-  renderer.pineBatch(m_pineInstanceBuffer.get(), visible_count, params);
+  params.time = renderer.get_animation_time();
+  renderer.pine_batch(m_pineInstanceBuffer.get(), visible_count, params);
 }
 
 void PineRenderer::clear() {

render/ground/plant_renderer.cpp

@@ -122,8 +122,8 @@ void PlantRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   PlantBatchParams params = m_plantParams;
-  params.time = renderer.getAnimationTime();
-  renderer.plantBatch(m_visibleInstanceBuffer.get(), visible_count, params);
+  params.time = renderer.get_animation_time();
+  renderer.plant_batch(m_visibleInstanceBuffer.get(), visible_count, params);
 }
 
 void PlantRenderer::clear() {

render/ground/river_renderer.cpp

@@ -162,12 +162,12 @@ void RiverRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   auto &visibility = Game::Map::VisibilityService::instance();
   const bool use_visibility = visibility.isInitialized();
 
-  auto *shader = renderer.getShader("river");
+  auto *shader = renderer.get_shader("river");
   if (shader == nullptr) {
     return;
   }
 
-  renderer.setCurrentShader(shader);
+  renderer.set_current_shader(shader);
 
   QMatrix4x4 model;
   model.setToIdentity();
@@ -225,7 +225,7 @@ void RiverRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     renderer.mesh(mesh, model, final_color, nullptr, alpha);
   }
 
-  renderer.setCurrentShader(nullptr);
+  renderer.set_current_shader(nullptr);
 }
 
 } // namespace Render::GL

render/ground/riverbank_renderer.cpp

@@ -250,12 +250,12 @@ void RiverbankRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   auto &visibility = Game::Map::VisibilityService::instance();
   const bool use_visibility = visibility.isInitialized();
 
-  auto *shader = renderer.getShader("riverbank");
+  auto *shader = renderer.get_shader("riverbank");
   if (shader == nullptr) {
     return;
   }
 
-  renderer.setCurrentShader(shader);
+  renderer.set_current_shader(shader);
 
   QMatrix4x4 model;
   model.setToIdentity();
@@ -298,7 +298,7 @@ void RiverbankRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     renderer.mesh(mesh, model, QVector3D(1.0F, 1.0F, 1.0F), nullptr, 1.0F);
   }
 
-  renderer.setCurrentShader(nullptr);
+  renderer.set_current_shader(nullptr);
 }
 
 } // namespace Render::GL

render/ground/road_renderer.cpp

@@ -155,16 +155,16 @@ void RoadRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   auto &visibility = Game::Map::VisibilityService::instance();
   const bool use_visibility = visibility.isInitialized();
 
-  auto *shader = renderer.getShader("road");
+  auto *shader = renderer.get_shader("road");
   if (shader == nullptr) {
 
-    shader = renderer.getShader("terrain");
+    shader = renderer.get_shader("terrain");
     if (shader == nullptr) {
       return;
     }
   }
 
-  renderer.setCurrentShader(shader);
+  renderer.set_current_shader(shader);
 
   QMatrix4x4 model;
   model.setToIdentity();
@@ -225,7 +225,7 @@ void RoadRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     renderer.mesh(mesh, model, final_color, nullptr, alpha);
   }
 
-  renderer.setCurrentShader(nullptr);
+  renderer.set_current_shader(nullptr);
 }
 
 } // namespace Render::GL

render/ground/stone_renderer.cpp

@@ -83,8 +83,8 @@ void StoneRenderer::submit(Renderer &renderer, ResourceManager *resources) {
     return;
   }
 
-  renderer.stoneBatch(m_stoneInstanceBuffer.get(), m_stoneInstanceCount,
-                      m_stoneParams);
+  renderer.stone_batch(m_stoneInstanceBuffer.get(), m_stoneInstanceCount,
+                       m_stoneParams);
 }
 
 void StoneRenderer::clear() {

render/ground/terrain_renderer.cpp

@@ -122,8 +122,8 @@ void TerrainRenderer::submit(Renderer &renderer, ResourceManager *resources) {
       }
     }
 
-    renderer.terrainChunk(chunk.mesh.get(), k_identity_matrix, chunk.params,
-                          0x0080U, true, 0.0F);
+    renderer.terrain_chunk(chunk.mesh.get(), k_identity_matrix, chunk.params,
+                           0x0080U, true, 0.0F);
   }
 }
 

render/horse/horse_animation_controller.cpp

@@ -10,12 +10,12 @@ namespace {
 constexpr float k_pi = std::numbers::pi_v<float>;
 
 struct GaitParameters {
-  float cycleTime;
-  float frontLegPhase;
-  float rearLegPhase;
-  float strideSwing;
-  float strideLift;
-  float bobAmplitude;
+  float cycle_time;
+  float front_leg_phase;
+  float rear_leg_phase;
+  float stride_swing;
+  float stride_lift;
+  float bob_amplitude;
 };
 
 constexpr GaitParameters getGaitParams(GaitType gait) {
@@ -99,7 +99,7 @@ void HorseAnimationController::idle(float bob_intensity) {
 
   float const phase = std::fmod(m_anim.time * 0.25F, 1.0F);
   m_phase = phase;
-  m_bob = std::sin(phase * 2.0F * k_pi) * m_profile.dims.idleBobAmplitude *
+  m_bob = std::sin(phase * 2.0F * k_pi) * m_profile.dims.idle_bob_amplitude *
           bob_intensity;
 
   updateGaitParameters();
@@ -176,7 +176,7 @@ auto HorseAnimationController::getCurrentBob() const -> float { return m_bob; }
 
 auto HorseAnimationController::getStrideCycle() const -> float {
   GaitParameters const params = getGaitParams(m_current_gait);
-  return params.cycleTime;
+  return params.cycle_time;
 }
 
 void HorseAnimationController::updateGaitParameters() {
@@ -199,28 +199,28 @@ void HorseAnimationController::updateGaitParameters() {
 
     float const ease_t = t * t * (3.0F - 2.0F * t);
 
-    m_profile.gait.cycleTime =
-        current_params.cycleTime +
-        ease_t * (target_params.cycleTime - current_params.cycleTime);
-    m_profile.gait.frontLegPhase =
-        current_params.frontLegPhase +
-        ease_t * (target_params.frontLegPhase - current_params.frontLegPhase);
-    m_profile.gait.rearLegPhase =
-        current_params.rearLegPhase +
-        ease_t * (target_params.rearLegPhase - current_params.rearLegPhase);
-    m_profile.gait.strideSwing =
-        current_params.strideSwing +
-        ease_t * (target_params.strideSwing - current_params.strideSwing);
-    m_profile.gait.strideLift =
-        current_params.strideLift +
-        ease_t * (target_params.strideLift - current_params.strideLift);
+    m_profile.gait.cycle_time =
+        current_params.cycle_time +
+        ease_t * (target_params.cycle_time - current_params.cycle_time);
+    m_profile.gait.front_leg_phase = current_params.front_leg_phase +
+                                     ease_t * (target_params.front_leg_phase -
+                                               current_params.front_leg_phase);
+    m_profile.gait.rear_leg_phase =
+        current_params.rear_leg_phase +
+        ease_t * (target_params.rear_leg_phase - current_params.rear_leg_phase);
+    m_profile.gait.stride_swing =
+        current_params.stride_swing +
+        ease_t * (target_params.stride_swing - current_params.stride_swing);
+    m_profile.gait.stride_lift =
+        current_params.stride_lift +
+        ease_t * (target_params.stride_lift - current_params.stride_lift);
   } else {
 
-    m_profile.gait.cycleTime = current_params.cycleTime;
-    m_profile.gait.frontLegPhase = current_params.frontLegPhase;
-    m_profile.gait.rearLegPhase = current_params.rearLegPhase;
-    m_profile.gait.strideSwing = current_params.strideSwing;
-    m_profile.gait.strideLift = current_params.strideLift;
+    m_profile.gait.cycle_time = current_params.cycle_time;
+    m_profile.gait.front_leg_phase = current_params.front_leg_phase;
+    m_profile.gait.rear_leg_phase = current_params.rear_leg_phase;
+    m_profile.gait.stride_swing = current_params.stride_swing;
+    m_profile.gait.stride_lift = current_params.stride_lift;
   }
 
   bool const is_moving = m_current_gait != GaitType::IDLE;
@@ -230,20 +230,20 @@ void HorseAnimationController::updateGaitParameters() {
     if (m_rider_ctx.gait.cycle_time > 0.0001F) {
       m_phase = m_rider_ctx.gait.cycle_phase;
     } else {
-      m_phase = std::fmod(m_anim.time / m_profile.gait.cycleTime, 1.0F);
+      m_phase = std::fmod(m_anim.time / m_profile.gait.cycle_time, 1.0F);
     }
 
     float const rider_intensity = m_rider_ctx.locomotion_normalized_speed();
-    float const bob_amp = m_profile.dims.idleBobAmplitude +
-                          rider_intensity * (m_profile.dims.moveBobAmplitude -
-                                             m_profile.dims.idleBobAmplitude);
+    float const bob_amp = m_profile.dims.idle_bob_amplitude +
+                          rider_intensity * (m_profile.dims.move_bob_amplitude -
+                                             m_profile.dims.idle_bob_amplitude);
 
     float const variation = std::sin(m_anim.time * 0.7F) * 0.05F + 1.0F;
     m_bob = std::sin(m_phase * 2.0F * k_pi) * bob_amp * variation;
   } else {
 
     m_phase = std::fmod(m_anim.time * 0.25F, 1.0F);
-    m_bob = std::sin(m_phase * 2.0F * k_pi) * m_profile.dims.idleBobAmplitude;
+    m_bob = std::sin(m_phase * 2.0F * k_pi) * m_profile.dims.idle_bob_amplitude;
   }
 
   float rein_tension = m_rider_ctx.locomotion_normalized_speed();

render/horse/rig.cpp

@@ -194,13 +194,14 @@ auto make_horse_dimensions(uint32_t seed) -> HorseDimensions {
   float const shoulder_to_barrel_offset = d.body_height * 0.05F + 0.05F;
   d.barrel_center_y = leg_down_distance - shoulder_to_barrel_offset;
 
-  d.saddle_height = d.barrel_center_y + d.body_height * 0.55F + d.saddle_thickness;
+  d.saddle_height =
+      d.barrel_center_y + d.body_height * 0.55F + d.saddle_thickness;
 
   return d;
 }
 
 auto make_horse_variant(uint32_t seed, const QVector3D &leather_base,
-                      const QVector3D &cloth_base) -> HorseVariant {
+                        const QVector3D &cloth_base) -> HorseVariant {
   HorseVariant v;
 
   float const coat_hue = hash01(seed ^ 0x23456U);
@@ -247,7 +248,7 @@ auto make_horse_variant(uint32_t seed, const QVector3D &leather_base,
 }
 
 auto make_horse_profile(uint32_t seed, const QVector3D &leather_base,
-                      const QVector3D &cloth_base) -> HorseProfile {
+                        const QVector3D &cloth_base) -> HorseProfile {
   HorseProfile profile;
   profile.dims = make_horse_dimensions(seed);
   profile.variant = make_horse_variant(seed, leather_base, cloth_base);
@@ -304,9 +305,9 @@ auto compute_mount_frame(const HorseProfile &profile)
   frame.stirrup_bottom_right =
       frame.stirrup_attach_right + QVector3D(0.0F, -d.stirrup_drop, 0.0F);
 
-  QVector3D const neck_top(0.0F,
-                           d.barrel_center_y + d.body_height * 0.65F + d.neck_rise,
-                           d.body_length * 0.25F);
+  QVector3D const neck_top(
+      0.0F, d.barrel_center_y + d.body_height * 0.65F + d.neck_rise,
+      d.body_length * 0.25F);
   QVector3D const head_center =
       neck_top + QVector3D(0.0F, d.head_height * 0.10F, d.head_length * 0.40F);
 
@@ -512,7 +513,8 @@ void HorseRendererBase::render_full(
   {
     QMatrix4x4 rump = horse_ctx.model;
     rump.translate(rump_center);
-    rump.scale(d.body_width * 1.18F, d.body_height * 1.00F, d.body_length * 0.36F);
+    rump.scale(d.body_width * 1.18F, d.body_height * 1.00F,
+               d.body_length * 0.36F);
     QVector3D const rump_color =
         coatGradient(v.coat_color, 0.62F, -0.28F, coat_seed_a * 0.7F);
     out.mesh(getUnitSphere(), rump, rump_color, nullptr, 1.0F, 6);
@@ -524,7 +526,8 @@ void HorseRendererBase::render_full(
     hip.translate(rump_center + QVector3D(side * d.body_width * 0.95F,
                                           -d.body_height * 0.10F,
                                           -d.body_length * 0.08F));
-    hip.scale(d.body_width * 0.45F, d.body_height * 0.42F, d.body_length * 0.26F);
+    hip.scale(d.body_width * 0.45F, d.body_height * 0.42F,
+              d.body_length * 0.26F);
     QVector3D const hip_color =
         coatGradient(v.coat_color, 0.58F, -0.18F, coat_seed_b + side * 0.06F);
     out.mesh(getUnitSphere(), hip, hip_color, nullptr, 1.0F, 6);
@@ -750,8 +753,9 @@ void HorseRendererBase::render_full(
              1.0F, 6);
   }
 
-  QVector3D bridle_base = muzzle_center + QVector3D(0.0F, -d.head_height * 0.05F,
-                                                    d.muzzle_length * 0.20F);
+  QVector3D bridle_base =
+      muzzle_center +
+      QVector3D(0.0F, -d.head_height * 0.05F, d.muzzle_length * 0.20F);
   mount.bridle_base = bridle_base;
   QVector3D const cheek_anchor_left =
       head_center + QVector3D(d.head_width * 0.55F, d.head_height * 0.05F,
@@ -800,8 +804,8 @@ void HorseRendererBase::render_full(
       QVector3D const strand_base =
           forelock_base + QVector3D(offset, 0.0F, 0.0F);
       QVector3D const strand_tip =
-          strand_base +
-          QVector3D(offset * 0.4F, -d.head_height * 0.25F, d.head_length * 0.12F);
+          strand_base + QVector3D(offset * 0.4F, -d.head_height * 0.25F,
+                                  d.head_length * 0.12F);
       drawCone(out, horse_ctx.model, strand_tip, strand_base,
                d.head_width * 0.10F, v.mane_color * (0.94F + 0.03F * i), 0.96F,
                7);
@@ -812,7 +816,8 @@ void HorseRendererBase::render_full(
       rump_center +
       QVector3D(0.0F, d.body_height * 0.36F, -d.body_length * 0.34F);
   QVector3D const tail_ctrl =
-      tail_base + QVector3D(0.0F, -d.tail_length * 0.20F, -d.tail_length * 0.28F);
+      tail_base +
+      QVector3D(0.0F, -d.tail_length * 0.20F, -d.tail_length * 0.28F);
   QVector3D const tail_end =
       tail_base + QVector3D(0.0F, -d.tail_length, -d.tail_length * 0.70F);
   QVector3D const tail_color = lerp3(v.tail_color, v.mane_color, 0.35F);
@@ -844,8 +849,8 @@ void HorseRendererBase::render_full(
   for (int i = 0; i < 3; ++i) {
     float const spread = (i - 1) * d.body_width * 0.14F;
     QVector3D const fan_base =
-        tail_end +
-        QVector3D(spread * 0.15F, -d.body_width * 0.05F, -d.tail_length * 0.08F);
+        tail_end + QVector3D(spread * 0.15F, -d.body_width * 0.05F,
+                             -d.tail_length * 0.08F);
     QVector3D const fan_tip =
         fan_base +
         QVector3D(spread, -d.tail_length * 0.32F, -d.tail_length * 0.22F);
@@ -908,12 +913,13 @@ void HorseRendererBase::render_full(
 
     bool const is_rear = (forwardBias < 0.0F);
     if (!is_rear) {
-      stride = std::clamp(stride, -d.body_length * 0.02F, d.body_length * 0.18F);
+      stride =
+          std::clamp(stride, -d.body_length * 0.02F, d.body_length * 0.18F);
     }
 
     bool const tighten_legs = is_moving;
-    float const shoulder_out =
-        d.body_width * (tighten_legs ? 0.42F : 0.56F) * (is_rear ? 0.96F : 1.0F);
+    float const shoulder_out = d.body_width * (tighten_legs ? 0.42F : 0.56F) *
+                               (is_rear ? 0.96F : 1.0F);
     float const shoulder_height = (is_rear ? 0.02F : 0.05F);
     float const stance_pull =
         is_rear ? -d.body_length * 0.04F : d.body_length * 0.05F;
@@ -1199,7 +1205,7 @@ void HorseRendererBase::render_full(
   body_frames.muzzle.forward = forward;
 
   draw_attachments(horse_ctx, anim, rider_ctx, profile, mount, phase, bob,
-                  rein_slack, body_frames, out);
+                   rein_slack, body_frames, out);
 }
 
 void HorseRendererBase::render_simplified(
@@ -1234,7 +1240,8 @@ void HorseRendererBase::render_simplified(
   {
     QMatrix4x4 body = horse_ctx.model;
     body.translate(barrel_center);
-    body.scale(d.body_width * 1.0F, d.body_height * 0.85F, d.body_length * 0.80F);
+    body.scale(d.body_width * 1.0F, d.body_height * 0.85F,
+               d.body_length * 0.80F);
     out.mesh(getUnitSphere(), body, v.coat_color, nullptr, 1.0F, 6);
   }
 
@@ -1251,7 +1258,8 @@ void HorseRendererBase::render_simplified(
   {
     QMatrix4x4 head = horse_ctx.model;
     head.translate(head_center);
-    head.scale(d.head_width * 0.90F, d.head_height * 0.85F, d.head_length * 0.75F);
+    head.scale(d.head_width * 0.90F, d.head_height * 0.85F,
+               d.head_length * 0.75F);
     out.mesh(getUnitSphere(), head, v.coat_color, nullptr, 1.0F);
   }
 
@@ -1300,9 +1308,9 @@ void HorseRendererBase::render_simplified(
 }
 
 void HorseRendererBase::render_minimal(const DrawContext &ctx,
-                                      HorseProfile &profile,
-                                      const HorseMotionSample *shared_motion,
-                                      ISubmitter &out) const {
+                                       HorseProfile &profile,
+                                       const HorseMotionSample *shared_motion,
+                                       ISubmitter &out) const {
 
   const HorseDimensions &d = profile.dims;
   const HorseVariant &v = profile.variant;
@@ -1350,7 +1358,7 @@ void HorseRendererBase::render(const DrawContext &ctx,
   ++s_horseRenderStats.horses_total;
 
   if (lod == HorseLOD::Billboard) {
-    ++s_horseRenderStats.horsesSkippedLOD;
+    ++s_horseRenderStats.horses_skipped_lod;
     return;
   }
 
@@ -1360,13 +1368,13 @@ void HorseRendererBase::render(const DrawContext &ctx,
   case HorseLOD::Full:
     ++s_horseRenderStats.lod_full;
     render_full(ctx, anim, rider_ctx, profile, shared_mount, shared_reins,
-               shared_motion, out);
+                shared_motion, out);
     break;
 
   case HorseLOD::Reduced:
     ++s_horseRenderStats.lod_reduced;
-    render_simplified(ctx, anim, rider_ctx, profile, shared_mount, shared_motion,
-                     out);
+    render_simplified(ctx, anim, rider_ctx, profile, shared_mount,
+                      shared_motion, out);
     break;
 
   case HorseLOD::Minimal:

render/horse/rig.h

@@ -161,9 +161,9 @@ struct HorseMotionSample {
 
 auto make_horse_dimensions(uint32_t seed) -> HorseDimensions;
 auto make_horse_variant(uint32_t seed, const QVector3D &leather_base,
-                      const QVector3D &cloth_base) -> HorseVariant;
+                        const QVector3D &cloth_base) -> HorseVariant;
 auto make_horse_profile(uint32_t seed, const QVector3D &leather_base,
-                      const QVector3D &cloth_base) -> HorseProfile;
+                        const QVector3D &cloth_base) -> HorseProfile;
 auto compute_mount_frame(const HorseProfile &profile) -> MountedAttachmentFrame;
 auto compute_rein_state(uint32_t horse_seed,
                         const HumanoidAnimationContext &rider_ctx) -> ReinState;
@@ -215,31 +215,31 @@ public:
               const HorseMotionSample *shared_motion, ISubmitter &out) const;
 
   void render_simplified(const DrawContext &ctx, const AnimationInputs &anim,
-                        const HumanoidAnimationContext &rider_ctx,
-                        HorseProfile &profile,
-                        const MountedAttachmentFrame *shared_mount,
-                        const HorseMotionSample *shared_motion,
-                        ISubmitter &out) const;
+                         const HumanoidAnimationContext &rider_ctx,
+                         HorseProfile &profile,
+                         const MountedAttachmentFrame *shared_mount,
+                         const HorseMotionSample *shared_motion,
+                         ISubmitter &out) const;
 
   void render_minimal(const DrawContext &ctx, HorseProfile &profile,
-                     const HorseMotionSample *shared_motion,
-                     ISubmitter &out) const;
+                      const HorseMotionSample *shared_motion,
+                      ISubmitter &out) const;
 
 protected:
   virtual void draw_attachments(const DrawContext &, const AnimationInputs &,
-                               const HumanoidAnimationContext &, HorseProfile &,
-                               const MountedAttachmentFrame &, float, float,
-                               float, const HorseBodyFrames &,
-                               ISubmitter &) const {}
+                                const HumanoidAnimationContext &,
+                                HorseProfile &, const MountedAttachmentFrame &,
+                                float, float, float, const HorseBodyFrames &,
+                                ISubmitter &) const {}
 
 private:
   void render_full(const DrawContext &ctx, const AnimationInputs &anim,
-                  const HumanoidAnimationContext &rider_ctx,
-                  HorseProfile &profile,
-                  const MountedAttachmentFrame *shared_mount,
-                  const ReinState *shared_reins,
-                  const HorseMotionSample *shared_motion,
-                  ISubmitter &out) const;
+                   const HumanoidAnimationContext &rider_ctx,
+                   HorseProfile &profile,
+                   const MountedAttachmentFrame *shared_mount,
+                   const ReinState *shared_reins,
+                   const HorseMotionSample *shared_motion,
+                   ISubmitter &out) const;
 };
 
 inline auto calculate_horse_lod(float distance) -> HorseLOD {

render/humanoid/mounted_pose_controller.cpp

@@ -174,13 +174,13 @@ void MountedPoseController::applySaddleClearance(
     const MountedAttachmentFrame &mount, const HorseDimensions &dims,
     float forward_bias, float up_bias) {
   float const forward_pull =
-      std::max(0.0F, forward_bias) * (dims.bodyWidth * 0.12F) +
-      dims.seatForwardOffset * 0.30F;
+      std::max(0.0F, forward_bias) * (dims.body_width * 0.12F) +
+      dims.seat_forward_offset * 0.30F;
   float const up_lift =
-      std::max(0.0F, up_bias) * (dims.saddleThickness * 0.85F);
+      std::max(0.0F, up_bias) * (dims.saddle_thickness * 0.85F);
 
   QVector3D const offset = -mount.seat_forward * forward_pull +
-                           mount.seat_up * (up_lift + dims.bodyHeight * 0.01F);
+                           mount.seat_up * (up_lift + dims.body_height * 0.01F);
   m_pose.pelvis_pos += offset;
   translateUpperBody(offset);
   calculateRidingKnees(mount);
@@ -207,7 +207,7 @@ void MountedPoseController::stabilizeUpperBody(
   m_pose.shoulder_l += mid_offset;
   m_pose.shoulder_r += mid_offset;
 
-  float const desired_half = std::clamp(dims.bodyWidth * 0.44F, 0.10F, 0.32F);
+  float const desired_half = std::clamp(dims.body_width * 0.44F, 0.10F, 0.32F);
   m_pose.shoulder_l = desired_mid - right_flat * desired_half;
   m_pose.shoulder_r = desired_mid + right_flat * desired_half;
 
@@ -347,8 +347,8 @@ void MountedPoseController::applyShieldDefense(
 void MountedPoseController::applyShieldStowed(
     const MountedAttachmentFrame &mount, const HorseDimensions &dims) {
   QVector3D const rest =
-      seatRelative(mount, dims.bodyLength * -0.05F, -dims.bodyWidth * 0.55F,
-                   dims.saddleThickness * 0.5F);
+      seatRelative(mount, dims.body_length * -0.05F, -dims.body_width * 0.55F,
+                   dims.saddle_thickness * 0.5F);
   getHand(true) = rest;
   const QVector3D left_outward = computeOutwardDir(true);
   getElbow(true) = solveElbowIK(true, getShoulder(true), rest, left_outward,
@@ -361,9 +361,10 @@ void MountedPoseController::applySwordIdlePose(
     const MountedAttachmentFrame &mount, const HorseDimensions &dims) {
   QVector3D const shoulder_r = getShoulder(false);
   QVector3D const sword_anchor =
-      shoulder_r + mount.seat_right * (dims.bodyWidth * 0.90F) +
-      mount.seat_forward * (dims.bodyLength * 0.22F) +
-      mount.seat_up * (dims.bodyHeight * 0.06F + dims.saddleThickness * 0.10F);
+      shoulder_r + mount.seat_right * (dims.body_width * 0.90F) +
+      mount.seat_forward * (dims.body_length * 0.22F) +
+      mount.seat_up *
+          (dims.body_height * 0.06F + dims.saddle_thickness * 0.10F);
 
   getHand(false) = sword_anchor;
   const QVector3D right_outward = computeOutwardDir(false);

render/humanoid/rig.cpp

@@ -151,7 +151,7 @@ auto HumanoidRendererBase::make_frame_local_transform(
     scale = uniform_scale;
   }
 
-  QVector3D const origin = frameLocalPosition(frame, local_offset);
+  QVector3D const origin = frame_local_position(frame, local_offset);
 
   QMatrix4x4 local;
   local.setColumn(0, QVector4D(frame.right * scale, 0.0F));
@@ -174,7 +174,7 @@ auto HumanoidRendererBase::make_head_local_transform(
 
 void HumanoidRendererBase::get_variant(const DrawContext &ctx, uint32_t seed,
                                        HumanoidVariant &v) const {
-  QVector3D const team_tint = resolveTeamTint(ctx);
+  QVector3D const team_tint = resolve_team_tint(ctx);
   v.palette = makeHumanoidPalette(team_tint, seed);
 }
 
@@ -183,10 +183,10 @@ void HumanoidRendererBase::customize_pose(const DrawContext &,
                                           uint32_t, HumanoidPose &) const {}
 
 void HumanoidRendererBase::add_attachments(const DrawContext &,
-                                          const HumanoidVariant &,
-                                          const HumanoidPose &,
-                                          const HumanoidAnimationContext &,
-                                          ISubmitter &) const {}
+                                           const HumanoidVariant &,
+                                           const HumanoidPose &,
+                                           const HumanoidAnimationContext &,
+                                           ISubmitter &) const {}
 
 auto HumanoidRendererBase::resolve_entity_ground_offset(
     const DrawContext &, Engine::Core::UnitComponent *unit_comp,
@@ -399,9 +399,9 @@ void HumanoidRendererBase::compute_locomotion_pose(
 }
 
 void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
-                                          const HumanoidVariant &v,
-                                          HumanoidPose &pose,
-                                          ISubmitter &out) const {
+                                            const HumanoidVariant &v,
+                                            HumanoidPose &pose,
+                                            ISubmitter &out) const {
   using HP = HumanProportions;
 
   QVector3D const scaling = get_proportion_scaling();
@@ -694,7 +694,7 @@ void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
   QVector3D const iris = QVector3D(0.10F, 0.10F, 0.12F);
   auto eyePosition = [&](float lateral) {
     QVector3D const local(lateral, 0.12F, 0.92F);
-    QVector3D world = frameLocalPosition(pose.body_frames.head, local);
+    QVector3D world = frame_local_position(pose.body_frames.head, local);
     world +=
         pose.body_frames.head.forward * (pose.body_frames.head.radius * 0.02F);
     return world;
@@ -800,19 +800,17 @@ void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
   draw_foot(pose.foot_r, false);
 
   draw_armor_overlay(ctx, v, pose, y_top_cover, torso_r, shoulder_half_span,
-                    upper_arm_r, right_axis, out);
+                     upper_arm_r, right_axis, out);
 
   draw_shoulder_decorations(ctx, v, pose, y_top_cover, pose.neck_base.y(),
-                          right_axis, out);
+                            right_axis, out);
 
   draw_helmet(ctx, v, pose, out);
 }
 
-void HumanoidRendererBase::draw_armor_overlay(const DrawContext &,
-                                             const HumanoidVariant &,
-                                             const HumanoidPose &, float, float,
-                                             float, float, const QVector3D &,
-                                             ISubmitter &) const {}
+void HumanoidRendererBase::draw_armor_overlay(
+    const DrawContext &, const HumanoidVariant &, const HumanoidPose &, float,
+    float, float, float, const QVector3D &, ISubmitter &) const {}
 
 void HumanoidRendererBase::draw_armor(const DrawContext &,
                                       const HumanoidVariant &,
@@ -820,11 +818,9 @@ void HumanoidRendererBase::draw_armor(const DrawContext &,
                                       const HumanoidAnimationContext &,
                                       ISubmitter &) const {}
 
-void HumanoidRendererBase::draw_shoulder_decorations(const DrawContext &,
-                                                   const HumanoidVariant &,
-                                                   const HumanoidPose &, float,
-                                                   float, const QVector3D &,
-                                                   ISubmitter &) const {}
+void HumanoidRendererBase::draw_shoulder_decorations(
+    const DrawContext &, const HumanoidVariant &, const HumanoidPose &, float,
+    float, const QVector3D &, ISubmitter &) const {}
 
 void HumanoidRendererBase::draw_helmet(const DrawContext &,
                                        const HumanoidVariant &,
@@ -832,9 +828,9 @@ void HumanoidRendererBase::draw_helmet(const DrawContext &,
                                        ISubmitter &) const {}
 
 void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
-                                          const HumanoidVariant &v,
-                                          const HumanoidPose &pose,
-                                          ISubmitter &out) const {
+                                            const HumanoidVariant &v,
+                                            const HumanoidPose &pose,
+                                            ISubmitter &out) const {
   const FacialHairParams &fh = v.facial_hair;
 
   if (fh.style == FacialHairStyle::None || fh.coverage < 0.01F) {
@@ -935,7 +931,7 @@ void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
         surface_dir /= dir_len;
 
         float const shell = 1.02F + jitter(0.03F);
-        QVector3D const root = frameLocalPosition(frame, surface_dir * shell);
+        QVector3D const root = frame_local_position(frame, surface_dir * shell);
 
         QVector3D local_dir(jitter(0.15F),
                             -(0.55F + row_t * 0.30F) + jitter(0.10F),
@@ -1014,7 +1010,7 @@ void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
         }
         surface_dir /= dir_len;
         QVector3D const root =
-            frameLocalPosition(frame, surface_dir * (1.01F + jitter(0.02F)));
+            frame_local_position(frame, surface_dir * (1.01F + jitter(0.02F)));
 
         QVector3D const dir_local(side * (0.55F + jitter(0.12F)), jitter(0.06F),
                                   0.34F + jitter(0.08F));
@@ -1106,9 +1102,9 @@ void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
 }
 
 void HumanoidRendererBase::draw_simplified_body(const DrawContext &ctx,
-                                              const HumanoidVariant &v,
-                                              HumanoidPose &pose,
-                                              ISubmitter &out) const {
+                                                const HumanoidVariant &v,
+                                                HumanoidPose &pose,
+                                                ISubmitter &out) const {
   using HP = HumanProportions;
 
   QVector3D const scaling = get_proportion_scaling();
@@ -1192,9 +1188,9 @@ void HumanoidRendererBase::draw_simplified_body(const DrawContext &ctx,
 }
 
 void HumanoidRendererBase::draw_minimal_body(const DrawContext &ctx,
-                                           const HumanoidVariant &v,
-                                           const HumanoidPose &pose,
-                                           ISubmitter &out) const {
+                                             const HumanoidVariant &v,
+                                             const HumanoidPose &pose,
+                                             ISubmitter &out) const {
   using HP = HumanProportions;
 
   QVector3D const top = pose.head_pos + QVector3D(0.0F, pose.head_r, 0.0F);
@@ -1208,7 +1204,7 @@ void HumanoidRendererBase::draw_minimal_body(const DrawContext &ctx,
 
 void HumanoidRendererBase::render(const DrawContext &ctx,
                                   ISubmitter &out) const {
-  FormationParams const formation = resolveFormation(ctx);
+  FormationParams const formation = resolve_formation(ctx);
   AnimationInputs const anim = sampleAnimState(ctx);
 
   Engine::Core::UnitComponent *unit_comp = nullptr;
@@ -1347,7 +1343,7 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
     constexpr float kSoldierCullRadius = 0.6F;
     if (ctx.camera != nullptr &&
         !ctx.camera->isInFrustum(soldier_world_pos, kSoldierCullRadius)) {
-      ++s_renderStats.soldiersSkippedFrustum;
+      ++s_renderStats.soldiers_skipped_frustum;
       continue;
     }
 
@@ -1356,10 +1352,10 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
     if (ctx.camera != nullptr) {
       soldier_distance =
           (soldier_world_pos - ctx.camera->getPosition()).length();
-      soldier_lod = calculateHumanoidLOD(soldier_distance);
+      soldier_lod = calculate_humanoid_lod(soldier_distance);
 
       if (soldier_lod == HumanoidLOD::Billboard) {
-        ++s_renderStats.soldiersSkippedLOD;
+        ++s_renderStats.soldiers_skipped_lod;
         continue;
       }
     }
@@ -1406,8 +1402,8 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
 
     if (!usedCachedPose) {
 
-      compute_locomotion_pose(inst_seed, anim.time + phase_offset, anim.is_moving,
-                            variation, pose);
+      compute_locomotion_pose(inst_seed, anim.time + phase_offset,
+                              anim.is_moving, variation, pose);
       ++s_renderStats.poses_computed;
 
       CachedPoseEntry &entry = s_poseCache[cacheKey];
@@ -1632,14 +1628,14 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
           shadowModel.scale(shadowWidth, shadowDepth, 1.0F);
 
           if (auto *renderer = dynamic_cast<Renderer *>(&out)) {
-            Shader *previous_shader = renderer->getCurrentShader();
-            renderer->setCurrentShader(shadowShader);
+            Shader *previous_shader = renderer->get_current_shader();
+            renderer->set_current_shader(shadowShader);
             shadowShader->setUniform(QStringLiteral("u_lightDir"), dir_for_use);
 
             out.mesh(quadMesh, shadowModel, QVector3D(0.0F, 0.0F, 0.0F),
                      nullptr, k_shadow_base_alpha, 0);
 
-            renderer->setCurrentShader(previous_shader);
+            renderer->set_current_shader(previous_shader);
           }
         }
       }

render/humanoid/rig.h

@@ -62,9 +62,9 @@ public:
                               uint32_t seed, HumanoidPose &io_pose) const;
 
   virtual void add_attachments(const DrawContext &ctx, const HumanoidVariant &v,
-                              const HumanoidPose &pose,
-                              const HumanoidAnimationContext &anim_ctx,
-                              ISubmitter &out) const;
+                               const HumanoidPose &pose,
+                               const HumanoidAnimationContext &anim_ctx,
+                               ISubmitter &out) const;
 
   virtual void draw_helmet(const DrawContext &ctx, const HumanoidVariant &v,
                            const HumanoidPose &pose, ISubmitter &out) const;
@@ -74,22 +74,23 @@ public:
                           const HumanoidAnimationContext &anim,
                           ISubmitter &out) const;
 
-  virtual void draw_armor_overlay(const DrawContext &ctx,
-                                 const HumanoidVariant &v,
-                                 const HumanoidPose &pose, float y_top_cover,
-                                 float torso_r, float shoulder_half_span,
-                                 float upper_arm_r, const QVector3D &right_axis,
-                                 ISubmitter &out) const;
+  virtual void
+  draw_armor_overlay(const DrawContext &ctx, const HumanoidVariant &v,
+                     const HumanoidPose &pose, float y_top_cover, float torso_r,
+                     float shoulder_half_span, float upper_arm_r,
+                     const QVector3D &right_axis, ISubmitter &out) const;
 
   virtual void draw_shoulder_decorations(const DrawContext &ctx,
-                                       const HumanoidVariant &v,
-                                       const HumanoidPose &pose,
-                                       float y_top_cover, float y_neck,
-                                       const QVector3D &right_axis,
-                                       ISubmitter &out) const;
+                                         const HumanoidVariant &v,
+                                         const HumanoidPose &pose,
+                                         float y_top_cover, float y_neck,
+                                         const QVector3D &right_axis,
+                                         ISubmitter &out) const;
 
-  virtual void draw_facial_hair(const DrawContext &ctx, const HumanoidVariant &v,
-                              const HumanoidPose &pose, ISubmitter &out) const;
+  virtual void draw_facial_hair(const DrawContext &ctx,
+                                const HumanoidVariant &v,
+                                const HumanoidPose &pose,
+                                ISubmitter &out) const;
 
   void render(const DrawContext &ctx, ISubmitter &out) const;
 
@@ -98,26 +99,26 @@ public:
       Engine::Core::TransformComponent *transform_comp) const -> float;
 
   void draw_simplified_body(const DrawContext &ctx, const HumanoidVariant &v,
-                          HumanoidPose &pose, ISubmitter &out) const;
+                            HumanoidPose &pose, ISubmitter &out) const;
 
   void draw_minimal_body(const DrawContext &ctx, const HumanoidVariant &v,
-                       const HumanoidPose &pose, ISubmitter &out) const;
+                         const HumanoidPose &pose, ISubmitter &out) const;
 
   static auto frame_local_position(const AttachmentFrame &frame,
-                                 const QVector3D &local) -> QVector3D;
+                                   const QVector3D &local) -> QVector3D;
 
   static auto make_frame_local_transform(const QMatrix4x4 &parent,
-                                      const AttachmentFrame &frame,
-                                      const QVector3D &local_offset,
-                                      float uniform_scale) -> QMatrix4x4;
+                                         const AttachmentFrame &frame,
+                                         const QVector3D &local_offset,
+                                         float uniform_scale) -> QMatrix4x4;
 
   static auto head_local_position(const HeadFrame &frame,
-                                const QVector3D &local) -> QVector3D;
+                                  const QVector3D &local) -> QVector3D;
 
   static auto make_head_local_transform(const QMatrix4x4 &parent,
-                                     const HeadFrame &frame,
-                                     const QVector3D &local_offset,
-                                     float uniform_scale) -> QMatrix4x4;
+                                        const HeadFrame &frame,
+                                        const QVector3D &local_offset,
+                                        float uniform_scale) -> QMatrix4x4;
 
 protected:
   mutable QVector3D m_cached_proportion_scale;
@@ -126,13 +127,13 @@ protected:
   static auto resolve_formation(const DrawContext &ctx) -> FormationParams;
 
   static void compute_locomotion_pose(uint32_t seed, float time, bool is_moving,
-                                    const VariationParams &variation,
-                                    HumanoidPose &io_pose);
+                                      const VariationParams &variation,
+                                      HumanoidPose &io_pose);
 
   static auto resolve_team_tint(const DrawContext &ctx) -> QVector3D;
 
   void draw_common_body(const DrawContext &ctx, const HumanoidVariant &v,
-                      HumanoidPose &pose, ISubmitter &out) const;
+                        HumanoidPose &pose, ISubmitter &out) const;
 };
 
 struct HumanoidRenderStats {

render/primitive_batch.cpp

@@ -14,7 +14,7 @@ PrimitiveBatcher::PrimitiveBatcher() {
 PrimitiveBatcher::~PrimitiveBatcher() = default;
 
 void PrimitiveBatcher::add_sphere(const QMatrix4x4 &transform,
-                                 const QVector3D &color, float alpha) {
+                                  const QVector3D &color, float alpha) {
   PrimitiveInstanceGpu inst;
   inst.set_transform(transform);
   inst.set_color(color, alpha);
@@ -23,7 +23,7 @@ void PrimitiveBatcher::add_sphere(const QMatrix4x4 &transform,
 }
 
 void PrimitiveBatcher::add_cylinder(const QMatrix4x4 &transform,
-                                   const QVector3D &color, float alpha) {
+                                    const QVector3D &color, float alpha) {
   PrimitiveInstanceGpu inst;
   inst.set_transform(transform);
   inst.set_color(color, alpha);
@@ -32,7 +32,7 @@ void PrimitiveBatcher::add_cylinder(const QMatrix4x4 &transform,
 }
 
 void PrimitiveBatcher::add_cone(const QMatrix4x4 &transform,
-                               const QVector3D &color, float alpha) {
+                                const QVector3D &color, float alpha) {
   PrimitiveInstanceGpu inst;
   inst.set_transform(transform);
   inst.set_color(color, alpha);

render/primitive_batch.h

@@ -76,7 +76,9 @@ public:
   [[nodiscard]] auto cylinder_count() const -> std::size_t {
     return m_cylinders.size();
   }
-  [[nodiscard]] auto cone_count() const -> std::size_t { return m_cones.size(); }
+  [[nodiscard]] auto cone_count() const -> std::size_t {
+    return m_cones.size();
+  }
   [[nodiscard]] auto total_count() const -> std::size_t {
     return m_spheres.size() + m_cylinders.size() + m_cones.size();
   }

render/scene_renderer.cpp

@@ -235,7 +235,8 @@ void Renderer::olive_batch(Buffer *instance_buffer, std::size_t instance_count,
   m_active_queue->submit(cmd);
 }
 
-void Renderer::firecamp_batch(Buffer *instance_buffer, std::size_t instance_count,
+void Renderer::firecamp_batch(Buffer *instance_buffer,
+                              std::size_t instance_count,
                               const FireCampBatchParams &params) {
   if ((instance_buffer == nullptr) || instance_count == 0 ||
       (m_active_queue == nullptr)) {
@@ -305,10 +306,9 @@ void Renderer::selection_smoke(const QMatrix4x4 &model, const QVector3D &color,
   }
 }
 
-void Renderer::enqueue_selection_ring(Engine::Core::Entity *,
-                                      Engine::Core::TransformComponent *transform,
-                                      Engine::Core::UnitComponent *unit_comp,
-                                      bool selected, bool hovered) {
+void Renderer::enqueue_selection_ring(
+    Engine::Core::Entity *, Engine::Core::TransformComponent *transform,
+    Engine::Core::UnitComponent *unit_comp, bool selected, bool hovered) {
   if ((!selected && !hovered) || (transform == nullptr)) {
     return;
   }
@@ -473,7 +473,7 @@ void Renderer::render_world(Engine::Core::World *world) {
       distanceToCamera = std::sqrt(dx * dx + dz * dz);
     }
 
-    if ((unit_comp != nullptr) && unit_comp->owner_id != m_localOwnerId) {
+    if ((unit_comp != nullptr) && unit_comp->owner_id != m_local_owner_id) {
       if (visibility_enabled) {
         if (!vis.isVisibleWorld(transform->position.x, transform->position.z)) {
           continue;
@@ -482,8 +482,8 @@ void Renderer::render_world(Engine::Core::World *world) {
     }
 
     bool const is_selected =
-        (m_selectedIds.find(entity->getId()) != m_selectedIds.end());
-    bool const is_hovered = (entity->getId() == m_hoveredEntityId);
+        (m_selected_ids.find(entity->getId()) != m_selected_ids.end());
+    bool const is_hovered = (entity->getId() == m_hovered_entity_id);
 
     QMatrix4x4 model_matrix;
     model_matrix.translate(transform->position.x, transform->position.y,
@@ -525,7 +525,7 @@ void Renderer::render_world(Engine::Core::World *world) {
         }
 
         enqueue_selection_ring(entity, transform, unit_comp, is_selected,
-                              is_hovered);
+                               is_hovered);
         drawn_by_registry = true;
       }
     }
@@ -605,14 +605,15 @@ void Renderer::render_world(Engine::Core::World *world) {
         mesh(contact_quad, c2, col, white, outer_alpha);
       }
     }
-    enqueue_selection_ring(entity, transform, unit_comp, is_selected, is_hovered);
+    enqueue_selection_ring(entity, transform, unit_comp, is_selected,
+                           is_hovered);
     mesh(mesh_to_draw, model_matrix, color,
          (res != nullptr) ? res->white() : nullptr, 1.0F);
   }
 
   if ((m_active_queue != nullptr) && batcher.total_count() > 0) {
     PrimitiveBatchParams params;
-    params.viewProj = m_view_proj;
+    params.view_proj = m_view_proj;
 
     if (batcher.sphere_count() > 0) {
       PrimitiveBatchCmd cmd;

render/scene_renderer.h

@@ -49,7 +49,9 @@ public:
   void set_camera(Camera *camera);
   void set_clear_color(float r, float g, float b, float a = 1.0F);
 
-  void update_animation_time(float delta_time) { m_accumulated_time += delta_time; }
+  void update_animation_time(float delta_time) {
+    m_accumulated_time += delta_time;
+  }
   auto get_animation_time() const -> float { return m_accumulated_time; }
 
   auto resources() const -> ResourceManager * {
@@ -149,9 +151,9 @@ public:
 
 private:
   void enqueue_selection_ring(Engine::Core::Entity *entity,
-                               Engine::Core::TransformComponent *transform,
-                               Engine::Core::UnitComponent *unit_comp,
-                               bool selected, bool hovered);
+                              Engine::Core::TransformComponent *transform,
+                              Engine::Core::UnitComponent *unit_comp,
+                              bool selected, bool hovered);
 
   Camera *m_camera = nullptr;
   std::shared_ptr<Backend> m_backend;

tests/render/body_frames_test.cpp

@@ -90,7 +90,7 @@ TEST_F(BodyFramesTest, FrameLocalPositionComputesCorrectly) {
 
   // Test frame-local position computation
   QVector3D local(1.0F, 0.0F, 0.0F); // Right
-  QVector3D world = HumanoidRendererBase::frameLocalPosition(frame, local);
+  QVector3D world = HumanoidRendererBase::frame_local_position(frame, local);
 
   // Expected: origin + right * (1.0 * radius)
   QVector3D expected = QVector3D(1.5F, 2.0F, 3.0F);
@@ -107,7 +107,7 @@ TEST_F(BodyFramesTest, FrameLocalPositionWithMultipleAxes) {
 
   // Test diagonal position
   QVector3D local(1.0F, 1.0F, 1.0F);
-  QVector3D world = HumanoidRendererBase::frameLocalPosition(frame, local);
+  QVector3D world = HumanoidRendererBase::frame_local_position(frame, local);
 
   // Expected: origin + right*1 + up*1 + forward*1
   QVector3D expected = QVector3D(1.0F, 1.0F, 1.0F);
@@ -126,7 +126,7 @@ TEST_F(BodyFramesTest, MakeFrameLocalTransformCreatesValidMatrix) {
   QVector3D localOffset(0.0F, 0.0F, 0.0F);
   float uniformScale = 1.0F;
 
-  QMatrix4x4 result = HumanoidRendererBase::makeFrameLocalTransform(
+  QMatrix4x4 result = HumanoidRendererBase::make_frame_local_transform(
       parent, frame, localOffset, uniformScale);
 
   // Verify the translation component
@@ -144,18 +144,18 @@ TEST_F(BodyFramesTest, LegacyHeadFunctionsStillWork) {
   headFrame.forward = QVector3D(0.0F, 0.0F, 1.0F);
   headFrame.radius = HP::HEAD_RADIUS;
 
-  // Test legacy headLocalPosition function
+  // Test legacy head_local_position function
   QVector3D local(1.0F, 0.0F, 0.0F);
-  QVector3D world = HumanoidRendererBase::headLocalPosition(headFrame, local);
+  QVector3D world = HumanoidRendererBase::head_local_position(headFrame, local);
   QVector3D expected = QVector3D(HP::HEAD_RADIUS, head_center_y, 0.0F);
   EXPECT_TRUE(approxEqual(world, expected));
 
-  // Test legacy makeHeadLocalTransform function
+  // Test legacy make_head_local_transform function
   QMatrix4x4 parent;
   QVector3D localOffset(0.0F, 0.0F, 0.0F);
   float uniformScale = 1.0F;
 
-  QMatrix4x4 result = HumanoidRendererBase::makeHeadLocalTransform(
+  QMatrix4x4 result = HumanoidRendererBase::make_head_local_transform(
       parent, headFrame, localOffset, uniformScale);
 
   QVector3D translation = result.map(QVector3D(0.0F, 0.0F, 0.0F));

tests/render/carthage_armor_bounds_test.cpp

@@ -56,11 +56,11 @@ public:
 
   void cylinder(const QVector3D &, const QVector3D &, float, const QVector3D &,
                 float) override {}
-  void selectionRing(const QMatrix4x4 &, float, float,
-                     const QVector3D &) override {}
+  void selection_ring(const QMatrix4x4 &, float, float,
+                      const QVector3D &) override {}
   void grid(const QMatrix4x4 &, const QVector3D &, float, float,
             float) override {}
-  void selectionSmoke(const QMatrix4x4 &, const QVector3D &, float) override {}
+  void selection_smoke(const QMatrix4x4 &, const QVector3D &, float) override {}
 };
 
 // Minimal renderer that reproduces the Carthage spearman proportions and

tests/render/helmet_renderers_test.cpp

@@ -25,9 +25,9 @@ public:
     cylinder_count++;
   }
 
-  void selectionRing(const QMatrix4x4 & /*model*/, float /*alphaInner*/,
-                     float /*alphaOuter*/,
-                     const QVector3D & /*color*/) override {
+  void selection_ring(const QMatrix4x4 & /*model*/, float /*alphaInner*/,
+                      float /*alphaOuter*/,
+                      const QVector3D & /*color*/) override {
     // Not used in helmet rendering
   }
 
@@ -37,8 +37,9 @@ public:
     // Not used in helmet rendering
   }
 
-  void selectionSmoke(const QMatrix4x4 & /*model*/, const QVector3D & /*color*/,
-                      float /*baseAlpha*/) override {
+  void selection_smoke(const QMatrix4x4 & /*model*/,
+                       const QVector3D & /*color*/,
+                       float /*baseAlpha*/) override {
     // Not used in helmet rendering
   }
 

tests/render/horse_animation_controller_test.cpp

@@ -13,7 +13,7 @@ protected:
     // Create a basic horse profile
     QVector3D const leather_base(0.5F, 0.4F, 0.3F);
     QVector3D const cloth_base(0.7F, 0.2F, 0.1F);
-    profile = makeHorseProfile(12345, leather_base, cloth_base);
+    profile = make_horse_profile(12345, leather_base, cloth_base);
 
     // Initialize animation inputs
     anim.time = 0.0F;
@@ -59,22 +59,22 @@ TEST_F(HorseAnimationControllerTest, SetGaitUpdatesParameters) {
   // Test walk gait
   controller.setGait(GaitType::WALK);
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 1.0F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 1.0F, 0.01F));
 
   // Test trot gait
   controller.setGait(GaitType::TROT);
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.60F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.60F, 0.01F));
 
   // Test canter gait
   controller.setGait(GaitType::CANTER);
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.50F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.50F, 0.01F));
 
   // Test gallop gait
   controller.setGait(GaitType::GALLOP);
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.38F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.38F, 0.01F));
 }
 
 TEST_F(HorseAnimationControllerTest, IdleGeneratesBobbing) {
@@ -108,19 +108,19 @@ TEST_F(HorseAnimationControllerTest, AccelerateChangesGait) {
   // Advance time to complete transition
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 1.0F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 1.0F, 0.01F));
 
   // Accelerate to trot speed
   controller.accelerate(3.0F);
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.60F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.60F, 0.01F));
 
   // Accelerate to gallop speed
   controller.accelerate(6.0F);
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.38F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.38F, 0.01F));
 }
 
 TEST_F(HorseAnimationControllerTest, DecelerateChangesGait) {
@@ -134,13 +134,13 @@ TEST_F(HorseAnimationControllerTest, DecelerateChangesGait) {
   // Advance time to complete transition
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.50F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.50F, 0.01F));
 
   // Decelerate to trot
   controller.decelerate(2.0F);
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.60F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.60F, 0.01F));
 }
 
 TEST_F(HorseAnimationControllerTest, TurnSetsAngles) {
@@ -296,7 +296,7 @@ TEST_F(HorseAnimationControllerTest, GaitTransitionsAreSmoothAndGradual) {
 
   // Start at walk
   controller.setGait(GaitType::WALK);
-  float const walk_cycle = profile.gait.cycleTime;
+  float const walk_cycle = profile.gait.cycle_time;
 
   // Accelerate to gallop
   controller.accelerate(10.0F);
@@ -304,12 +304,12 @@ TEST_F(HorseAnimationControllerTest, GaitTransitionsAreSmoothAndGradual) {
   // After short time, should be transitioning (not at final value)
   anim.time += 0.1F;
   controller.updateGaitParameters();
-  float const transition_cycle1 = profile.gait.cycleTime;
+  float const transition_cycle1 = profile.gait.cycle_time;
   EXPECT_GT(transition_cycle1, 0.38F);      // Not yet at gallop cycle time
   EXPECT_LT(transition_cycle1, walk_cycle); // But moving toward it
 
   // After enough time, should reach final value
   anim.time += 0.5F;
   controller.updateGaitParameters();
-  EXPECT_TRUE(approxEqual(profile.gait.cycleTime, 0.38F, 0.01F));
+  EXPECT_TRUE(approxEqual(profile.gait.cycle_time, 0.38F, 0.01F));
 }

tests/render/horse_equipment_renderers_test.cpp

@@ -37,16 +37,17 @@ public:
     cylinder_count++;
   }
 
-  void selectionRing(const QMatrix4x4 & /*model*/, float /*alphaInner*/,
-                     float /*alphaOuter*/,
-                     const QVector3D & /*color*/) override {}
+  void selection_ring(const QMatrix4x4 & /*model*/, float /*alphaInner*/,
+                      float /*alphaOuter*/,
+                      const QVector3D & /*color*/) override {}
 
   void grid(const QMatrix4x4 & /*model*/, const QVector3D & /*color*/,
             float /*cellSize*/, float /*thickness*/,
             float /*extent*/) override {}
 
-  void selectionSmoke(const QMatrix4x4 & /*model*/, const QVector3D & /*color*/,
-                      float /*baseAlpha*/ = 0.15F) override {}
+  void selection_smoke(const QMatrix4x4 & /*model*/,
+                       const QVector3D & /*color*/,
+                       float /*baseAlpha*/ = 0.15F) override {}
 
   int mesh_count = 0;
   int cylinder_count = 0;
@@ -112,8 +113,8 @@ protected:
     frames.tail_base.up = QVector3D(0.0F, 1.0F, 0.0F);
     frames.tail_base.forward = QVector3D(0.0F, 0.0F, 1.0F);
 
-    variant.saddleColor = QVector3D(0.6F, 0.4F, 0.2F);
-    variant.blanketColor = QVector3D(0.8F, 0.1F, 0.1F);
+    variant.saddle_color = QVector3D(0.6F, 0.4F, 0.2F);
+    variant.blanket_color = QVector3D(0.8F, 0.1F, 0.1F);
     variant.tack_color = QVector3D(0.3F, 0.2F, 0.1F);
 
     anim.time = 0.0F;

ui/qml/ProductionPanel.qml

@@ -782,66 +782,210 @@ Rectangle {
                             width: 110
                             height: 80
                             radius: 6
-                            color: isEnabled ? (healerMouseArea.containsMouse ? "#34495e" : "#2c3e50") : "#1a1a1a"
+                            color: isEnabled ? (catapultMouseArea.containsMouse ? "#34495e" : "#2c3e50") : "#1a1a1a"
                             border.color: isEnabled ? "#4a6572" : "#2a2a2a"
                             border.width: 2
                             opacity: isEnabled ? 1 : 0.5
 
-                            Column {
+                            Image {
+                                id: catapultRecruitIcon
+
+                                anchors.fill: parent
+                                fillMode: Image.PreserveAspectCrop
+                                smooth: true
+                                source: productionPanel.unitIconSource("catapult", unitGridContent.prod.nation_id)
+                                visible: source !== ""
+                                opacity: parent.isEnabled ? 1 : 0.35
+                            }
+
+                            Text {
                                 anchors.centerIn: parent
-                                spacing: 4
-
-                                Item {
-                                    anchors.horizontalCenter: parent.horizontalCenter
-                                    width: 48
-                                    height: 48
-
-                                    Image {
-                                        id: healerIcon
-
-                                        anchors.fill: parent
-                                        fillMode: Image.PreserveAspectFit
-                                        smooth: true
-                                        source: productionPanel.unitIconSource("healer", unitGridContent.prod.nation_id)
-                                        visible: source !== ""
-                                        opacity: parent.parent.parent.isEnabled ? 1 : 0.4
-                                    }
+                                visible: !catapultRecruitIcon.visible
+                                text: productionPanel.unitIconEmoji("catapult")
+                                color: parent.isEnabled ? "#ecf0f1" : "#5a5a5a"
+                                font.pointSize: 42
+                                opacity: parent.isEnabled ? 0.9 : 0.4
+                            }
 
-                                    Text {
-                                        anchors.centerIn: parent
-                                        visible: !healerIcon.visible
-                                        text: productionPanel.unitIconEmoji("healer")
-                                        color: parent.parent.parent.isEnabled ? "#ecf0f1" : "#5a5a5a"
-                                        font.pointSize: 20
-                                    }
+                            Rectangle {
+                                id: catapultCostBadge
 
+                                width: catapultCostText.implicitWidth + 12
+                                height: catapultCostText.implicitHeight + 6
+                                anchors.horizontalCenter: parent.horizontalCenter
+                                anchors.bottom: parent.bottom
+                                anchors.bottomMargin: 6
+                                radius: 8
+                                color: parent.isEnabled ? "#000000b3" : "#00000066"
+                                border.color: parent.isEnabled ? "#f39c12" : "#555555"
+                                border.width: 1
+
+                                Text {
+                                    id: catapultCostText
+
+                                    anchors.centerIn: parent
+                                    text: unitGridContent.prod.villagerCost || 1
+                                    color: catapultCostBadge.parent.isEnabled ? "#fdf7e3" : "#8a8a8a"
+                                    font.pointSize: 16
+                                    font.bold: true
                                 }
 
+                            }
+
+                            MouseArea {
+                                id: catapultMouseArea
+
+                                anchors.fill: parent
+                                hoverEnabled: true
+                                enabled: parent.isEnabled
+                                onClicked: productionPanel.recruitUnit("catapult")
+                                cursorShape: parent.isEnabled ? Qt.PointingHandCursor : Qt.ForbiddenCursor
+                                ToolTip.visible: containsMouse
+                                ToolTip.text: parent.isEnabled ? qsTr("Recruit Catapult\nCost: %1 villagers\nBuild time: %2s").arg(unitGridContent.prod.villagerCost || 1).arg((unitGridContent.prod.buildTime || 0).toFixed(0)) : (parent.queueTotal >= 5 ? qsTr("Queue is full (5/5)") : (unitGridContent.prod.producedCount >= unitGridContent.prod.maxUnits ? qsTr("Unit cap reached") : qsTr("Cannot recruit")))
+                                ToolTip.delay: 300
+                            }
+
+                            Rectangle {
+                                anchors.fill: parent
+                                color: "#ffffff"
+                                opacity: catapultMouseArea.pressed ? 0.2 : 0
+                                radius: parent.radius
+                            }
+
+                        }
+
+                        Rectangle {
+                            property int queueTotal: (unitGridContent.prod.inProgress ? 1 : 0) + (unitGridContent.prod.queueSize || 0)
+                            property bool isEnabled: unitGridContent.prod.has_barracks && unitGridContent.prod.producedCount < unitGridContent.prod.maxUnits && queueTotal < 5
+
+                            width: 110
+                            height: 80
+                            radius: 6
+                            color: isEnabled ? (ballistaMouseArea.containsMouse ? "#34495e" : "#2c3e50") : "#1a1a1a"
+                            border.color: isEnabled ? "#4a6572" : "#2a2a2a"
+                            border.width: 2
+                            opacity: isEnabled ? 1 : 0.5
+
+                            Image {
+                                id: ballistaRecruitIcon
+
+                                anchors.fill: parent
+                                fillMode: Image.PreserveAspectCrop
+                                smooth: true
+                                source: productionPanel.unitIconSource("ballista", unitGridContent.prod.nation_id)
+                                visible: source !== ""
+                                opacity: parent.isEnabled ? 1 : 0.35
+                            }
+
+                            Text {
+                                anchors.centerIn: parent
+                                visible: !ballistaRecruitIcon.visible
+                                text: productionPanel.unitIconEmoji("ballista")
+                                color: parent.isEnabled ? "#ecf0f1" : "#5a5a5a"
+                                font.pointSize: 42
+                                opacity: parent.isEnabled ? 0.9 : 0.4
+                            }
+
+                            Rectangle {
+                                id: ballistaCostBadge
+
+                                width: ballistaCostText.implicitWidth + 12
+                                height: ballistaCostText.implicitHeight + 6
+                                anchors.horizontalCenter: parent.horizontalCenter
+                                anchors.bottom: parent.bottom
+                                anchors.bottomMargin: 6
+                                radius: 8
+                                color: parent.isEnabled ? "#000000b3" : "#00000066"
+                                border.color: parent.isEnabled ? "#f39c12" : "#555555"
+                                border.width: 1
+
                                 Text {
-                                    anchors.horizontalCenter: parent.horizontalCenter
-                                    text: qsTr("Healer")
-                                    color: parent.parent.parent.isEnabled ? "#ecf0f1" : "#5a5a5a"
-                                    font.pointSize: 10
+                                    id: ballistaCostText
+
+                                    anchors.centerIn: parent
+                                    text: unitGridContent.prod.villagerCost || 1
+                                    color: ballistaCostBadge.parent.isEnabled ? "#fdf7e3" : "#8a8a8a"
+                                    font.pointSize: 16
                                     font.bold: true
                                 }
 
-                                Row {
-                                    anchors.horizontalCenter: parent.horizontalCenter
-                                    spacing: 4
+                            }
 
-                                    Text {
-                                        text: "👥"
-                                        color: parent.parent.parent.parent.isEnabled ? "#f39c12" : "#5a5a5a"
-                                        font.pointSize: 9
-                                    }
+                            MouseArea {
+                                id: ballistaMouseArea
 
-                                    Text {
-                                        text: unitGridContent.prod.villagerCost || 1
-                                        color: parent.parent.parent.parent.isEnabled ? "#f39c12" : "#5a5a5a"
-                                        font.pointSize: 9
-                                        font.bold: true
-                                    }
+                                anchors.fill: parent
+                                hoverEnabled: true
+                                enabled: parent.isEnabled
+                                onClicked: productionPanel.recruitUnit("ballista")
+                                cursorShape: parent.isEnabled ? Qt.PointingHandCursor : Qt.ForbiddenCursor
+                                ToolTip.visible: containsMouse
+                                ToolTip.text: parent.isEnabled ? qsTr("Recruit Ballista\nCost: %1 villagers\nBuild time: %2s").arg(unitGridContent.prod.villagerCost || 1).arg((unitGridContent.prod.buildTime || 0).toFixed(0)) : (parent.queueTotal >= 5 ? qsTr("Queue is full (5/5)") : (unitGridContent.prod.producedCount >= unitGridContent.prod.maxUnits ? qsTr("Unit cap reached") : qsTr("Cannot recruit")))
+                                ToolTip.delay: 300
+                            }
+
+                            Rectangle {
+                                anchors.fill: parent
+                                color: "#ffffff"
+                                opacity: ballistaMouseArea.pressed ? 0.2 : 0
+                                radius: parent.radius
+                            }
+
+                        }
+
+                        Rectangle {
+                            property int queueTotal: (unitGridContent.prod.inProgress ? 1 : 0) + (unitGridContent.prod.queueSize || 0)
+                            property bool isEnabled: unitGridContent.prod.has_barracks && unitGridContent.prod.producedCount < unitGridContent.prod.maxUnits && queueTotal < 5
+
+                            width: 110
+                            height: 80
+                            radius: 6
+                            color: isEnabled ? (healerMouseArea.containsMouse ? "#34495e" : "#2c3e50") : "#1a1a1a"
+                            border.color: isEnabled ? "#4a6572" : "#2a2a2a"
+                            border.width: 2
+                            opacity: isEnabled ? 1 : 0.5
+
+                            Image {
+                                id: healerRecruitIcon
+
+                                anchors.fill: parent
+                                fillMode: Image.PreserveAspectCrop
+                                smooth: true
+                                source: productionPanel.unitIconSource("healer", unitGridContent.prod.nation_id)
+                                visible: source !== ""
+                                opacity: parent.isEnabled ? 1 : 0.35
+                            }
 
+                            Text {
+                                anchors.centerIn: parent
+                                visible: !healerRecruitIcon.visible
+                                text: productionPanel.unitIconEmoji("healer")
+                                color: parent.isEnabled ? "#ecf0f1" : "#5a5a5a"
+                                font.pointSize: 42
+                                opacity: parent.isEnabled ? 0.9 : 0.4
+                            }
+
+                            Rectangle {
+                                id: healerCostBadge
+
+                                width: healerCostText.implicitWidth + 12
+                                height: healerCostText.implicitHeight + 6
+                                anchors.horizontalCenter: parent.horizontalCenter
+                                anchors.bottom: parent.bottom
+                                anchors.bottomMargin: 6
+                                radius: 8
+                                color: parent.isEnabled ? "#000000b3" : "#00000066"
+                                border.color: parent.isEnabled ? "#f39c12" : "#555555"
+                                border.width: 1
+
+                                Text {
+                                    id: healerCostText
+
+                                    anchors.centerIn: parent
+                                    text: unitGridContent.prod.villagerCost || 1
+                                    color: healerCostBadge.parent.isEnabled ? "#fdf7e3" : "#8a8a8a"
+                                    font.pointSize: 16
+                                    font.bold: true
                                 }
 
                             }