Standard-of-Iron/tests/render/helmet_renderers_test.cpp

#include "render/equipment/equipment_registry.h"
#include "render/equipment/helmets/headwrap.h"
#include "render/equipment/helmets/montefortino_helmet.h"
#include "render/humanoid/rig.h"
#include "render/palette.h"
#include <gtest/gtest.h>
#include <memory>

using namespace Render::GL;

namespace {

// Mock submitter for testing
class MockSubmitter : public ISubmitter {
public:
  void mesh(Mesh * /*mesh*/, const QMatrix4x4 & /*transform*/,
            const QVector3D & /*color*/, Texture * /*texture*/,
            float /*alpha*/) override {
    mesh_count++;
  }

  void cylinder(const QVector3D & /*start*/, const QVector3D & /*end*/,
                float /*radius*/, const QVector3D & /*color*/,
                float /*alpha*/) override {
    cylinder_count++;
  }

  void selectionRing(const QMatrix4x4 & /*model*/, float /*alphaInner*/,
                     float /*alphaOuter*/,
                     const QVector3D & /*color*/) override {
    // Not used in helmet rendering
  }

  void grid(const QMatrix4x4 & /*model*/, const QVector3D & /*color*/,
            float /*cellSize*/, float /*thickness*/,
            float /*extent*/) override {
    // Not used in helmet rendering
  }

  void selectionSmoke(const QMatrix4x4 & /*model*/, const QVector3D & /*color*/,
                      float /*baseAlpha*/) override {
    // Not used in helmet rendering
  }

  int mesh_count = 0;
  int cylinder_count = 0;
};

// Helper to create a basic DrawContext
DrawContext createTestContext() {
  DrawContext ctx;
  ctx.model.setToIdentity();
  ctx.backend = nullptr;
  ctx.entity = nullptr;
  return ctx;
}

// Helper to create basic body frames
BodyFrames createTestFrames() {
  BodyFrames frames;
  frames.head.origin = QVector3D(0.0F, 1.7F, 0.0F);
  frames.head.right = QVector3D(1.0F, 0.0F, 0.0F);
  frames.head.up = QVector3D(0.0F, 1.0F, 0.0F);
  frames.head.forward = QVector3D(0.0F, 0.0F, 1.0F);
  frames.head.radius = 0.12F;
  return frames;
}

// Helper to create basic palette
HumanoidPalette createTestPalette() {
  HumanoidPalette palette;
  palette.skin = QVector3D(0.8F, 0.6F, 0.5F);
  palette.cloth = QVector3D(0.7F, 0.3F, 0.2F);
  palette.leather = QVector3D(0.4F, 0.3F, 0.2F);
  palette.leatherDark = QVector3D(0.3F, 0.2F, 0.1F);
  palette.metal = QVector3D(0.7F, 0.7F, 0.7F);
  palette.wood = QVector3D(0.5F, 0.3F, 0.2F);
  return palette;
}

} // namespace

class HelmetRenderersTest : public ::testing::Test {
protected:
  void SetUp() override {
    // Ensure built-in equipment is registered
    registerBuiltInEquipment();

    ctx = createTestContext();
    frames = createTestFrames();
    palette = createTestPalette();
    anim.inputs.time = 0.0F;
    anim.inputs.isMoving = false;
    anim.inputs.is_attacking = false;
    anim.inputs.isMelee = false;
  }

  DrawContext ctx;
  BodyFrames frames;
  HumanoidPalette palette;
  HumanoidAnimationContext anim;
  MockSubmitter submitter;
};

TEST_F(HelmetRenderersTest, MontefortinoHelmetRendersWithValidFrames) {
  MontefortinoHelmetRenderer helmet;

  helmet.render(ctx, frames, palette, anim, submitter);

  // Montefortino helmet should render multiple mesh components
  EXPECT_GT(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, MontefortinoHelmetHandlesZeroHeadRadius) {
  MontefortinoHelmetRenderer helmet;
  frames.head.radius = 0.0F;

  helmet.render(ctx, frames, palette, anim, submitter);

  // Should not render anything when head radius is zero
  EXPECT_EQ(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, HeadwrapRendersWithValidFrames) {
  HeadwrapRenderer headwrap;

  headwrap.render(ctx, frames, palette, anim, submitter);

  // Headwrap should render band, knot, and tail
  EXPECT_GT(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, HeadwrapHandlesZeroHeadRadius) {
  HeadwrapRenderer headwrap;
  frames.head.radius = 0.0F;

  headwrap.render(ctx, frames, palette, anim, submitter);

  // Should not render anything when head radius is zero
  EXPECT_EQ(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, HelmetsRegisteredInEquipmentRegistry) {
  auto &registry = EquipmentRegistry::instance();

  // Verify montefortino helmet is registered
  EXPECT_TRUE(registry.has(EquipmentCategory::Helmet, "montefortino"));
  auto montefortino = registry.get(EquipmentCategory::Helmet, "montefortino");
  ASSERT_NE(montefortino, nullptr);

  // Verify headwrap is registered
  EXPECT_TRUE(registry.has(EquipmentCategory::Helmet, "headwrap"));
  auto headwrap = registry.get(EquipmentCategory::Helmet, "headwrap");
  ASSERT_NE(headwrap, nullptr);
}

TEST_F(HelmetRenderersTest, MontefortinoHelmetFromRegistryRenders) {
  auto &registry = EquipmentRegistry::instance();
  auto helmet = registry.get(EquipmentCategory::Helmet, "montefortino");
  ASSERT_NE(helmet, nullptr);

  helmet->render(ctx, frames, palette, anim, submitter);

  EXPECT_GT(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, HeadwrapFromRegistryRenders) {
  auto &registry = EquipmentRegistry::instance();
  auto headwrap = registry.get(EquipmentCategory::Helmet, "headwrap");
  ASSERT_NE(headwrap, nullptr);

  headwrap->render(ctx, frames, palette, anim, submitter);

  EXPECT_GT(submitter.mesh_count, 0);
}

TEST_F(HelmetRenderersTest, HelmetsUseHeadFrameCoordinates) {
  // Test that helmets use head frame's coordinate system
  frames.head.origin = QVector3D(1.0F, 2.0F, 3.0F);
  frames.head.right = QVector3D(0.0F, 1.0F, 0.0F); // Rotated frame
  frames.head.up = QVector3D(-1.0F, 0.0F, 0.0F);
  frames.head.forward = QVector3D(0.0F, 0.0F, 1.0F);
  frames.head.radius = 0.12F;

  MontefortinoHelmetRenderer helmet;
  MockSubmitter submitter1;
  helmet.render(ctx, frames, palette, anim, submitter1);

  // Helmet should still render even with rotated frame
  EXPECT_GT(submitter1.mesh_count, 0);

  HeadwrapRenderer headwrap;
  MockSubmitter submitter2;
  headwrap.render(ctx, frames, palette, anim, submitter2);

  EXPECT_GT(submitter2.mesh_count, 0);
}