apply format

app/core/game_engine.cpp

@@ -717,9 +717,9 @@ void GameEngine::update(float dt) {
       if (new_version != m_runtime.visibilityVersion) {
         if (m_fog) {
           m_fog->update_mask(visibility_service.getWidth(),
-                            visibility_service.getHeight(),
-                            visibility_service.getTileSize(),
-                            visibility_service.snapshotCells());
+                             visibility_service.getHeight(),
+                             visibility_service.getTileSize(),
+                             visibility_service.snapshotCells());
         }
         m_runtime.visibilityVersion = new_version;
       }
@@ -1335,7 +1335,7 @@ void GameEngine::start_skirmish(const QString &map_path,
     if (result.has_focus_position && m_camera) {
       const auto &cam_config = Game::GameConfig::instance().camera();
       m_camera->set_rts_view(result.focusPosition, cam_config.default_distance,
-                            cam_config.default_pitch, cam_config.default_yaw);
+                             cam_config.default_pitch, cam_config.default_yaw);
     }
 
     Game::Map::MapDefinition map_def;

game/map/environment.cpp

@@ -11,10 +11,10 @@ void Environment::apply(const MapDefinition &def,
                         Render::GL::Renderer &renderer,
                         Render::GL::Camera &camera) {
 
-  camera.set_rts_view(def.camera.center, def.camera.distance, def.camera.tiltDeg,
-                    def.camera.yaw_deg);
+  camera.set_rts_view(def.camera.center, def.camera.distance,
+                      def.camera.tiltDeg, def.camera.yaw_deg);
   camera.set_perspective(def.camera.fovY, 16.0F / 9.0F, def.camera.near_plane,
-                        def.camera.far_plane);
+                         def.camera.far_plane);
   Render::GL::Renderer::GridParams gp;
   gp.cell_size = def.grid.tile_size;
   gp.extent =

render/entity/arrow_vfx_renderer.cpp

@@ -149,8 +149,8 @@ static inline void drawTorso(const DrawContext &p, ISubmitter &out,
   float torso_radius = HP::TORSO_TOP_R;
 
   out.mesh(get_unit_cylinder(),
-           cylinder_between(p.model, torso_top, torsoBot, torso_radius), C.tunic,
-           nullptr, 1.0F);
+           cylinder_between(p.model, torso_top, torsoBot, torso_radius),
+           C.tunic, nullptr, 1.0F);
 
   QVector3D waist{0.0F, HP::WAIST_Y, 0.0F};
   QVector3D hipCenter = (P.hipL + P.hipR) * 0.5F;
@@ -187,8 +187,8 @@ static inline void drawHeadAndNeck(const DrawContext &p, ISubmitter &out,
 
   QVector3D domeC = P.head_pos + QVector3D(0.0F, P.head_r * 0.25F, 0.0F);
   float domeR = P.head_r * 1.05F;
-  out.mesh(get_unit_sphere(), sphere_at(p.model, domeC, domeR), C.metal, nullptr,
-           1.0F);
+  out.mesh(get_unit_sphere(), sphere_at(p.model, domeC, domeR), C.metal,
+           nullptr, 1.0F);
 
   QVector3D visorBase(0.0F, P.head_pos.y() + P.head_r * 0.10F,
                       P.head_r * 0.80F);
@@ -298,8 +298,9 @@ static inline void drawQuiver(const DrawContext &p, ISubmitter &out,
   QVector3D q_base(-0.10F, HP::CHEST_Y, -0.22F);
 
   float quiver_r = HP::HEAD_RADIUS * 0.45F;
-  out.mesh(get_unit_cylinder(), cylinder_between(p.model, q_base, qTop, quiver_r),
-           C.leather, nullptr, 1.0F);
+  out.mesh(get_unit_cylinder(),
+           cylinder_between(p.model, q_base, qTop, quiver_r), C.leather,
+           nullptr, 1.0F);
 
   float j = (hash_01(seed) - 0.5F) * 0.04F;
   float k = (hash_01(seed ^ HashXorShift::k_golden_ratio) - 0.5F) * 0.04F;
@@ -343,13 +344,14 @@ static inline void drawBowAndArrow(const DrawContext &p, ISubmitter &out,
   for (int i = 1; i <= k_bow_curve_segments; ++i) {
     float t = float(i) / float(k_bow_curve_segments);
     QVector3D cur = q_bezier(bot_end, ctrl, top_end, t);
-    out.mesh(get_unit_cylinder(), cylinder_between(p.model, prev, cur, P.bowRodR),
-             C.wood, nullptr, 1.0F);
+    out.mesh(get_unit_cylinder(),
+             cylinder_between(p.model, prev, cur, P.bowRodR), C.wood, nullptr,
+             1.0F);
     prev = cur;
   }
   out.mesh(get_unit_cylinder(),
            cylinder_between(p.model, grip - up * 0.05F, grip + up * 0.05F,
-                           P.bowRodR * 1.45F),
+                            P.bowRodR * 1.45F),
            C.wood, nullptr, 1.0F);
 
   out.mesh(get_unit_cylinder(),
@@ -358,7 +360,8 @@ static inline void drawBowAndArrow(const DrawContext &p, ISubmitter &out,
   out.mesh(get_unit_cylinder(),
            cylinder_between(p.model, nock, bot_end, P.stringR), C.stringCol,
            nullptr, 1.0F);
-  out.mesh(get_unit_cylinder(), cylinder_between(p.model, P.hand_l, nock, 0.0045F),
+  out.mesh(get_unit_cylinder(),
+           cylinder_between(p.model, P.hand_l, nock, 0.0045F),
            C.stringCol * 0.9F, nullptr, 1.0F);
 
   QVector3D tail = nock - forward * 0.06F;

render/entity/arrow_vfx_renderer.h

@@ -18,6 +18,6 @@ class ArrowSystem;
 namespace Render::GL {
 
 void render_arrows(Renderer *renderer, ResourceManager *resources,
-                  const Game::Systems::ArrowSystem &arrow_system);
+                   const Game::Systems::ArrowSystem &arrow_system);
 
 }

render/entity/mounted_knight_pose.h

@@ -34,8 +34,8 @@ struct MountedKnightPoseTuning {
 };
 
 inline void tune_mounted_knight_frame(const HorseDimensions &dims,
-                                   MountedAttachmentFrame &mount,
-                                   const MountedKnightPoseTuning &cfg = {}) {
+                                      MountedAttachmentFrame &mount,
+                                      const MountedKnightPoseTuning &cfg = {}) {
   auto reposition_stirrup = [&](bool is_left) {
     float const side = is_left ? -1.0F : 1.0F;
     QVector3D attach =

render/entity/nations/carthage/barracks_renderer.cpp

@@ -244,14 +244,14 @@ void draw_phoenician_banner(const DrawContext &p, ISubmitter &out, Mesh *unit,
   QVector3D const beam_end(pole_x + beam_length + 0.02F, beam_y, pole_z);
   out.mesh(get_unit_cylinder(),
            p.model * Render::Geom::cylinder_between(beam_start, beam_end,
-                                                   pole_radius * 0.35F),
+                                                    pole_radius * 0.35F),
            c.cedar, white, 1.0F);
 
   QVector3D const connector_top(
       beam_end.x(), beam_end.y() - banner_height * 0.35F, beam_end.z());
   out.mesh(get_unit_cylinder(),
            p.model * Render::Geom::cylinder_between(beam_end, connector_top,
-                                                   pole_radius * 0.18F),
+                                                    pole_radius * 0.18F),
            c.limestone, white, 1.0F);
 
   float const panel_x = beam_end.x() + (banner_width * 0.5F - beam_length);

render/entity/nations/carthage/healer_renderer.cpp

@@ -197,7 +197,7 @@ public:
   }
 
   void draw_healer_robes(const DrawContext &ctx, const HumanoidVariant &v,
-                       const HumanoidPose &pose, ISubmitter &out) const {
+                         const HumanoidPose &pose, ISubmitter &out) const {
     using HP = HumanProportions;
     const BodyFrames &frames = pose.body_frames;
     const AttachmentFrame &torso = frames.torso;
@@ -305,20 +305,21 @@ public:
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, sash_top, sash_top - up * 0.006F,
-                             torso_r * 1.02F),
+                              torso_r * 1.02F),
              team_tint, nullptr, 1.0F, k_mat_tools);
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, sash_bot + up * 0.006F, sash_bot,
-                             torso_r * 1.02F),
+                              torso_r * 1.02F),
              team_tint, nullptr, 1.0F, k_mat_tools);
 
     QVector3D const sash_hang_start =
         origin + right * (torso_r * 0.3F) + up * (sash_y - origin.y());
     QVector3D const sash_hang_end =
         sash_hang_start - up * 0.12F + forward * 0.02F;
-    out.mesh(get_unit_cylinder(),
-             cylinder_between(ctx.model, sash_hang_start, sash_hang_end, 0.018F),
-             purple_dark, nullptr, 1.0F, k_mat_purple_trim);
+    out.mesh(
+        get_unit_cylinder(),
+        cylinder_between(ctx.model, sash_hang_start, sash_hang_end, 0.018F),
+        purple_dark, nullptr, 1.0F, k_mat_purple_trim);
 
     out.mesh(get_unit_sphere(),
              sphere_at(ctx.model, sash_hang_end - up * 0.01F, 0.015F),
@@ -329,12 +330,14 @@ public:
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, neck_center - up * 0.012F,
-                             neck_center + up * 0.012F, HP::NECK_RADIUS * 1.7F),
+                              neck_center + up * 0.012F,
+                              HP::NECK_RADIUS * 1.7F),
              robe_tan, nullptr, 1.0F, k_mat_tunic);
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, neck_center + up * 0.010F,
-                             neck_center + up * 0.018F, HP::NECK_RADIUS * 2.0F),
+                              neck_center + up * 0.018F,
+                              HP::NECK_RADIUS * 2.0F),
              purple_tyrian * 0.9F, nullptr, 1.0F, k_mat_purple_trim);
 
     auto drawFlowingSleeve = [&](const QVector3D &shoulder_pos,
@@ -368,8 +371,8 @@ public:
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model,
-                             neck_center + forward * (torso_depth * 0.3F),
-                             pendant_pos + up * 0.01F, 0.006F),
+                              neck_center + forward * (torso_depth * 0.3F),
+                              pendant_pos + up * 0.01F, 0.006F),
              bronze_color * 0.85F, nullptr, 1.0F, k_mat_tools);
   }
 

render/entity/nations/carthage/spearman_renderer.cpp

@@ -417,8 +417,8 @@ void register_spearman_renderer(Render::GL::EntityRendererRegistry &registry) {
             return shader;
           }
           if (auto resources = lookup_spearman_shader_resources(shader_key)) {
-            shader = ctx.backend->get_or_load_shader(shader_key, resources->vertex,
-                                                  resources->fragment);
+            shader = ctx.backend->get_or_load_shader(
+                shader_key, resources->vertex, resources->fragment);
           }
           return shader;
         };

render/entity/nations/carthage/swordsman_renderer.cpp

@@ -280,12 +280,13 @@ private:
     QVector3D const tip = hip + QVector3D(-0.05F, -0.22F, -0.12F);
     float const sheath_r = extras.swordWidth * 0.85F;
 
-    out.mesh(get_unit_cylinder(), cylinder_between(ctx.model, hip, tip, sheath_r),
+    out.mesh(get_unit_cylinder(),
+             cylinder_between(ctx.model, hip, tip, sheath_r),
              v.palette.leather * 0.9F, nullptr, 1.0F);
 
     out.mesh(get_unit_cone(),
-             cone_from_to(ctx.model, tip, tip + QVector3D(-0.02F, -0.02F, -0.02F),
-                        sheath_r),
+             cone_from_to(ctx.model, tip,
+                          tip + QVector3D(-0.02F, -0.02F, -0.02F), sheath_r),
              extras.metalColor, nullptr, 1.0F);
   }
 

render/entity/nations/roman/barracks_renderer.cpp

@@ -204,14 +204,14 @@ void drawStandards(const DrawContext &p, ISubmitter &out, Mesh *unit,
   QVector3D const beam_end(pole_x + beam_length + 0.02F, beam_y, pole_z);
   out.mesh(get_unit_cylinder(),
            p.model * Render::Geom::cylinder_between(beam_start, beam_end,
-                                                   pole_radius * 0.35F),
+                                                    pole_radius * 0.35F),
            c.wood, white, 1.0F);
 
   QVector3D const connector_top(
       beam_end.x(), beam_end.y() - banner_height * 0.35F, beam_end.z());
   out.mesh(get_unit_cylinder(),
            p.model * Render::Geom::cylinder_between(beam_end, connector_top,
-                                                   pole_radius * 0.18F),
+                                                    pole_radius * 0.18F),
            c.stone_light, white, 1.0F);
 
   float const panel_x = beam_end.x() + (banner_width * 0.5F - beam_length);

render/entity/nations/roman/healer_renderer.cpp

@@ -145,7 +145,7 @@ public:
   }
 
   void draw_healer_tunic(const DrawContext &ctx, const HumanoidVariant &v,
-                       const HumanoidPose &pose, ISubmitter &out) const {
+                         const HumanoidPose &pose, ISubmitter &out) const {
     using HP = HumanProportions;
     const BodyFrames &frames = pose.body_frames;
     const AttachmentFrame &torso = frames.torso;
@@ -251,16 +251,16 @@ public:
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, sash_center - up * 0.022F,
-                             sash_center + up * 0.022F, torso_r * 0.86F),
+                              sash_center + up * 0.022F, torso_r * 0.86F),
              sash_red, nullptr, 1.0F);
 
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, sash_center + up * 0.020F,
-                             sash_center + up * 0.026F, torso_r * 0.88F),
+                              sash_center + up * 0.026F, torso_r * 0.88F),
              trim_gold, nullptr, 1.0F);
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, sash_center - up * 0.026F,
-                             sash_center - up * 0.020F, torso_r * 0.88F),
+                              sash_center - up * 0.020F, torso_r * 0.88F),
              trim_gold, nullptr, 1.0F);
 
     if (style.show_cape) {
@@ -307,8 +307,8 @@ public:
     QVector3D const cross_color = saturate_color(sash_red * 1.05F);
     out.mesh(get_unit_cylinder(),
              cylinder_between(ctx.model, emblem_center - right * cross_half,
-                             emblem_center + right * cross_half,
-                             cross_thickness),
+                              emblem_center + right * cross_half,
+                              cross_thickness),
              cross_color, nullptr, 1.0F);
     out.mesh(get_unit_cylinder(),
              cylinder_between(
@@ -346,7 +346,7 @@ public:
                           const QVector3D &elbow_pos) {
       out.mesh(get_unit_sphere(),
                sphere_at(ctx.model, shoulder_pos + outward * 0.01F,
-                        HP::UPPER_ARM_R * 1.6F),
+                         HP::UPPER_ARM_R * 1.6F),
                tunic_white, nullptr, 1.0F);
 
       for (int i = 0; i < 5; ++i) {

render/entity/nations/roman/spearman_renderer.cpp

@@ -348,40 +348,40 @@ private:
 void register_spearman_renderer(Render::GL::EntityRendererRegistry &registry) {
   ensure_spearman_styles_registered();
   static SpearmanRenderer const renderer;
-  registry.register_renderer(
-      "troops/roman/spearman", [](const DrawContext &ctx, ISubmitter &out) {
-        static SpearmanRenderer const static_renderer;
-        Shader *spearman_shader = nullptr;
-        auto acquireShader = [&](const QString &shader_key) -> Shader * {
-          if (ctx.backend == nullptr || shader_key.isEmpty()) {
-            return nullptr;
-          }
-          Shader *shader = ctx.backend->shader(shader_key);
-          if (shader != nullptr) {
-            return shader;
-          }
-          if (auto resources = lookup_spearman_shader_resources(shader_key)) {
-            shader = ctx.backend->get_or_load_shader(shader_key, resources->vertex,
-                                                  resources->fragment);
-          }
-          return shader;
-        };
-        if (ctx.backend != nullptr) {
-          QString shader_key = static_renderer.resolve_shader_key(ctx);
-          spearman_shader = acquireShader(shader_key);
-          if (spearman_shader == nullptr) {
-            spearman_shader = acquireShader(QStringLiteral("spearman"));
-          }
-        }
-        auto *scene_renderer = dynamic_cast<Renderer *>(&out);
-        if ((scene_renderer != nullptr) && (spearman_shader != nullptr)) {
-          scene_renderer->set_current_shader(spearman_shader);
-        }
-        static_renderer.render(ctx, out);
-        if (scene_renderer != nullptr) {
-          scene_renderer->set_current_shader(nullptr);
-        }
-      });
+  registry.register_renderer("troops/roman/spearman", [](const DrawContext &ctx,
+                                                         ISubmitter &out) {
+    static SpearmanRenderer const static_renderer;
+    Shader *spearman_shader = nullptr;
+    auto acquireShader = [&](const QString &shader_key) -> Shader * {
+      if (ctx.backend == nullptr || shader_key.isEmpty()) {
+        return nullptr;
+      }
+      Shader *shader = ctx.backend->shader(shader_key);
+      if (shader != nullptr) {
+        return shader;
+      }
+      if (auto resources = lookup_spearman_shader_resources(shader_key)) {
+        shader = ctx.backend->get_or_load_shader(shader_key, resources->vertex,
+                                                 resources->fragment);
+      }
+      return shader;
+    };
+    if (ctx.backend != nullptr) {
+      QString shader_key = static_renderer.resolve_shader_key(ctx);
+      spearman_shader = acquireShader(shader_key);
+      if (spearman_shader == nullptr) {
+        spearman_shader = acquireShader(QStringLiteral("spearman"));
+      }
+    }
+    auto *scene_renderer = dynamic_cast<Renderer *>(&out);
+    if ((scene_renderer != nullptr) && (spearman_shader != nullptr)) {
+      scene_renderer->set_current_shader(spearman_shader);
+    }
+    static_renderer.render(ctx, out);
+    if (scene_renderer != nullptr) {
+      scene_renderer->set_current_shader(nullptr);
+    }
+  });
 }
 
 } // namespace Render::GL::Roman

render/entity/nations/roman/swordsman_renderer.cpp

@@ -284,12 +284,13 @@ private:
     QVector3D const tip = hip + QVector3D(-0.05F, -0.22F, -0.12F);
     float const sheath_r = extras.swordWidth * 0.85F;
 
-    out.mesh(get_unit_cylinder(), cylinder_between(ctx.model, hip, tip, sheath_r),
+    out.mesh(get_unit_cylinder(),
+             cylinder_between(ctx.model, hip, tip, sheath_r),
              v.palette.leather * 0.9F, nullptr, 1.0F);
 
     out.mesh(get_unit_cone(),
-             cone_from_to(ctx.model, tip, tip + QVector3D(-0.02F, -0.02F, -0.02F),
-                        sheath_r),
+             cone_from_to(ctx.model, tip,
+                          tip + QVector3D(-0.02F, -0.02F, -0.02F), sheath_r),
              extras.metalColor, nullptr, 1.0F);
   }
 

render/equipment/armor/armor_light_carthage.cpp

@@ -88,7 +88,7 @@ void ArmorLightCarthageRenderer::render(const DrawContext &ctx,
         shoulder_anchor - up * (torso_r * 0.82F) + forward * (torso_r * 0.22F);
     submitter.mesh(get_unit_cylinder(),
                    cylinder_between(ctx.model, shoulder_anchor, chest_anchor,
-                                   torso_r * 0.12F),
+                                    torso_r * 0.12F),
                    leather_highlight * 0.95F, nullptr, 1.0F, 1);
   };
   strap(1.0F);
@@ -98,8 +98,8 @@ void ArmorLightCarthageRenderer::render(const DrawContext &ctx,
       top + forward * (torso_depth * 0.35F) - up * (torso_r * 0.06F);
   QVector3D front_panel_bottom =
       bottom + forward * (torso_depth * 0.38F) + up * (torso_r * 0.03F);
-  QMatrix4x4 front_panel = cylinder_between(ctx.model, front_panel_top,
-                                           front_panel_bottom, torso_r * 0.56F);
+  QMatrix4x4 front_panel = cylinder_between(
+      ctx.model, front_panel_top, front_panel_bottom, torso_r * 0.56F);
   front_panel.scale(1.18F, 1.0F,
                     std::max(0.22F, (torso_depth * 0.76F) / (torso_r * 0.76F)));
   submitter.mesh(torso_mesh != nullptr ? torso_mesh : get_unit_torso(),
@@ -110,7 +110,7 @@ void ArmorLightCarthageRenderer::render(const DrawContext &ctx,
   QVector3D back_panel_bottom =
       bottom - forward * (torso_depth * 0.34F) + up * (torso_r * 0.02F);
   QMatrix4x4 back_panel = cylinder_between(ctx.model, back_panel_top,
-                                          back_panel_bottom, torso_r * 0.58F);
+                                           back_panel_bottom, torso_r * 0.58F);
   back_panel.scale(1.18F, 1.0F,
                    std::max(0.22F, (torso_depth * 0.74F) / (torso_r * 0.80F)));
   submitter.mesh(torso_mesh != nullptr ? torso_mesh : get_unit_torso(),

render/equipment/armor/carthage_shoulder_cover.cpp

@@ -38,16 +38,16 @@ void CarthageShoulderCoverRenderer::render(const DrawContext &ctx,
     QMatrix4x4 upper = ctx.model;
     upper.translate(upper_pos);
     upper.scale(upper_arm_r * 1.75F, upper_arm_r * 0.38F, upper_arm_r * 1.55F);
-    submitter.mesh(get_unit_sphere(), upper, leather_color * 1.05F, nullptr, 1.0F,
-                   1);
+    submitter.mesh(get_unit_sphere(), upper, leather_color * 1.05F, nullptr,
+                   1.0F, 1);
 
     QVector3D lower_pos = upper_pos - QVector3D(0.0F, 0.045F, 0.0F) +
                           outward * (outward_offset * 0.75F);
     QMatrix4x4 lower = ctx.model;
     lower.translate(lower_pos);
     lower.scale(upper_arm_r * 1.58F, upper_arm_r * 0.34F, upper_arm_r * 1.40F);
-    submitter.mesh(get_unit_sphere(), lower, leather_color * 0.96F, nullptr, 1.0F,
-                   1);
+    submitter.mesh(get_unit_sphere(), lower, leather_color * 0.96F, nullptr,
+                   1.0F, 1);
 
     QVector3D trim_pos = lower_pos - QVector3D(0.0F, 0.025F, 0.0F) +
                          outward * (outward_offset * 0.55F);

render/equipment/armor/chainmail_armor.cpp

@@ -16,7 +16,7 @@ namespace Render::GL {
 using Render::Geom::cylinder_between;
 
 auto ChainmailArmorRenderer::calculate_ring_color(float x, float y,
-                                                float z) const -> QVector3D {
+                                                  float z) const -> QVector3D {
 
   float rust_noise =
       std::sin(x * 127.3F) * std::cos(y * 97.1F) * std::sin(z * 83.7F);

render/equipment/armor/roman_armor.cpp

@@ -170,7 +170,7 @@ void RomanLightArmorRenderer::render(const DrawContext &ctx,
         shoulder_anchor - up * (torso_r * 0.82F) + forward * (torso_r * 0.22F);
     submitter.mesh(get_unit_cylinder(),
                    cylinder_between(ctx.model, shoulder_anchor, chest_anchor,
-                                   torso_r * 0.10F),
+                                    torso_r * 0.10F),
                    leather_highlight * 0.95F, nullptr, 1.0F, 1);
   };
   strap(1.0F);
@@ -180,8 +180,8 @@ void RomanLightArmorRenderer::render(const DrawContext &ctx,
       top + forward * (torso_depth * 0.35F) - up * (torso_r * 0.06F);
   QVector3D front_panel_bottom =
       bottom + forward * (torso_depth * 0.38F) + up * (torso_r * 0.03F);
-  QMatrix4x4 front_panel = cylinder_between(ctx.model, front_panel_top,
-                                           front_panel_bottom, torso_r * 0.48F);
+  QMatrix4x4 front_panel = cylinder_between(
+      ctx.model, front_panel_top, front_panel_bottom, torso_r * 0.48F);
   front_panel.scale(1.18F, 1.0F,
                     std::max(0.22F, (torso_depth * 0.76F) / (torso_r * 0.76F)));
   submitter.mesh(torso_mesh != nullptr ? torso_mesh : get_unit_torso(),
@@ -192,7 +192,7 @@ void RomanLightArmorRenderer::render(const DrawContext &ctx,
   QVector3D back_panel_bottom =
       bottom - forward * (torso_depth * 0.34F) + up * (torso_r * 0.02F);
   QMatrix4x4 back_panel = cylinder_between(ctx.model, back_panel_top,
-                                          back_panel_bottom, torso_r * 0.50F);
+                                           back_panel_bottom, torso_r * 0.50F);
   back_panel.scale(1.18F, 1.0F,
                    std::max(0.22F, (torso_depth * 0.74F) / (torso_r * 0.80F)));
   submitter.mesh(torso_mesh != nullptr ? torso_mesh : get_unit_torso(),

render/equipment/armor/roman_greaves.cpp

@@ -78,8 +78,8 @@ void RomanGreavesRenderer::render(const DrawContext &ctx,
 
       seg_transform.scale(segment_width, greave_len * 0.5F, greave_thickness);
 
-      submitter.mesh(get_unit_cube(), seg_transform, greaves_color, nullptr, 1.0F,
-                     5);
+      submitter.mesh(get_unit_cube(), seg_transform, greaves_color, nullptr,
+                     1.0F, 5);
     }
   };
 

render/equipment/armor/tunic_renderer.cpp

@@ -254,7 +254,7 @@ void TunicRenderer::renderGorget(const DrawContext &ctx,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, gorget_bot, gorget_top,
-                                 HP::NECK_RADIUS * 2.6F),
+                                  HP::NECK_RADIUS * 2.6F),
                  steel_color * 1.08F, nullptr, 1.0F);
 
   QVector3D const a = gorget_top + QVector3D(0, 0.005F, 0);

render/equipment/helmets/carthage_heavy_helmet.cpp

@@ -49,14 +49,14 @@ void CarthageHeavyHelmetRenderer::render(const DrawContext &ctx,
   QVector3D cone_base = head_point(QVector3D(0.0f, 0.58f, 0.0f));
   QVector3D cone_tip = head_point(QVector3D(0.0f, 1.46f, 0.0f));
   submitter.mesh(get_unit_cone(),
-                 cone_from_to(ctx.model, cone_base, cone_tip, base_r), base_color,
-                 nullptr, 1.0f, 2);
+                 cone_from_to(ctx.model, cone_base, cone_tip, base_r),
+                 base_color, nullptr, 1.0f, 2);
 
   QVector3D tip_base = head_point(QVector3D(0.0f, 1.12f, 0.0f));
   QVector3D tip_apex = head_point(QVector3D(0.0f, 1.70f, 0.0f));
   submitter.mesh(get_unit_cone(),
                  cone_from_to(ctx.model, tip_base, tip_apex,
-                            std::max(0.05f, base_r * 0.28f)),
+                              std::max(0.05f, base_r * 0.28f)),
                  accent, nullptr, 1.0f, 2);
 
   QMatrix4x4 tip_cap =

render/equipment/helmets/carthage_light_helmet.cpp

@@ -121,8 +121,8 @@ void CarthageLightHelmetRenderer::render_bowl(const DrawContext &ctx,
   QMatrix4x4 bowl = ctx.model;
   bowl.translate(cap_center);
   bowl.scale(R * 0.88F, R * 0.82F, R * 0.88F);
-  submitter.mesh(get_unit_sphere(), bowl, m_config.leather_color * 0.94F, nullptr,
-                 0.9F, 2);
+  submitter.mesh(get_unit_sphere(), bowl, m_config.leather_color * 0.94F,
+                 nullptr, 0.9F, 2);
 
   QVector3D taper_top = helmet_origin + up * (R * 0.48F);
   QVector3D taper_bot = helmet_origin + up * (R * 0.26F);

render/equipment/helmets/carthage_light_helmet.h

@@ -22,7 +22,9 @@ class CarthageLightHelmetRenderer : public IEquipmentRenderer {
 public:
   CarthageLightHelmetRenderer() = default;
 
-  void set_config(const CarthageLightHelmetConfig &config) { m_config = config; }
+  void set_config(const CarthageLightHelmetConfig &config) {
+    m_config = config;
+  }
 
   void render(const DrawContext &ctx, const BodyFrames &frames,
               const HumanoidPalette &palette,

render/equipment/helmets/headwrap.cpp

@@ -33,9 +33,10 @@ void HeadwrapRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
   QVector3D const band_top = headPoint(QVector3D(0.0F, 0.70F, 0.0F));
   QVector3D const band_bot = headPoint(QVector3D(0.0F, 0.30F, 0.0F));
-  submitter.mesh(get_unit_cylinder(),
-                 cylinder_between(ctx.model, band_bot, band_top, head_r * 1.08F),
-                 cloth_color, nullptr, 1.0F);
+  submitter.mesh(
+      get_unit_cylinder(),
+      cylinder_between(ctx.model, band_bot, band_top, head_r * 1.08F),
+      cloth_color, nullptr, 1.0F);
 
   QVector3D const knot_center = headPoint(QVector3D(0.10F, 0.60F, 0.72F));
   QMatrix4x4 knot_m = ctx.model;
@@ -47,9 +48,10 @@ void HeadwrapRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
                              head.up * (-0.05F) + head.forward * (-0.06F);
   QVector3D const tail_bot = tail_top + head.right * 0.02F +
                              head.up * (-0.28F) + head.forward * (-0.08F);
-  submitter.mesh(get_unit_cylinder(),
-                 cylinder_between(ctx.model, tail_top, tail_bot, head_r * 0.28F),
-                 cloth_color * QVector3D(0.92F, 0.98F, 1.05F), nullptr, 1.0F);
+  submitter.mesh(
+      get_unit_cylinder(),
+      cylinder_between(ctx.model, tail_top, tail_bot, head_r * 0.28F),
+      cloth_color * QVector3D(0.92F, 0.98F, 1.05F), nullptr, 1.0F);
 }
 
 } // namespace Render::GL

render/equipment/helmets/roman_heavy_helmet.cpp

@@ -115,9 +115,10 @@ void RomanHeavyHelmetRenderer::render(const DrawContext &ctx,
       cylinder_between(ctx.model, crest_base, crest_mid, crest_mount_radius),
       brass_color, nullptr, 1.0f, 2);
 
-  submitter.mesh(get_unit_cone(),
-                 cone_from_to(ctx.model, crest_mid, crest_top, crest_cone_radius),
-                 QVector3D(0.96f, 0.12f, 0.12f), nullptr, 1.0f, 0);
+  submitter.mesh(
+      get_unit_cone(),
+      cone_from_to(ctx.model, crest_mid, crest_top, crest_cone_radius),
+      QVector3D(0.96f, 0.12f, 0.12f), nullptr, 1.0f, 0);
 
   submitter.mesh(get_unit_sphere(),
                  sphere_at(ctx.model, crest_top, crest_top_sphere_r),

render/equipment/helmets/roman_light_helmet.cpp

@@ -46,9 +46,10 @@ void RomanLightHelmetRenderer::render(const DrawContext &ctx,
                  helmet_color, nullptr, 1.0F, 2);
 
   QVector3D const apex_pos = headPoint(QVector3D(0.0F, 1.48F, 0.0F));
-  submitter.mesh(get_unit_cone(),
-                 cone_from_to(ctx.model, helmet_top, apex_pos, helmet_r * 0.97F),
-                 helmet_accent, nullptr, 1.0F, 2);
+  submitter.mesh(
+      get_unit_cone(),
+      cone_from_to(ctx.model, helmet_top, apex_pos, helmet_r * 0.97F),
+      helmet_accent, nullptr, 1.0F, 2);
 
   auto ring = [&](float y_offset, float r_scale, const QVector3D &col) {
     QVector3D const center = headPoint(QVector3D(0.0F, y_offset, 0.0F));
@@ -67,7 +68,7 @@ void RomanLightHelmetRenderer::render(const DrawContext &ctx,
   QVector3D const neck_guard_bot = headPoint(QVector3D(0.0F, -0.32F, -0.92F));
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, neck_guard_bot, neck_guard_top,
-                                 helmet_r * 0.86F),
+                                  helmet_r * 0.86F),
                  helmet_color * 0.90F, nullptr, 1.0F, 2);
 
   QVector3D const crest_base = apex_pos;

render/equipment/horse/armor/champion_renderer.cpp

@@ -24,12 +24,14 @@ void ChampionRenderer::render(const DrawContext &ctx,
   QMatrix4x4 upper_plate = chest.make_local_transform(
       ctx.model, QVector3D(0.0F, 0.12F, 0.05F), 0.85F);
   upper_plate.scale(0.38F, 0.18F, 0.32F);
-  out.mesh(get_unit_sphere(), upper_plate, armor_color * 1.05F, nullptr, 1.0F, 1);
+  out.mesh(get_unit_sphere(), upper_plate, armor_color * 1.05F, nullptr, 1.0F,
+           1);
 
   QMatrix4x4 lower_plate = chest.make_local_transform(
       ctx.model, QVector3D(0.0F, -0.12F, 0.05F), 0.85F);
   lower_plate.scale(0.38F, 0.18F, 0.32F);
-  out.mesh(get_unit_sphere(), lower_plate, armor_color * 0.95F, nullptr, 1.0F, 1);
+  out.mesh(get_unit_sphere(), lower_plate, armor_color * 0.95F, nullptr, 1.0F,
+           1);
 }
 
 } // namespace Render::GL

render/equipment/horse/tack/stirrup_renderer.cpp

@@ -27,7 +27,8 @@ void StirrupRenderer::render(const DrawContext &ctx,
     QMatrix4x4 foot_plate = ctx.model;
     foot_plate.translate(stirrup_bottom);
     foot_plate.scale(0.10F, 0.015F, 0.12F);
-    out.mesh(get_unit_sphere(), foot_plate, variant.tack_color, nullptr, 1.0F, 4);
+    out.mesh(get_unit_sphere(), foot_plate, variant.tack_color, nullptr, 1.0F,
+             4);
   }
 }
 

render/equipment/weapons/bow_renderer.cpp

@@ -92,8 +92,8 @@ void BowRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, grip - up * 0.05F,
-                                 grip + up * 0.05F,
-                                 m_config.bow_rod_radius * 1.45F),
+                                  grip + up * 0.05F,
+                                  m_config.bow_rod_radius * 1.45F),
                  k_dark_bow_color, nullptr, 1.0F, m_config.material_id);
 
   submitter.mesh(
@@ -152,7 +152,8 @@ void BowRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
                    nullptr, 1.0F, m_config.material_id);
 
     QVector3D const head_base = tip - forward * 0.10F;
-    submitter.mesh(get_unit_cone(), cone_from_to(ctx.model, head_base, tip, 0.05F),
+    submitter.mesh(get_unit_cone(),
+                   cone_from_to(ctx.model, head_base, tip, 0.05F),
                    m_config.metal_color, nullptr, 1.0F, m_config.material_id);
 
     QVector3D const f1b = tail - forward * 0.02F;

render/equipment/weapons/quiver_renderer.cpp

@@ -54,9 +54,10 @@ void QuiverRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, q_top, a1, 0.010F), palette.wood,
                  nullptr, 1.0F, m_config.material_id);
-  submitter.mesh(get_unit_cone(),
-                 cone_from_to(ctx.model, a1, a1 + QVector3D(0, 0.05F, 0), 0.025F),
-                 m_config.fletching_color, nullptr, 1.0F, m_config.material_id);
+  submitter.mesh(
+      get_unit_cone(),
+      cone_from_to(ctx.model, a1, a1 + QVector3D(0, 0.05F, 0), 0.025F),
+      m_config.fletching_color, nullptr, 1.0F, m_config.material_id);
 
   if (m_config.num_arrows >= 2) {
     QVector3D const a2 = q_top + QVector3D(0.02F - j, 0.07F, 0.02F - k);

render/equipment/weapons/roman_scutum.cpp

@@ -125,7 +125,8 @@ void RomanScutumRenderer::render(const DrawContext &ctx,
     QMatrix4x4 m = ctx.model;
     m.translate(rim_pos);
     m.scale(rim_thickness);
-    submitter.mesh(get_unit_sphere(), m, bronze_color * 0.95F, nullptr, 1.0F, 4);
+    submitter.mesh(get_unit_sphere(), m, bronze_color * 0.95F, nullptr, 1.0F,
+                   4);
   }
 
   float const y_pos_bot = -shield_height * 0.48F;
@@ -140,7 +141,8 @@ void RomanScutumRenderer::render(const DrawContext &ctx,
     QMatrix4x4 m = ctx.model;
     m.translate(rim_pos);
     m.scale(rim_thickness);
-    submitter.mesh(get_unit_sphere(), m, bronze_color * 0.95F, nullptr, 1.0F, 4);
+    submitter.mesh(get_unit_sphere(), m, bronze_color * 0.95F, nullptr, 1.0F,
+                   4);
   }
 
   for (int side = 0; side < 2; ++side) {
@@ -174,7 +176,8 @@ void RomanScutumRenderer::render(const DrawContext &ctx,
     QMatrix4x4 m = ctx.model;
     m.translate(rivet_pos);
     m.scale(0.012F);
-    submitter.mesh(get_unit_sphere(), m, bronze_color * 1.15F, nullptr, 1.0F, 4);
+    submitter.mesh(get_unit_sphere(), m, bronze_color * 1.15F, nullptr, 1.0F,
+                   4);
   }
 }
 

render/equipment/weapons/shield_carthage.cpp

@@ -163,7 +163,7 @@ void CarthageShieldRenderer::render(const DrawContext &ctx,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, emblem_body_bot, emblem_body_top,
-                                 emblem_radius),
+                                  emblem_radius),
                  metal_color, nullptr, 1.0F, 4);
 
   QVector3D const emblem_arm_height =
@@ -175,21 +175,22 @@ void CarthageShieldRenderer::render(const DrawContext &ctx,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, emblem_arm_left, emblem_arm_right,
-                                 emblem_radius * 0.75F),
+                                  emblem_radius * 0.75F),
                  metal_color, nullptr, 1.0F, 4);
 
   submitter.mesh(get_unit_sphere(),
                  sphere_at(ctx.model,
-                          emblem_body_top + axis_y * (shield_radius * 0.05F),
-                          emblem_radius * 1.4F),
+                           emblem_body_top + axis_y * (shield_radius * 0.05F),
+                           emblem_radius * 1.4F),
                  metal_color, nullptr, 1.0F, 4);
 
-  submitter.mesh(get_unit_cone(),
-                 cone_from_to(ctx.model,
-                            emblem_body_bot - axis_y * (shield_radius * 0.04F),
-                            emblem_plane - axis_y * (shield_radius * 0.22F),
-                            emblem_radius * 1.6F),
-                 metal_color, nullptr, 1.0F, 4);
+  submitter.mesh(
+      get_unit_cone(),
+      cone_from_to(ctx.model,
+                   emblem_body_bot - axis_y * (shield_radius * 0.04F),
+                   emblem_plane - axis_y * (shield_radius * 0.22F),
+                   emblem_radius * 1.6F),
+      metal_color, nullptr, 1.0F, 4);
 
   QVector3D const grip_a = shield_center - axis_x * 0.035F - n * 0.030F;
   QVector3D const grip_b = shield_center + axis_x * 0.035F - n * 0.030F;

render/equipment/weapons/shield_renderer.cpp

@@ -58,8 +58,8 @@ void ShieldRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
     m.translate(shield_center - n * plate_half);
     m.rotate(k_shield_yaw_degrees, 0.0F, 1.0F, 0.0F);
     m.scale(shield_width * 0.985F, shield_height * 0.985F, plate_full);
-    submitter.mesh(get_unit_cylinder(), m, palette.leather * 0.8F, nullptr, 1.0F,
-                   m_config.material_id);
+    submitter.mesh(get_unit_cylinder(), m, palette.leather * 0.8F, nullptr,
+                   1.0F, m_config.material_id);
   }
 
   auto draw_ring_rotated = [&](float width, float height, float thickness,

render/equipment/weapons/shield_roman.cpp

@@ -67,17 +67,19 @@ void RomanShieldRenderer::render(const DrawContext &ctx,
                        axis_x * (shield_width * 0.5F);
   QVector3D top_right = shield_center + axis_y * (shield_height * 0.5F) +
                         axis_x * (shield_width * 0.5F);
-  submitter.mesh(get_unit_cylinder(),
-                 cylinder_between(ctx.model, top_left, top_right, rim_thickness),
-                 trim_color, nullptr, 1.0F, 4);
+  submitter.mesh(
+      get_unit_cylinder(),
+      cylinder_between(ctx.model, top_left, top_right, rim_thickness),
+      trim_color, nullptr, 1.0F, 4);
 
   QVector3D bot_left = shield_center - axis_y * (shield_height * 0.5F) -
                        axis_x * (shield_width * 0.5F);
   QVector3D bot_right = shield_center - axis_y * (shield_height * 0.5F) +
                         axis_x * (shield_width * 0.5F);
-  submitter.mesh(get_unit_cylinder(),
-                 cylinder_between(ctx.model, bot_left, bot_right, rim_thickness),
-                 trim_color, nullptr, 1.0F, 4);
+  submitter.mesh(
+      get_unit_cylinder(),
+      cylinder_between(ctx.model, bot_left, bot_right, rim_thickness),
+      trim_color, nullptr, 1.0F, 4);
 
   float const boss_radius = 0.08F;
   submitter.mesh(get_unit_sphere(),

render/equipment/weapons/spear_renderer.cpp

@@ -39,7 +39,7 @@ void SpearRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, shaft_mid, shaft_tip,
-                                 m_config.shaft_radius * 0.95F),
+                                  m_config.shaft_radius * 0.95F),
                  m_config.shaft_color * 0.98F, nullptr, 1.0F,
                  m_config.material_id);
 
@@ -49,13 +49,13 @@ void SpearRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
   submitter.mesh(get_unit_cone(),
                  cone_from_to(ctx.model, spearhead_base, spearhead_tip,
-                            m_config.shaft_radius * 1.8F),
+                              m_config.shaft_radius * 1.8F),
                  m_config.spearhead_color, nullptr, 1.0F, m_config.material_id);
 
   QVector3D const grip_end = grip_pos + spear_dir * 0.10F;
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, grip_pos, grip_end,
-                                 m_config.shaft_radius * 1.5F),
+                                  m_config.shaft_radius * 1.5F),
                  palette.leather * 0.92F, nullptr, 1.0F, m_config.material_id);
 }
 

render/equipment/weapons/sword_renderer.cpp

@@ -90,7 +90,7 @@ void SwordRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, handle_end, blade_base,
-                                 m_config.handle_radius),
+                                  m_config.handle_radius),
                  palette.leather, nullptr, 1.0F, m_config.material_id);
 
   QVector3D const guard_center = blade_base;
@@ -149,14 +149,14 @@ void SwordRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
 
     submitter.mesh(get_unit_cylinder(),
                    cylinder_between(ctx.model, start + right * offset,
-                                   end + right * offset,
-                                   blade_thickness * 0.8F),
+                                    end + right * offset,
+                                    blade_thickness * 0.8F),
                    color * 0.92F, nullptr, 1.0F, m_config.material_id);
 
     submitter.mesh(get_unit_cylinder(),
                    cylinder_between(ctx.model, start - right * offset,
-                                   end - right * offset,
-                                   blade_thickness * 0.8F),
+                                    end - right * offset,
+                                    blade_thickness * 0.8F),
                    color * 0.92F, nullptr, 1.0F, m_config.material_id);
   };
 
@@ -185,7 +185,7 @@ void SwordRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
       blade_base + sword_dir * (tip_start_dist - 0.06F);
   submitter.mesh(get_unit_cylinder(),
                  cylinder_between(ctx.model, fuller_start, fuller_end,
-                                 blade_thickness * 0.6F),
+                                  blade_thickness * 0.6F),
                  m_config.metal_color * 0.65F, nullptr, 1.0F,
                  m_config.material_id);
 
@@ -201,10 +201,10 @@ void SwordRenderer::render(const DrawContext &ctx, const BodyFrames &frames,
     float const alpha = clamp01(0.35F * (1.0F - t));
     QVector3D const trail_start = blade_base - sword_dir * 0.05F;
     QVector3D const trail_end = blade_base - sword_dir * (0.28F + 0.15F * t);
-    submitter.mesh(get_unit_cone(),
-                   cone_from_to(ctx.model, trail_end, trail_start, base_w * 0.9F),
-                   m_config.metal_color * 0.9F, nullptr, alpha,
-                   m_config.material_id);
+    submitter.mesh(
+        get_unit_cone(),
+        cone_from_to(ctx.model, trail_end, trail_start, base_w * 0.9F),
+        m_config.metal_color * 0.9F, nullptr, alpha, m_config.material_id);
   }
 }
 

render/geom/arrow.cpp

@@ -92,7 +92,7 @@ auto Arrow::get() -> GL::Mesh * {
 namespace GL {
 
 void render_arrows(Renderer *renderer, ResourceManager *resources,
-                  const Game::Systems::ArrowSystem &arrow_system) {
+                   const Game::Systems::ArrowSystem &arrow_system) {
   if ((renderer == nullptr) || (resources == nullptr)) {
     return;
   }

render/geom/arrow.h

@@ -24,5 +24,5 @@ class ArrowSystem;
 
 namespace Render::GL {
 void render_arrows(Renderer *renderer, ResourceManager *resources,
-                  const Game::Systems::ArrowSystem &arrow_system);
+                   const Game::Systems::ArrowSystem &arrow_system);
 }

render/gl/backend.cpp

@@ -191,7 +191,8 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
     return;
   }
 
-  const QMatrix4x4 view_proj = cam.get_projection_matrix() * cam.get_view_matrix();
+  const QMatrix4x4 view_proj =
+      cam.get_projection_matrix() * cam.get_view_matrix();
 
   m_lastBoundShader = nullptr;
   m_lastBoundTexture = nullptr;
@@ -275,7 +276,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         if (m_cylinderPipeline->m_fogUniforms.view_proj !=
             Shader::InvalidUniform) {
           fog_shader->set_uniform(m_cylinderPipeline->m_fogUniforms.view_proj,
-                                 view_proj);
+                                  view_proj);
         }
         m_cylinderPipeline->upload_fog_instances(instance_count);
         m_cylinderPipeline->draw_fog(instance_count);
@@ -464,7 +465,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       if (m_vegetationPipeline->m_plantUniforms.time !=
           Shader::InvalidUniform) {
         plant_shader->set_uniform(m_vegetationPipeline->m_plantUniforms.time,
-                                 plant.params.time);
+                                  plant.params.time);
       }
       if (m_vegetationPipeline->m_plantUniforms.wind_strength !=
           Shader::InvalidUniform) {
@@ -547,11 +548,11 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       if (m_vegetationPipeline->m_pineUniforms.view_proj !=
           Shader::InvalidUniform) {
         pine_shader->set_uniform(m_vegetationPipeline->m_pineUniforms.view_proj,
-                                view_proj);
+                                 view_proj);
       }
       if (m_vegetationPipeline->m_pineUniforms.time != Shader::InvalidUniform) {
         pine_shader->set_uniform(m_vegetationPipeline->m_pineUniforms.time,
-                                pine.params.time);
+                                 pine.params.time);
       }
       if (m_vegetationPipeline->m_pineUniforms.wind_strength !=
           Shader::InvalidUniform) {
@@ -561,8 +562,9 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       }
       if (m_vegetationPipeline->m_pineUniforms.wind_speed !=
           Shader::InvalidUniform) {
-        pine_shader->set_uniform(m_vegetationPipeline->m_pineUniforms.wind_speed,
-                                pine.params.wind_speed);
+        pine_shader->set_uniform(
+            m_vegetationPipeline->m_pineUniforms.wind_speed,
+            pine.params.wind_speed);
       }
       if (m_vegetationPipeline->m_pineUniforms.light_direction !=
           Shader::InvalidUniform) {
@@ -638,7 +640,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
       if (m_vegetationPipeline->m_oliveUniforms.time !=
           Shader::InvalidUniform) {
         olive_shader->set_uniform(m_vegetationPipeline->m_oliveUniforms.time,
-                                 olive.params.time);
+                                  olive.params.time);
       }
       if (m_vegetationPipeline->m_oliveUniforms.wind_strength !=
           Shader::InvalidUniform) {
@@ -828,12 +830,12 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
 
         if (m_terrainPipeline->m_groundUniforms.mvp != Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_groundUniforms.mvp,
-                                    mvp);
+                                     mvp);
         }
         if (m_terrainPipeline->m_groundUniforms.model !=
             Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_groundUniforms.model,
-                                    terrain.model);
+                                     terrain.model);
         }
         if (m_terrainPipeline->m_groundUniforms.grass_primary !=
             Shader::InvalidUniform) {
@@ -862,7 +864,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         if (m_terrainPipeline->m_groundUniforms.tint !=
             Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_groundUniforms.tint,
-                                    terrain.params.tint);
+                                     terrain.params.tint);
         }
         if (m_terrainPipeline->m_groundUniforms.noise_offset !=
             Shader::InvalidUniform) {
@@ -969,12 +971,12 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         if (m_terrainPipeline->m_terrainUniforms.mvp !=
             Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_terrainUniforms.mvp,
-                                    mvp);
+                                     mvp);
         }
         if (m_terrainPipeline->m_terrainUniforms.model !=
             Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_terrainUniforms.model,
-                                    terrain.model);
+                                     terrain.model);
         }
         if (m_terrainPipeline->m_terrainUniforms.grass_primary !=
             Shader::InvalidUniform) {
@@ -1015,7 +1017,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         if (m_terrainPipeline->m_terrainUniforms.tint !=
             Shader::InvalidUniform) {
           active_shader->set_uniform(m_terrainPipeline->m_terrainUniforms.tint,
-                                    terrain.params.tint);
+                                     terrain.params.tint);
         }
         if (m_terrainPipeline->m_terrainUniforms.noise_offset !=
             Shader::InvalidUniform) {
@@ -1189,13 +1191,13 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         }
 
         active_shader->set_uniform(m_waterPipeline->m_riverUniforms.model,
-                                  it.model);
+                                   it.model);
         active_shader->set_uniform(m_waterPipeline->m_riverUniforms.view,
-                                  cam.get_view_matrix());
+                                   cam.get_view_matrix());
         active_shader->set_uniform(m_waterPipeline->m_riverUniforms.projection,
-                                  cam.get_projection_matrix());
+                                   cam.get_projection_matrix());
         active_shader->set_uniform(m_waterPipeline->m_riverUniforms.time,
-                                  m_animationTime);
+                                   m_animationTime);
 
         it.mesh->draw();
         break;
@@ -1208,14 +1210,14 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         }
 
         active_shader->set_uniform(m_waterPipeline->m_riverbankUniforms.model,
-                                  it.model);
+                                   it.model);
         active_shader->set_uniform(m_waterPipeline->m_riverbankUniforms.view,
-                                  cam.get_view_matrix());
+                                   cam.get_view_matrix());
         active_shader->set_uniform(
             m_waterPipeline->m_riverbankUniforms.projection,
             cam.get_projection_matrix());
         active_shader->set_uniform(m_waterPipeline->m_riverbankUniforms.time,
-                                  m_animationTime);
+                                   m_animationTime);
 
         it.mesh->draw();
         break;
@@ -1228,11 +1230,11 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
         }
 
         active_shader->set_uniform(m_waterPipeline->m_bridgeUniforms.mvp,
-                                  it.mvp);
+                                   it.mvp);
         active_shader->set_uniform(m_waterPipeline->m_bridgeUniforms.model,
-                                  it.model);
+                                   it.model);
         active_shader->set_uniform(m_waterPipeline->m_bridgeUniforms.color,
-                                  it.color);
+                                   it.color);
 
         QVector3D const light_dir(0.35F, 0.8F, 0.45F);
         active_shader->set_uniform(
@@ -1248,13 +1250,14 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
           m_lastBoundShader = active_shader;
         }
 
-        active_shader->set_uniform(m_waterPipeline->m_road_uniforms.mvp, it.mvp);
+        active_shader->set_uniform(m_waterPipeline->m_road_uniforms.mvp,
+                                   it.mvp);
         active_shader->set_uniform(m_waterPipeline->m_road_uniforms.model,
-                                  it.model);
+                                   it.model);
         active_shader->set_uniform(m_waterPipeline->m_road_uniforms.color,
-                                  it.color);
+                                   it.color);
         active_shader->set_uniform(m_waterPipeline->m_road_uniforms.alpha,
-                                  it.alpha);
+                                   it.alpha);
 
         QVector3D const road_light_dir(0.35F, 0.8F, 0.45F);
         active_shader->set_uniform(

render/gl/backend.h

@@ -57,7 +57,7 @@ public:
     return m_shaderCache ? m_shaderCache->get(name) : nullptr;
   }
   auto get_or_load_shader(const QString &name, const QString &vertPath,
-                       const QString &fragPath) -> Shader * {
+                          const QString &fragPath) -> Shader * {
     if (!m_shaderCache) {
       return nullptr;
     }

render/gl/backend/vegetation_pipeline.cpp

@@ -94,7 +94,8 @@ void VegetationPipeline::cache_uniforms() {
   if (m_pineShader != nullptr) {
     m_pineUniforms.view_proj = m_pineShader->uniform_handle("uViewProj");
     m_pineUniforms.time = m_pineShader->uniform_handle("uTime");
-    m_pineUniforms.wind_strength = m_pineShader->uniform_handle("uWindStrength");
+    m_pineUniforms.wind_strength =
+        m_pineShader->uniform_handle("uWindStrength");
     m_pineUniforms.wind_speed = m_pineShader->uniform_handle("uWindSpeed");
     m_pineUniforms.light_direction =
         m_pineShader->uniform_handle("uLightDirection");

render/gl/backend/vegetation_pipeline.h

@@ -26,7 +26,9 @@ public:
   [[nodiscard]] auto plant_shader() const -> GL::Shader * {
     return m_plantShader;
   }
-  [[nodiscard]] auto pine_shader() const -> GL::Shader * { return m_pineShader; }
+  [[nodiscard]] auto pine_shader() const -> GL::Shader * {
+    return m_pineShader;
+  }
   [[nodiscard]] auto olive_shader() const -> GL::Shader * {
     return m_oliveShader;
   }

render/gl/camera.cpp

@@ -185,7 +185,7 @@ void Camera::lookAt(const QVector3D &position, const QVector3D &target,
 }
 
 void Camera::set_perspective(float fov, float aspect, float near_plane,
-                            float far_plane) {
+                             float far_plane) {
   if (!finite(fov) || !finite(aspect) || !finite(near_plane) ||
       !finite(far_plane)) {
     return;
@@ -200,7 +200,7 @@ void Camera::set_perspective(float fov, float aspect, float near_plane,
 }
 
 void Camera::set_orthographic(float left, float right, float bottom, float top,
-                             float near_plane, float far_plane) {
+                              float near_plane, float far_plane) {
   if (!finite(left) || !finite(right) || !finite(bottom) || !finite(top) ||
       !finite(near_plane) || !finite(far_plane)) {
     return;
@@ -508,7 +508,7 @@ void Camera::update_follow(const QVector3D &targetCenter) {
 }
 
 void Camera::set_rts_view(const QVector3D &center, float distance, float angle,
-                        float yaw_deg) {
+                          float yaw_deg) {
   if (!finite(center) || !finite(distance) || !finite(angle) ||
       !finite(yaw_deg)) {
     return;
@@ -729,7 +729,8 @@ void Camera::computeYawPitchFromOffset(const QVector3D &off, float &yaw_deg,
   pitch_deg = pitch;
 }
 
-auto Camera::is_in_frustum(const QVector3D &center, float radius) const -> bool {
+auto Camera::is_in_frustum(const QVector3D &center,
+                           float radius) const -> bool {
 
   QMatrix4x4 const vp = get_view_projection_matrix();
 

render/gl/camera.h

@@ -30,9 +30,9 @@ public:
               const QVector3D &up);
 
   void set_perspective(float fov, float aspect, float near_plane,
-                      float far_plane);
+                       float far_plane);
   void set_orthographic(float left, float right, float bottom, float top,
-                       float near_plane, float far_plane);
+                        float near_plane, float far_plane);
 
   void move_forward(float distance);
   void move_right(float distance);
@@ -55,18 +55,21 @@ public:
                        QPointF &outScreen) const -> bool;
 
   void set_follow_enabled(bool enable) { m_followEnabled = enable; }
-  [[nodiscard]] auto is_follow_enabled() const -> bool { return m_followEnabled; }
+  [[nodiscard]] auto is_follow_enabled() const -> bool {
+    return m_followEnabled;
+  }
   void set_follow_lerp(float alpha) { m_followLerp = alpha; }
   void set_follow_offset(const QVector3D &off) { m_followOffset = off; }
   void capture_follow_offset() { m_followOffset = m_position - m_target; }
   void update_follow(const QVector3D &targetCenter);
 
   void set_rts_view(const QVector3D &center,
-                  float distance = CameraDefaults::k_default_rts_distance,
-                  float angle = CameraDefaults::k_default_rts_angle,
-                  float yaw_deg = CameraDefaults::k_default_rts_yaw);
-  void set_top_down_view(const QVector3D &center,
-                      float distance = CameraDefaults::k_default_rts_distance);
+                    float distance = CameraDefaults::k_default_rts_distance,
+                    float angle = CameraDefaults::k_default_rts_angle,
+                    float yaw_deg = CameraDefaults::k_default_rts_yaw);
+  void
+  set_top_down_view(const QVector3D &center,
+                    float distance = CameraDefaults::k_default_rts_distance);
   void apply_soft_boundaries(bool isPanning = false);
 
   [[nodiscard]] auto get_view_matrix() const -> QMatrix4x4;
@@ -94,7 +97,7 @@ public:
   [[nodiscard]] auto get_far() const -> float { return m_far_plane; }
 
   [[nodiscard]] auto is_in_frustum(const QVector3D &center,
-                                 float radius) const -> bool;
+                                   float radius) const -> bool;
 
 private:
   QVector3D m_position{0.0F, 0.0F, 0.0F};

render/gl/primitives.cpp

@@ -593,7 +593,8 @@ auto get_unit_sphere(int latSegments, int lonSegments) -> Mesh * {
 }
 
 auto get_unit_cone(int radialSegments) -> Mesh * {
-  static std::unique_ptr<Mesh> const s_mesh(create_unit_cone_mesh(radialSegments));
+  static std::unique_ptr<Mesh> const s_mesh(
+      create_unit_cone_mesh(radialSegments));
   return s_mesh.get();
 }
 

render/gl/primitives.h

@@ -14,15 +14,15 @@ auto get_unit_cylinder(int radialSegments = kDefaultRadialSegments) -> Mesh *;
 auto get_unit_cube() -> Mesh *;
 
 auto get_unit_sphere(int latSegments = kDefaultLatitudeSegments,
-                   int lonSegments = kDefaultRadialSegments) -> Mesh *;
+                     int lonSegments = kDefaultRadialSegments) -> Mesh *;
 
 auto get_unit_cone(int radialSegments = kDefaultRadialSegments) -> Mesh *;
 
 auto get_unit_capsule(int radialSegments = kDefaultRadialSegments,
-                    int heightSegments = kDefaultCapsuleHeightSegments)
+                      int heightSegments = kDefaultCapsuleHeightSegments)
     -> Mesh *;
 
 auto get_unit_torso(int radialSegments = kDefaultRadialSegments,
-                  int heightSegments = kDefaultTorsoHeightSegments) -> Mesh *;
+                    int heightSegments = kDefaultTorsoHeightSegments) -> Mesh *;
 
 } // namespace Render::GL

render/gl/shader.cpp

@@ -29,7 +29,7 @@ Shader::~Shader() {
 }
 
 auto Shader::load_from_files(const QString &vertexPath,
-                           const QString &fragmentPath) -> bool {
+                             const QString &fragmentPath) -> bool {
   const QString resolved_vert =
       Utils::Resources::resolveResourcePath(vertexPath);
   const QString resolved_frag =
@@ -65,7 +65,7 @@ auto Shader::load_from_files(const QString &vertexPath,
 }
 
 auto Shader::load_from_source(const QString &vertex_source,
-                            const QString &fragment_source) -> bool {
+                              const QString &fragment_source) -> bool {
   initializeOpenGLFunctions();
   m_uniformCache.clear();
   GLuint const vertex_shader = compile_shader(vertex_source, GL_VERTEX_SHADER);
@@ -125,7 +125,8 @@ auto Shader::uniform_handle(const char *name) -> Shader::UniformHandle {
   return uniformHandleImpl(*this, m_program, m_uniformCache, name, true);
 }
 
-auto Shader::optional_uniform_handle(const char *name) -> Shader::UniformHandle {
+auto Shader::optional_uniform_handle(const char *name)
+    -> Shader::UniformHandle {
   return uniformHandleImpl(*this, m_program, m_uniformCache, name, false);
 }
 
@@ -243,7 +244,8 @@ auto Shader::compile_shader(const QString &source, GLenum type) -> GLuint {
   return shader;
 }
 
-auto Shader::link_program(GLuint vertex_shader, GLuint fragment_shader) -> bool {
+auto Shader::link_program(GLuint vertex_shader,
+                          GLuint fragment_shader) -> bool {
   initializeOpenGLFunctions();
   m_program = glCreateProgram();
   glAttachShader(m_program, vertex_shader);

render/gl/shader.h

@@ -18,9 +18,9 @@ public:
   ~Shader() override;
 
   auto load_from_files(const QString &vertexPath,
-                     const QString &fragmentPath) -> bool;
+                       const QString &fragmentPath) -> bool;
   auto load_from_source(const QString &vertex_source,
-                      const QString &fragment_source) -> bool;
+                        const QString &fragment_source) -> bool;
 
   void use();
   void release();

render/gl/shader_cache.h

@@ -40,7 +40,8 @@ public:
     return (it != m_named.end()) ? it->second.get() : nullptr;
   }
 
-  auto get_or_load(const QString &vertPath, const QString &fragPath) -> Shader * {
+  auto get_or_load(const QString &vertPath,
+                   const QString &fragPath) -> Shader * {
     const QString resolved_vert =
         Utils::Resources::resolveResourcePath(vertPath);
     const QString resolved_frag =

render/gl/texture.cpp

@@ -89,8 +89,10 @@ void Texture::unbind() {
 
 void Texture::set_filter(Filter minFilter, Filter magFilter) {
   bind();
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, get_gl_filter(minFilter));
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, get_gl_filter(magFilter));
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                  get_gl_filter(minFilter));
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                  get_gl_filter(magFilter));
 }
 
 void Texture::set_wrap(Wrap sWrap, Wrap tWrap) {

render/gl/texture.h

@@ -17,7 +17,8 @@ public:
   ~Texture() override;
 
   auto load_from_file(const QString &path) -> bool;
-  auto create_empty(int width, int height, Format format = Format::RGBA) -> bool;
+  auto create_empty(int width, int height,
+                    Format format = Format::RGBA) -> bool;
 
   void bind(int unit = 0);
   void unbind();

render/ground/firecamp_renderer.cpp

@@ -124,7 +124,7 @@ void FireCampRenderer::submit(Renderer &renderer, ResourceManager *resources) {
             std::make_unique<Buffer>(Buffer::Type::Vertex);
       }
       m_fireCampInstanceBuffer->set_data(m_visibleInstances,
-                                        Buffer::Usage::Static);
+                                         Buffer::Usage::Static);
     }
   }
 

render/ground/fog_renderer.cpp

@@ -16,7 +16,7 @@ const QMatrix4x4 k_identity_matrix;
 }
 
 void FogRenderer::update_mask(int width, int height, float tile_size,
-                             const std::vector<std::uint8_t> &cells) {
+                              const std::vector<std::uint8_t> &cells) {
   m_width = std::max(0, width);
   m_height = std::max(0, height);
   m_tile_size = std::max(0.0001F, tile_size);

render/ground/fog_renderer.h

@@ -21,7 +21,7 @@ public:
   [[nodiscard]] auto is_enabled() const -> bool { return m_enabled; }
 
   void update_mask(int width, int height, float tile_size,
-                  const std::vector<std::uint8_t> &cells);
+                   const std::vector<std::uint8_t> &cells);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 

render/ground/olive_renderer.cpp

@@ -110,7 +110,8 @@ void OliveRenderer::submit(Renderer &renderer, ResourceManager *resources) {
       if (!m_oliveInstanceBuffer) {
         m_oliveInstanceBuffer = std::make_unique<Buffer>(Buffer::Type::Vertex);
       }
-      m_oliveInstanceBuffer->set_data(m_visibleInstances, Buffer::Usage::Static);
+      m_oliveInstanceBuffer->set_data(m_visibleInstances,
+                                      Buffer::Usage::Static);
     }
   }
 

render/ground/plant_renderer.cpp

@@ -112,7 +112,7 @@ void PlantRenderer::submit(Renderer &renderer, ResourceManager *resources) {
             std::make_unique<Buffer>(Buffer::Type::Vertex);
       }
       m_visibleInstanceBuffer->set_data(m_visibleInstances,
-                                       Buffer::Usage::Static);
+                                        Buffer::Usage::Static);
     }
   }
 

render/ground/riverbank_asset_renderer.cpp

@@ -110,7 +110,7 @@ void RiverbankAssetRenderer::submit(Renderer &, ResourceManager *resources) {
     }
     if (!m_visibleInstances.empty()) {
       m_assetInstanceBuffer->set_data(m_visibleInstances,
-                                     Buffer::Usage::Dynamic);
+                                      Buffer::Usage::Dynamic);
     }
 
     m_cachedVisibilityVersion = current_version;

render/horse/horse_animation_controller.cpp

@@ -172,7 +172,9 @@ auto HorseAnimationController::get_current_phase() const -> float {
   return m_phase;
 }
 
-auto HorseAnimationController::get_current_bob() const -> float { return m_bob; }
+auto HorseAnimationController::get_current_bob() const -> float {
+  return m_bob;
+}
 
 auto HorseAnimationController::get_stride_cycle() const -> float {
   GaitParameters const params = getGaitParams(m_current_gait);

render/horse/rig.cpp

@@ -119,8 +119,8 @@ inline void drawCone(ISubmitter &out, const QMatrix4x4 &model,
                      const QVector3D &tip, const QVector3D &base, float radius,
                      const QVector3D &color, float alpha = 1.0F,
                      int materialId = 0) {
-  out.mesh(get_unit_cone(), cone_from_to(model, tip, base, radius), color, nullptr,
-           alpha, materialId);
+  out.mesh(get_unit_cone(), cone_from_to(model, tip, base, radius), color,
+           nullptr, alpha, materialId);
 }
 
 inline void drawRoundedSegment(ISubmitter &out, const QMatrix4x4 &model,
@@ -133,8 +133,9 @@ inline void drawRoundedSegment(ISubmitter &out, const QMatrix4x4 &model,
   QVector3D const tint = lerp(start_color, end_color, 0.5F);
   out.mesh(get_unit_cylinder(), cylinder_between(model, start, end, mid_radius),
            tint, nullptr, alpha, materialId);
-  out.mesh(get_unit_sphere(), Render::Geom::sphere_at(model, start, start_radius),
-           start_color, nullptr, alpha, materialId);
+  out.mesh(get_unit_sphere(),
+           Render::Geom::sphere_at(model, start, start_radius), start_color,
+           nullptr, alpha, materialId);
   out.mesh(get_unit_sphere(), Render::Geom::sphere_at(model, end, end_radius),
            end_color, nullptr, alpha, materialId);
 }
@@ -584,12 +585,12 @@ void HorseRendererBase::render_full(
       coatGradient(v.coat_color, 0.78F, 0.12F, coat_seed_c * 0.6F);
   out.mesh(get_unit_cylinder(),
            cylinder_between(horse_ctx.model, neck_base, neck_mid,
-                           neck_radius * 1.00F),
+                            neck_radius * 1.00F),
            neck_color_base, nullptr, 1.0F);
-  out.mesh(
-      get_unit_cylinder(),
-      cylinder_between(horse_ctx.model, neck_mid, neck_top, neck_radius * 0.86F),
-      lighten(neck_color_base, 1.03F), nullptr, 1.0F);
+  out.mesh(get_unit_cylinder(),
+           cylinder_between(horse_ctx.model, neck_mid, neck_top,
+                            neck_radius * 0.86F),
+           lighten(neck_color_base, 1.03F), nullptr, 1.0F);
 
   {
     QVector3D const jugular_start =
@@ -670,11 +671,11 @@ void HorseRendererBase::render_full(
         QVector3D(0.0F, -d.head_height * 0.02F, d.muzzle_length * -0.30F);
     out.mesh(get_unit_cone(),
              cone_from_to(horse_ctx.model, left_base + inward, left_base,
-                        d.head_width * 0.11F),
+                          d.head_width * 0.11F),
              darken(v.muzzle_color, 0.6F), nullptr, 1.0F);
     out.mesh(get_unit_cone(),
              cone_from_to(horse_ctx.model, right_base + inward, right_base,
-                        d.head_width * 0.11F),
+                          d.head_width * 0.11F),
              darken(v.muzzle_color, 0.6F), nullptr, 1.0F);
   }
 
@@ -700,11 +701,11 @@ void HorseRendererBase::render_full(
 
   out.mesh(get_unit_cone(),
            cone_from_to(horse_ctx.model, ear_tip_left, ear_base_left,
-                      d.head_width * 0.11F),
+                        d.head_width * 0.11F),
            v.mane_color, nullptr, 1.0F);
   out.mesh(get_unit_cone(),
            cone_from_to(horse_ctx.model, ear_tip_right, ear_base_right,
-                      d.head_width * 0.11F),
+                        d.head_width * 0.11F),
            v.mane_color, nullptr, 1.0F);
 
   QVector3D const eye_left =
@@ -727,8 +728,8 @@ void HorseRendererBase::render_full(
       QMatrix4x4 pupil = horse_ctx.model;
       pupil.translate(pos + QVector3D(0.0F, 0.0F, d.head_width * 0.04F));
       pupil.scale(d.head_width * 0.05F);
-      out.mesh(get_unit_sphere(), pupil, QVector3D(0.03F, 0.03F, 0.03F), nullptr,
-               1.0F, 6);
+      out.mesh(get_unit_sphere(), pupil, QVector3D(0.03F, 0.03F, 0.03F),
+               nullptr, 1.0F, 6);
     }
     {
 
@@ -791,7 +792,7 @@ void HorseRendererBase::render_full(
         seg_start + QVector3D(sway, 0.07F - t * 0.05F, -0.05F - t * 0.03F);
     out.mesh(get_unit_cylinder(),
              cylinder_between(horse_ctx.model, seg_start, seg_end,
-                             d.head_width * (0.10F * (1.0F - t * 0.4F))),
+                              d.head_width * (0.10F * (1.0F - t * 0.4F))),
              v.mane_color * (0.98F + t * 0.05F), nullptr, 1.0F, 7);
   }
 
@@ -873,8 +874,8 @@ void HorseRendererBase::render_full(
     sole.translate(hoof_center + QVector3D(0.0F, -hoof_height * 0.45F, 0.0F));
     sole.scale(
         QVector3D(half_width * 0.92F, hoof_height * 0.08F, half_depth * 0.95F));
-    out.mesh(get_unit_cylinder(), sole, darken(hoof_color, 0.72F), nullptr, 1.0F,
-             8);
+    out.mesh(get_unit_cylinder(), sole, darken(hoof_color, 0.72F), nullptr,
+             1.0F, 8);
 
     QMatrix4x4 toe = horse_ctx.model;
     toe.translate(hoof_center + QVector3D(0.0F, -hoof_height * 0.10F,

render/humanoid/humanoid_math.cpp

@@ -5,9 +5,9 @@
 namespace Render::GL {
 
 auto elbow_bend_torso(const QVector3D &shoulder, const QVector3D &hand,
-                    const QVector3D &outwardDir, float alongFrac,
-                    float lateral_offset, float yBias,
-                    float outwardSign) -> QVector3D {
+                      const QVector3D &outwardDir, float alongFrac,
+                      float lateral_offset, float yBias,
+                      float outwardSign) -> QVector3D {
   QVector3D dir = hand - shoulder;
   float const dist = std::max(dir.length(), 1e-5F);
   dir /= dist;

render/humanoid/humanoid_math.h

@@ -26,8 +26,8 @@ inline auto right_of(const QVector3D &fwd) -> QVector3D {
 }
 
 auto elbow_bend_torso(const QVector3D &shoulder, const QVector3D &hand,
-                    const QVector3D &outwardDir, float alongFrac,
-                    float lateral_offset, float yBias,
-                    float outwardSign) -> QVector3D;
+                      const QVector3D &outwardDir, float alongFrac,
+                      float lateral_offset, float yBias,
+                      float outwardSign) -> QVector3D;
 
 } // namespace Render::GL

render/humanoid/mounted_pose_controller.cpp

@@ -32,7 +32,8 @@ MountedPoseController::MountedPoseController(
     HumanoidPose &pose, const HumanoidAnimationContext &anim_ctx)
     : m_pose(pose), m_anim_ctx(anim_ctx) {}
 
-void MountedPoseController::mount_on_horse(const MountedAttachmentFrame &mount) {
+void MountedPoseController::mount_on_horse(
+    const MountedAttachmentFrame &mount) {
   positionPelvisOnSaddle(mount);
   attach_feet_to_stirrups(mount);
   calculate_riding_knees(mount);
@@ -58,9 +59,9 @@ void MountedPoseController::ridingIdle(const MountedAttachmentFrame &mount) {
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), left_hand_rest,
-                                left_outward, 0.45F, 0.12F, -0.05F, 1.0F);
+                                   left_outward, 0.45F, 0.12F, -0.05F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), right_hand_rest,
-                                 right_outward, 0.45F, 0.12F, -0.05F, 1.0F);
+                                    right_outward, 0.45F, 0.12F, -0.05F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "ridingIdle");
 }
@@ -109,9 +110,9 @@ void MountedPoseController::ridingReining(const MountedAttachmentFrame &mount,
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), left_rein_pos,
-                                left_outward, 0.52F, 0.08F, -0.12F, 1.0F);
+                                   left_outward, 0.52F, 0.08F, -0.12F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), right_rein_pos,
-                                 right_outward, 0.52F, 0.08F, -0.12F, 1.0F);
+                                    right_outward, 0.52F, 0.08F, -0.12F, 1.0F);
 
   float const avg_tension = (left_tension + right_tension) * 0.5F;
   QVector3D const lean_back = mount.seat_forward * (-0.08F * avg_tension);
@@ -221,10 +222,10 @@ void MountedPoseController::stabilizeUpperBody(
 }
 
 void MountedPoseController::apply_pose(const MountedAttachmentFrame &mount,
-                                      const MountedRiderPoseRequest &request) {
+                                       const MountedRiderPoseRequest &request) {
   mount_on_horse(mount);
   apply_saddle_clearance(mount, request.dims, request.clearanceForward,
-                       request.clearanceUp);
+                         request.clearanceUp);
 
   stabilizeUpperBody(mount, request.dims);
 
@@ -243,12 +244,12 @@ void MountedPoseController::apply_pose(const MountedAttachmentFrame &mount,
   apply_lean(mount, forward, request.sideBias);
 
   apply_torso_sculpt(mount, request.torsoCompression, request.torsoTwist,
-                   request.shoulderDip);
+                     request.shoulderDip);
 
   float const clamped_forward = std::clamp(forward, -1.0F, 1.0F);
   float const clamped_side = std::clamp(request.sideBias, -1.0F, 1.0F);
   update_head_hierarchy(mount, clamped_forward * 0.4F, clamped_side * 0.4F,
-                      "applyPose_fixup");
+                        "applyPose_fixup");
 
   const bool needs_weapon_right = request.weaponPose != MountedWeaponPose::None;
   const bool needs_weapon_left =
@@ -290,7 +291,7 @@ void MountedPoseController::apply_pose(const MountedAttachmentFrame &mount,
     break;
   case MountedWeaponPose::SwordStrike:
     apply_sword_strike(mount, request.actionPhase,
-                     request.shieldPose != MountedShieldPose::None);
+                       request.shieldPose != MountedShieldPose::None);
     break;
   case MountedWeaponPose::SpearGuard:
     apply_spear_guard(mount, SpearGrip::OVERHAND);
@@ -308,7 +309,7 @@ void MountedPoseController::apply_pose(const MountedAttachmentFrame &mount,
 }
 
 void MountedPoseController::apply_lean(const MountedAttachmentFrame &mount,
-                                      float forward_lean, float side_lean) {
+                                       float forward_lean, float side_lean) {
   float const clamped_forward = std::clamp(forward_lean, -1.0F, 1.0F);
   float const clamped_side = std::clamp(side_lean, -1.0F, 1.0F);
 
@@ -320,7 +321,7 @@ void MountedPoseController::apply_lean(const MountedAttachmentFrame &mount,
   m_pose.neck_base += lean_offset * 0.9F;
 
   update_head_hierarchy(mount, clamped_forward * 0.4F, clamped_side * 0.4F,
-                      "apply_lean");
+                        "apply_lean");
 }
 
 void MountedPoseController::apply_shield_defense(
@@ -337,9 +338,9 @@ void MountedPoseController::apply_shield_defense(
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), shield_pos,
-                                left_outward, 0.45F, 0.15F, -0.10F, 1.0F);
+                                   left_outward, 0.45F, 0.15F, -0.10F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), rein_pos,
-                                 right_outward, 0.45F, 0.12F, -0.08F, 1.0F);
+                                    right_outward, 0.45F, 0.12F, -0.08F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "shield_defense");
 }
@@ -352,7 +353,7 @@ void MountedPoseController::apply_shield_stowed(
   get_hand(true) = rest;
   const QVector3D left_outward = compute_outward_dir(true);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), rest, left_outward,
-                                0.42F, 0.12F, -0.05F, 1.0F);
+                                   0.42F, 0.12F, -0.05F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "shield_stowed");
 }
@@ -368,8 +369,8 @@ void MountedPoseController::apply_sword_idle_pose(
 
   get_hand(false) = sword_anchor;
   const QVector3D right_outward = compute_outward_dir(false);
-  get_elbow(false) = solve_elbow_ik(false, shoulder_r, sword_anchor, right_outward,
-                                 0.46F, 0.24F, -0.05F, 1.0F);
+  get_elbow(false) = solve_elbow_ik(false, shoulder_r, sword_anchor,
+                                    right_outward, 0.46F, 0.24F, -0.05F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "sword_idle");
 }
@@ -418,12 +419,12 @@ void MountedPoseController::apply_sword_strike(
 
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), hand_r_target,
-                                 right_outward, 0.42F, 0.15F, 0.0F, 1.0F);
+                                    right_outward, 0.42F, 0.15F, 0.0F, 1.0F);
 
   if (!keep_left_hand) {
     const QVector3D left_outward = compute_outward_dir(true);
     get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), hand_l_target,
-                                  left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
+                                     left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
   }
 }
 
@@ -469,13 +470,13 @@ void MountedPoseController::apply_spear_thrust(
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), hand_l_target,
-                                left_outward, 0.48F, 0.10F, -0.06F, 1.0F);
+                                   left_outward, 0.48F, 0.10F, -0.06F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), hand_r_target,
-                                 right_outward, 0.48F, 0.10F, -0.04F, 1.0F);
+                                    right_outward, 0.48F, 0.10F, -0.04F, 1.0F);
 }
 
-void MountedPoseController::apply_spear_guard(const MountedAttachmentFrame &mount,
-                                            SpearGrip grip_style) {
+void MountedPoseController::apply_spear_guard(
+    const MountedAttachmentFrame &mount, SpearGrip grip_style) {
   QVector3D hand_r_target;
   QVector3D hand_l_target;
 
@@ -500,15 +501,15 @@ void MountedPoseController::apply_spear_guard(const MountedAttachmentFrame &moun
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), hand_l_target,
-                                left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
+                                   left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), hand_r_target,
-                                 right_outward, 0.45F, 0.12F, -0.05F, 1.0F);
+                                    right_outward, 0.45F, 0.12F, -0.05F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "spear_guard_pose");
 }
 
 void MountedPoseController::apply_bow_draw(const MountedAttachmentFrame &mount,
-                                         float draw_phase) {
+                                           float draw_phase) {
   draw_phase = std::clamp(draw_phase, 0.0F, 1.0F);
 
   QVector3D const bow_hold_pos = seatRelative(mount, 0.25F, -0.08F, 0.25F);
@@ -537,9 +538,9 @@ void MountedPoseController::apply_bow_draw(const MountedAttachmentFrame &mount,
   const QVector3D left_outward = compute_outward_dir(true);
   const QVector3D right_outward = compute_outward_dir(false);
   get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), hand_l_target,
-                                left_outward, 0.50F, 0.08F, -0.05F, 1.0F);
+                                   left_outward, 0.50F, 0.08F, -0.05F, 1.0F);
   get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), hand_r_target,
-                                 right_outward, 0.48F, 0.12F, -0.08F, 1.0F);
+                                    right_outward, 0.48F, 0.12F, -0.08F, 1.0F);
 
   update_head_hierarchy(mount, 0.0F, 0.0F, "bow_draw");
 }
@@ -601,7 +602,7 @@ void MountedPoseController::holdReinsImpl(const MountedAttachmentFrame &mount,
     get_hand(true) = left_rein_pos;
     const QVector3D left_outward = compute_outward_dir(true);
     get_elbow(true) = solve_elbow_ik(true, get_shoulder(true), left_rein_pos,
-                                  left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
+                                     left_outward, 0.45F, 0.12F, -0.08F, 1.0F);
   }
 
   if (apply_right) {
@@ -609,8 +610,9 @@ void MountedPoseController::holdReinsImpl(const MountedAttachmentFrame &mount,
         reinAnchor(mount, false, right_slack, right_tension);
     get_hand(false) = right_rein_pos;
     const QVector3D right_outward = compute_outward_dir(false);
-    get_elbow(false) = solve_elbow_ik(false, get_shoulder(false), right_rein_pos,
-                                   right_outward, 0.45F, 0.12F, -0.08F, 1.0F);
+    get_elbow(false) =
+        solve_elbow_ik(false, get_shoulder(false), right_rein_pos,
+                       right_outward, 0.45F, 0.12F, -0.08F, 1.0F);
   }
 }
 
@@ -659,13 +661,13 @@ auto MountedPoseController::solve_elbow_ik(
     bool, const QVector3D &shoulder, const QVector3D &hand,
     const QVector3D &outward_dir, float along_frac, float lateral_offset,
     float y_bias, float outward_sign) const -> QVector3D {
-  return elbow_bend_torso(shoulder, hand, outward_dir, along_frac, lateral_offset,
-                        y_bias, outward_sign);
+  return elbow_bend_torso(shoulder, hand, outward_dir, along_frac,
+                          lateral_offset, y_bias, outward_sign);
 }
 
-auto MountedPoseController::solve_knee_ik(bool is_left, const QVector3D &hip,
-                                        const QVector3D &foot,
-                                        float height_scale) const -> QVector3D {
+auto MountedPoseController::solve_knee_ik(
+    bool is_left, const QVector3D &hip, const QVector3D &foot,
+    float height_scale) const -> QVector3D {
   using HP = HumanProportions;
 
   QVector3D hip_to_foot = foot - hip;
@@ -746,7 +748,8 @@ auto MountedPoseController::compute_right_axis() const -> QVector3D {
   return right_axis;
 }
 
-auto MountedPoseController::compute_outward_dir(bool is_left) const -> QVector3D {
+auto MountedPoseController::compute_outward_dir(bool is_left) const
+    -> QVector3D {
   QVector3D const right_axis = compute_right_axis();
   return is_left ? -right_axis : right_axis;
 }

render/humanoid/mounted_pose_controller.h

@@ -74,10 +74,10 @@ public:
   };
 
   void apply_pose(const MountedAttachmentFrame &mount,
-                 const MountedRiderPoseRequest &request);
+                  const MountedRiderPoseRequest &request);
 
   void finalize_head_sync(const MountedAttachmentFrame &mount,
-                        std::string_view debug_label = "final_head_sync");
+                          std::string_view debug_label = "final_head_sync");
 
 private:
   HumanoidPose &m_pose;
@@ -89,12 +89,12 @@ private:
   void calculate_riding_knees(const MountedAttachmentFrame &mount);
 
   auto solve_elbow_ik(bool is_left, const QVector3D &shoulder,
-                    const QVector3D &hand, const QVector3D &outward_dir,
-                    float along_frac, float lateral_offset, float y_bias,
-                    float outward_sign) const -> QVector3D;
+                      const QVector3D &hand, const QVector3D &outward_dir,
+                      float along_frac, float lateral_offset, float y_bias,
+                      float outward_sign) const -> QVector3D;
 
   auto solve_knee_ik(bool is_left, const QVector3D &hip, const QVector3D &foot,
-                   float height_scale) const -> QVector3D;
+                     float height_scale) const -> QVector3D;
 
   auto get_shoulder(bool is_left) const -> const QVector3D &;
   auto get_hand(bool is_left) -> QVector3D &;
@@ -104,34 +104,34 @@ private:
   auto compute_outward_dir(bool is_left) const -> QVector3D;
 
   void apply_lean(const MountedAttachmentFrame &mount, float forward_lean,
-                 float side_lean);
+                  float side_lean);
   void apply_shield_defense(const MountedAttachmentFrame &mount, bool raised);
   void apply_shield_stowed(const MountedAttachmentFrame &mount,
-                         const HorseDimensions &dims);
+                           const HorseDimensions &dims);
   void apply_sword_idle_pose(const MountedAttachmentFrame &mount,
-                          const HorseDimensions &dims);
-  void apply_sword_strike(const MountedAttachmentFrame &mount, float attack_phase,
-                        bool keep_left_hand);
+                             const HorseDimensions &dims);
+  void apply_sword_strike(const MountedAttachmentFrame &mount,
+                          float attack_phase, bool keep_left_hand);
   void apply_spear_thrust(const MountedAttachmentFrame &mount,
-                        float attack_phase);
+                          float attack_phase);
   void apply_spear_guard(const MountedAttachmentFrame &mount, SpearGrip grip);
   void apply_bow_draw(const MountedAttachmentFrame &mount, float draw_phase);
   void apply_saddle_clearance(const MountedAttachmentFrame &mount,
-                            const HorseDimensions &dims, float forward_bias,
-                            float up_bias);
+                              const HorseDimensions &dims, float forward_bias,
+                              float up_bias);
   void stabilizeUpperBody(const MountedAttachmentFrame &mount,
                           const HorseDimensions &dims);
-  void apply_torso_sculpt(const MountedAttachmentFrame &mount, float compression,
-                        float twist, float shoulderDip);
+  void apply_torso_sculpt(const MountedAttachmentFrame &mount,
+                          float compression, float twist, float shoulderDip);
   void update_head_hierarchy(const MountedAttachmentFrame &mount,
-                           float extra_forward_tilt, float extra_side_tilt,
-                           std::string_view debug_label = "head_sync");
+                             float extra_forward_tilt, float extra_side_tilt,
+                             std::string_view debug_label = "head_sync");
   void holdReinsImpl(const MountedAttachmentFrame &mount, float left_slack,
                      float right_slack, float left_tension, float right_tension,
                      bool apply_left, bool apply_right);
 
   void apply_fixed_head_frame(const MountedAttachmentFrame &mount,
-                           std::string_view debug_label);
+                              std::string_view debug_label);
 };
 
 } // namespace Render::GL

render/humanoid/pose_controller.cpp

@@ -82,8 +82,8 @@ void HumanoidPoseController::placeHandAt(bool is_left,
   float const outward_sign = 1.0F;
 
   get_elbow(is_left) =
-      solve_elbow_ik(is_left, shoulder, target_position, outward_dir, along_frac,
-                   lateral_offset, y_bias, outward_sign);
+      solve_elbow_ik(is_left, shoulder, target_position, outward_dir,
+                     along_frac, lateral_offset, y_bias, outward_sign);
 }
 
 auto HumanoidPoseController::solve_elbow_ik(
@@ -91,8 +91,8 @@ auto HumanoidPoseController::solve_elbow_ik(
     const QVector3D &outward_dir, float along_frac, float lateral_offset,
     float y_bias, float outward_sign) const -> QVector3D {
 
-  return elbow_bend_torso(shoulder, hand, outward_dir, along_frac, lateral_offset,
-                        y_bias, outward_sign);
+  return elbow_bend_torso(shoulder, hand, outward_dir, along_frac,
+                          lateral_offset, y_bias, outward_sign);
 }
 
 auto HumanoidPoseController::solve_knee_ik(

render/humanoid/pose_controller.h

@@ -30,12 +30,12 @@ public:
   void look_at(const QVector3D &target);
 
   auto solve_elbow_ik(bool is_left, const QVector3D &shoulder,
-                    const QVector3D &hand, const QVector3D &outward_dir,
-                    float along_frac, float lateral_offset, float y_bias,
-                    float outward_sign) const -> QVector3D;
+                      const QVector3D &hand, const QVector3D &outward_dir,
+                      float along_frac, float lateral_offset, float y_bias,
+                      float outward_sign) const -> QVector3D;
 
   auto solve_knee_ik(bool is_left, const QVector3D &hip, const QVector3D &foot,
-                   float height_scale) const -> QVector3D;
+                     float height_scale) const -> QVector3D;
 
   auto get_shoulder_y(bool is_left) const -> float;
   auto get_pelvis_y() const -> float;

render/humanoid/rig.cpp

@@ -392,10 +392,10 @@ void HumanoidRendererBase::compute_locomotion_pose(
   QVector3D const outward_l = -right_axis;
   QVector3D const outward_r = right_axis;
 
-  pose.elbow_l = elbow_bend_torso(pose.shoulder_l, pose.hand_l, outward_l, 0.45F,
-                                0.15F, -0.08F, +1.0F);
-  pose.elbow_r = elbow_bend_torso(pose.shoulder_r, pose.hand_r, outward_r, 0.48F,
-                                0.12F, 0.02F, +1.0F);
+  pose.elbow_l = elbow_bend_torso(pose.shoulder_l, pose.hand_l, outward_l,
+                                  0.45F, 0.15F, -0.08F, +1.0F);
+  pose.elbow_r = elbow_bend_torso(pose.shoulder_r, pose.hand_r, outward_r,
+                                  0.48F, 0.12F, 0.02F, +1.0F);
 }
 
 void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
@@ -516,7 +516,7 @@ void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
   QVector3D const chin_pos = pose.head_pos - head_up * head_r;
   out.mesh(get_unit_cylinder(),
            cylinder_between(ctx.model, pose.neck_base, chin_pos,
-                           HP::NECK_RADIUS * width_scale),
+                            HP::NECK_RADIUS * width_scale),
            v.palette.skin * 0.9F, nullptr, 1.0F);
 
   QMatrix4x4 head_rot;
@@ -792,8 +792,8 @@ void HumanoidRendererBase::draw_common_body(const DrawContext &ctx,
 
     foot_mat = foot_mat * scale_mat * shear_mat;
 
-    out.mesh(get_unit_capsule(), foot_mat, v.palette.leatherDark * 0.92F, nullptr,
-             1.0F);
+    out.mesh(get_unit_capsule(), foot_mat, v.palette.leatherDark * 0.92F,
+             nullptr, 1.0F);
   };
 
   draw_foot(pose.foot_l, true);
@@ -969,8 +969,8 @@ void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
 
         QVector3D const mid = root + (tip - root) * 0.40F;
         out.mesh(get_unit_cylinder(),
-                 cylinder_between(ctx.model, root, mid, base_radius), root_color,
-                 nullptr, 1.0F);
+                 cylinder_between(ctx.model, root, mid, base_radius),
+                 root_color, nullptr, 1.0F);
 
         out.mesh(get_unit_cone(), cone_from_to(ctx.model, mid, tip, mid_radius),
                  tip_color, nullptr, 1.0F);
@@ -1034,8 +1034,9 @@ void HumanoidRendererBase::draw_facial_hair(const DrawContext &ctx,
             saturate(hair_root * (color_jitter * 0.95F));
         QVector3D const tip_color = saturate(hair_tip * (color_jitter * 1.02F));
 
-        out.mesh(get_unit_sphere(), sphere_at(ctx.model, root, base_radius * 0.7F),
-                 root_color, nullptr, 1.0F);
+        out.mesh(get_unit_sphere(),
+                 sphere_at(ctx.model, root, base_radius * 0.7F), root_color,
+                 nullptr, 1.0F);
 
         QVector3D const mid = root + (tip - root) * 0.5F;
         out.mesh(get_unit_cylinder(),
@@ -1167,24 +1168,24 @@ void HumanoidRendererBase::draw_simplified_body(const DrawContext &ctx,
 
   out.mesh(get_unit_cylinder(),
            cylinder_between(ctx.model, pose.shoulder_l, pose.hand_l,
-                           (upper_arm_r + fore_arm_r) * 0.5F),
+                            (upper_arm_r + fore_arm_r) * 0.5F),
            v.palette.cloth, nullptr, 1.0F);
   out.mesh(get_unit_cylinder(),
            cylinder_between(ctx.model, pose.shoulder_r, pose.hand_r,
-                           (upper_arm_r + fore_arm_r) * 0.5F),
+                            (upper_arm_r + fore_arm_r) * 0.5F),
            v.palette.cloth, nullptr, 1.0F);
 
   QVector3D const hip_l = pose.pelvis_pos + QVector3D(-0.10F, -0.02F, 0.0F);
   QVector3D const hip_r = pose.pelvis_pos + QVector3D(0.10F, -0.02F, 0.0F);
 
-  out.mesh(
-      get_unit_cylinder(),
-      cylinder_between(ctx.model, hip_l, pose.foot_l, (thigh_r + shin_r) * 0.5F),
-      v.palette.cloth * 0.92F, nullptr, 1.0F);
-  out.mesh(
-      get_unit_cylinder(),
-      cylinder_between(ctx.model, hip_r, pose.foot_r, (thigh_r + shin_r) * 0.5F),
-      v.palette.cloth * 0.92F, nullptr, 1.0F);
+  out.mesh(get_unit_cylinder(),
+           cylinder_between(ctx.model, hip_l, pose.foot_l,
+                            (thigh_r + shin_r) * 0.5F),
+           v.palette.cloth * 0.92F, nullptr, 1.0F);
+  out.mesh(get_unit_cylinder(),
+           cylinder_between(ctx.model, hip_r, pose.foot_r,
+                            (thigh_r + shin_r) * 0.5F),
+           v.palette.cloth * 0.92F, nullptr, 1.0F);
 }
 
 void HumanoidRendererBase::draw_minimal_body(const DrawContext &ctx,
@@ -1198,8 +1199,9 @@ void HumanoidRendererBase::draw_minimal_body(const DrawContext &ctx,
 
   float const body_radius = HP::TORSO_TOP_R * get_torso_scale();
 
-  out.mesh(get_unit_capsule(), capsule_between(ctx.model, top, bot, body_radius),
-           v.palette.cloth, nullptr, 1.0F);
+  out.mesh(get_unit_capsule(),
+           capsule_between(ctx.model, top, bot, body_radius), v.palette.cloth,
+           nullptr, 1.0F);
 }
 
 void HumanoidRendererBase::render(const DrawContext &ctx,
@@ -1631,7 +1633,8 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
           if (auto *renderer = dynamic_cast<Renderer *>(&out)) {
             Shader *previous_shader = renderer->get_current_shader();
             renderer->set_current_shader(shadowShader);
-            shadowShader->set_uniform(QStringLiteral("u_lightDir"), dir_for_use);
+            shadowShader->set_uniform(QStringLiteral("u_lightDir"),
+                                      dir_for_use);
 
             out.mesh(quadMesh, shadowModel, QVector3D(0.0F, 0.0F, 0.0F),
                      nullptr, k_shadow_base_alpha, 0);

render/palette.cpp

@@ -9,7 +9,7 @@ namespace Render::GL {
 using Render::Geom::clampVec01;
 
 auto make_humanoid_palette(const QVector3D &team_tint,
-                         uint32_t seed) -> HumanoidPalette {
+                           uint32_t seed) -> HumanoidPalette {
   HumanoidPalette p;
 
   float const variation = (hash_01(seed) - 0.5F) * 0.08F;

render/palette.h

@@ -15,6 +15,6 @@ struct HumanoidPalette {
 };
 
 auto make_humanoid_palette(const QVector3D &team_tint,
-                         uint32_t seed) -> HumanoidPalette;
+                           uint32_t seed) -> HumanoidPalette;
 
 } // namespace Render::GL

render/scene_renderer.cpp

@@ -72,7 +72,8 @@ void Renderer::begin_frame() {
   m_active_queue->clear();
 
   if (m_camera != nullptr) {
-    m_view_proj = m_camera->get_projection_matrix() * m_camera->get_view_matrix();
+    m_view_proj =
+        m_camera->get_projection_matrix() * m_camera->get_view_matrix();
   }
 
   if (m_backend) {
@@ -110,7 +111,7 @@ void Renderer::set_viewport(int width, int height) {
   if ((m_camera != nullptr) && height > 0) {
     float const aspect = float(width) / float(height);
     m_camera->set_perspective(m_camera->get_fov(), aspect, m_camera->get_near(),
-                             m_camera->get_far());
+                              m_camera->get_far());
   }
 }
 void Renderer::mesh(Mesh *mesh, const QMatrix4x4 &model, const QVector3D &color,

tests/render/pose_controller_compatibility_test.cpp

@@ -49,7 +49,8 @@ protected:
 };
 
 TEST_F(PoseControllerCompatibilityTest, ElbowIKMatchesLegacyFunction) {
-  // Test that controller's solveElbowIK produces same result as elbow_bend_torso
+  // Test that controller's solveElbowIK produces same result as
+  // elbow_bend_torso
 
   QVector3D const shoulder(0.21F, 1.45F, 0.0F);
   QVector3D const hand(0.35F, 1.15F, 0.75F);
@@ -62,13 +63,13 @@ TEST_F(PoseControllerCompatibilityTest, ElbowIKMatchesLegacyFunction) {
   // Legacy approach
   QVector3D const legacy_elbow =
       elbow_bend_torso(shoulder, hand, outward_dir, along_frac, lateral_offset,
-                     y_bias, outward_sign);
+                       y_bias, outward_sign);
 
   // New controller approach
   HumanoidPoseController controller(pose, anim_ctx);
   QVector3D const controller_elbow =
       controller.solve_elbow_ik(false, shoulder, hand, outward_dir, along_frac,
-                              lateral_offset, y_bias, outward_sign);
+                                lateral_offset, y_bias, outward_sign);
 
   // Should be identical
   EXPECT_TRUE(approxEqual(legacy_elbow, controller_elbow, 0.001F))
@@ -93,7 +94,7 @@ TEST_F(PoseControllerCompatibilityTest, PlaceHandAtUsesCorrectElbowIK) {
   right_axis.normalize();
   QVector3D const outward_r = right_axis;
   legacy_pose.elbow_r = elbow_bend_torso(legacy_pose.shoulder_r, target_hand,
-                                       outward_r, 0.48F, 0.12F, 0.02F, 1.0F);
+                                         outward_r, 0.48F, 0.12F, 0.02F, 1.0F);
 
   // New controller approach
   HumanoidPoseController controller(pose, anim_ctx);

tests/render/pose_controller_test.cpp

@@ -194,7 +194,8 @@ TEST_F(HumanoidPoseControllerTest, SolveKneeIKReturnsValidPosition) {
   QVector3D const foot(0.10F, 0.0F, 0.05F);
   float const height_scale = 1.0F;
 
-  QVector3D const knee = controller.solve_knee_ik(false, hip, foot, height_scale);
+  QVector3D const knee =
+      controller.solve_knee_ik(false, hip, foot, height_scale);
 
   // Knee should be between hip and foot (in Y)
   EXPECT_LT(knee.y(), hip.y());
@@ -212,7 +213,8 @@ TEST_F(HumanoidPoseControllerTest, SolveKneeIKPreventsGroundPenetration) {
   QVector3D const foot(0.50F, 0.0F, 0.50F); // Far foot
   float const height_scale = 1.0F;
 
-  QVector3D const knee = controller.solve_knee_ik(true, hip, foot, height_scale);
+  QVector3D const knee =
+      controller.solve_knee_ik(true, hip, foot, height_scale);
 
   // Knee should be at or above the floor threshold
   float const min_knee_y =