FPSNavigationComponent.cpp

#include "FPSNavigationComponent.h"
 
#include "ViewContext.h"
#include "Input/InputManager.h"
#include "Services/Time.h"
#include "Components/Core/TransformComponent.h"
 
#include "Foundation/Reflection/Method.h"
 
#include <glm/gtx/quaternion.hpp>
 
#include <algorithm>
#include <numbers>
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
 
void Cogs::Core::FPSNavigationComponent::registerType()
{
  Field fields[] = {
    Field(Name("enable"), &FPSNavigationComponent::enable),
    Field(Name("enablePitch"), &FPSNavigationComponent::enablePitch),
    Field(Name("maxLinearSpeed"), &FPSNavigationComponent::maxLinearSpeed),
    Field(Name("maxAngularSpeed"), &FPSNavigationComponent::maxAngularSpeed),
    Field(Name("axisForward"), &FPSNavigationComponent::axisForward),
    Field(Name("axisRight"), &FPSNavigationComponent::axisRight),
    Field(Name("axisUp"), &FPSNavigationComponent::axisUp),
    Field(Name("axisDown"), &FPSNavigationComponent::axisDown),
    Field(Name("axisRotateUp"), &FPSNavigationComponent::axisRotateUp),
    Field(Name("axisRotateRight"), &FPSNavigationComponent::axisRotateRight),
    Field(Name("actionRun"), &FPSNavigationComponent::actionRun),
    Field(Name("actionEnableNavigation"), &FPSNavigationComponent::actionEnableNavigation),
    Field(Name("pitch"), &FPSNavigationComponent::pitch),
    Field(Name("yaw"), &FPSNavigationComponent::yaw),
  };
  Method methods[] = {
    Method(Name("initialize"), &FPSNavigationComponent::initialize),
    Method(Name("update"), &FPSNavigationComponent::update),
  };
 
  DynamicComponent::registerDerivedType<FPSNavigationComponent>().setMethods(methods).setFields(fields);
}
 
void Cogs::Core::FPSNavigationComponent::initialize(Cogs::Core::Context * context)
{
  this->context = context;
}
 
glm::vec3 Cogs::Core::FPSNavigationComponent::getOffset()
{
  auto & input = context->getDefaultView()->inputManager;
  auto speed = glm::vec3(
    input->getAxisValue(axisRight),
    input->getAxisValue(axisForward),
    input->getAxisValue(axisUp) - input->getAxisValue(axisDown)
  );
 
  speed *= maxLinearSpeed;
  if (input->getActionState(actionRun)) speed *= 3;
  return speed * (float)context->time->getAnimationTimeDelta();
}
 
glm::vec2 Cogs::Core::FPSNavigationComponent::getPitchYawOffset()
{
  auto & input = context->getDefaultView()->inputManager;
 
  glm::vec2 pitchYaw(input->getAxisValue(axisRotateUp), -input->getAxisValue(axisRotateRight));
 
  pitchYaw *= maxAngularSpeed * context->time->getAnimationTimeDelta();
 
  return pitchYaw;
}
 
void Cogs::Core::FPSNavigationComponent::update()
{
  if (!enable) return;
 
  auto & input = context->getDefaultView()->inputManager;
  auto posOffset = getOffset();
  auto rotOffset = getPitchYawOffset();
  if (actionEnableNavigation != "") {
    if (!input->getActionState(actionEnableNavigation)) return;
  }
 
 
  auto pitchOffset = rotOffset.x;
  auto yawOffset = rotOffset.y;
 
  pitch += pitchOffset;
  yaw += yawOffset;
 
  if (enablePitch) {
    constexpr float maxPitch = std::numbers::pi_v<float> / 2.0f;
    if (pitch < -maxPitch) pitch = -maxPitch;
    if (pitch > maxPitch) pitch = maxPitch;
  }
  else {
    pitch = 0;
  }
 
  auto yawRot = glm::quat(glm::vec3(0, 0, yaw));
  auto pitchRot = glm::quat(glm::vec3(pitch, 0, 0));
 
  // When pitch control is enabled, we add a 90 degree rotation to point the camera forward instead of down
  if (enablePitch) pitchRot *= glm::quat(glm::vec3(glm::half_pi<float>(), 0, 0));
 
  auto * navigationTransform = getComponent<TransformComponent>();
  navigationTransform->transform.trs.rotation = yawRot * pitchRot;
 
  //find move direction:
  posOffset = glm::rotate(yawRot, posOffset);
 
  //apply translation:
  navigationTransform->transform.trs.position += posOffset;
 
  navigationTransform->setChanged();
}