TeleportNavigationComponent.cpp

#include "TeleportNavigationComponent.h"
 
#include "Types.h"
#include "ViewContext.h"
#include "Input/InputManager.h"
 
#include "Components/Core/CameraComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Geometry/MeshGeneratorComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Scene/RayPick.h"
#include "EntityStore.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/SceneSystem.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Reflection/Method.h"
 
 
#include <glm/gtx/quaternion.hpp>
 
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TeleportNavigationComponent");
  glm::vec4 navEmissive(0.2f, 0.2f, 0.8f, 1);
  glm::vec4 navDiffuse(0, 0, 0, 0.7f);
}
 
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
 
//static
void Cogs::Core::TeleportNavigationComponent::registerType()
{
  Field fields[] = {
    Field(Name("actionTeleport"), &TeleportNavigationComponent::actionTeleport),
    Field(Name("aimEntity"), &TeleportNavigationComponent::aimEntity),
    Field(Name("beamOffset"), &TeleportNavigationComponent::beamOffset),
    Field(Name("beamRotation"), &TeleportNavigationComponent::beamRotation),
    Field(Name("useCoordinate"), &TeleportNavigationComponent::useCoordinate),
    Field(Name("teleportOffset"), &TeleportNavigationComponent::teleportOffset),
  };
  Method methods[] = {
    Method(Name("initialize"), &TeleportNavigationComponent::initialize),
    Method(Name("postUpdate"), &TeleportNavigationComponent::postUpdate),
    Method(Name("update"), &TeleportNavigationComponent::update),
  };
 
  DynamicComponent::registerDerivedType<TeleportNavigationComponent>().setMethods(methods).setFields(fields);
}
 
void Cogs::Core::TeleportNavigationComponent::initialize(Cogs::Core::Context * context)
{
  this->context = context;
  this->beam = context->store->findEntity("aimBeam", aimEntity.get());
  if (!this->beam) {
    this->beam = context->store->createChildEntity("Group", aimEntity.get(), "aimBeam");
  }
  EntityPtr beamGeometry = context->store->findEntity("aimCylinder", this->beam.get());
  if (!beamGeometry) {
    beamGeometry = context->store->createChildEntity("Cylinder", this->beam.get(), "aimCylinder");
  }
 
  MaterialComponent *beamMaterial = beamGeometry->getComponent<MaterialComponent>();
  beamMaterial->emissiveColor = navEmissive;
  beamMaterial->diffuseColor = navDiffuse;
  beamMaterial->setChanged();
 
  MeshGeneratorComponent *beamShape = beamGeometry->getComponent<MeshGeneratorComponent>();
  beamShape->size = glm::vec3(0.002f, 0, 2500); // radius, halfheight
  beamShape->setChanged();
 
  TransformComponent *beamGeometryTransform = beamGeometry->getComponent<TransformComponent>();
  beamGeometryTransform->position = glm::vec3(0, 0, -2500);
  beamGeometryTransform->setChanged();
 
  TransformComponent *beamTransform = this->beam->getComponent<TransformComponent>();
  beamTransform->position = beamOffset;
  beamTransform->rotation = beamRotation;
  beamTransform->setChanged();
 
  SceneComponent *beamVisibility = beamGeometry->getComponent<SceneComponent>();
  beamVisibility->visible = false;
  beamVisibility->pickable = false;
  beamVisibility->setChanged();
  this->beamVisibility = beamVisibility->getComponentHandle<SceneComponent>();
 
  CameraComponent *beamCam = beam.get()->getComponent<CameraComponent>();
  if (!beamCam) {
    beamCam = context->store->addComponent<CameraComponent>(beam.get());
  }
  //beamCam->projectionMode = CameraComponent::Orthographic;
  //beamCam->orthoHeight = 0.1f;
 
  beamCam->projectionMode = ProjectionMode::Perspective;
  beamCam->fieldOfView = 0.01f;
 
  beamCam->flags = CameraFlags::EnablePicking;
  beamCam->viewportSize = glm::vec2(3, 3);
  beamCam->nearPlaneLimit = 0.1f;
  beamCam->enableClippingPlaneAdjustment = true;
  //beamCam->nearDistance = 0.1f;
  //beamCam->farDistance = 5000;
 
  beamCam->setChanged();
 
  destinationMarker = context->store->findEntity("destinationMarker", aimEntity.get());
  if (!destinationMarker) {
    destinationMarker = context->store->createChildEntity("Group", aimEntity.get(), "destinationMarker");
  }
  EntityPtr destGeometry = context->store->findEntity("destinationSphere", destinationMarker.get());
  if (!destGeometry) {
    destGeometry = context->store->createChildEntity("Sphere", destinationMarker.get(), "destinationSphere");
  }
 
  MaterialComponent *destMaterial = destGeometry->getComponent<MaterialComponent>();
  destMaterial->emissiveColor = navEmissive;
  destMaterial->diffuseColor = navDiffuse;
  destMaterial->setChanged();
 
  TransformComponent *destTransform = destGeometry->getComponent<TransformComponent>();
  destTransform->scale = glm::vec3(0.25f);
  destTransform->setChanged();
 
  destinationVisibility = destinationMarker->getComponentHandle<SceneComponent>();
  SceneComponent *destVis = destinationVisibility.resolveComponent<SceneComponent>();
  destVis->pickable = false;
  destVis->visible = false;
  destVis->setChanged();
}
 
void logVector(const Cogs::Logging::Log& logger_, const char * name, glm::dvec3 vector)
{
  LOG_DEBUG(logger_, "%s: (%f,%f,%f)", name, vector.x, vector.y, vector.z);
}
 
void Cogs::Core::TeleportNavigationComponent::postUpdate()
{
}
 
void Cogs::Core::TeleportNavigationComponent::update()
{
  ViewContext* view = context->getDefaultView();
  auto& input = view->inputManager;
 
  if (!navigationTransform) {
    navigationTransform = getComponent<TransformComponent>()->getComponentHandle<TransformComponent>();
  }
 
  auto destVis = destinationVisibility.resolveComponent<SceneComponent>();
  auto destinationTransform = destinationMarker->getComponent<TransformComponent>();
 
  bool pressed = input->getActionState(actionTeleport);
 
  if (pressed)
  {
    //FIXME: Force camera system to update:
    context->transformSystem->update(context);
    context->cameraSystem->update(context);
 
    //Keep raypicking while button down:
    std::vector<RayPicking::RayPickHit> hits;
    //We use a dummy camera to do the ray pick
    auto beamCam = beam->getComponent<CameraComponent>();
    auto size = beamCam->viewportSize;
    context->rayPicking->pickCamera(context, *beamCam, 0.5f*size, std::numeric_limits<float>::max(), defaultPickingRadius, PickingFlags::None, PicksReturned::Closest, {}, hits);
    if (!hits.empty()) {
      destinationTransform->position = hits.front().position;
      destinationTransform->coordinates = context->transformSystem->getOrigin();
      destinationTransform->setChanged();
      context->transformSystem->updateTransformData(*destinationTransform);
 
      if (!destVis->visible) {
        destVis->visible = true;
        destVis->setChanged();
        context->sceneSystem->updateState(*destVis);
      }
    }
    else {
      //Nothing was hit:
      if (destVis->visible) {
        destVis->visible = false;
        destVis->setChanged();
        context->sceneSystem->updateState(*destVis);
      }
    }
 
  }
  if (pressed != wasPressed) {
    auto beamVis = beamVisibility.resolveComponent<SceneComponent>();
    beamVis->visible = pressed;
    beamVis->setChanged();
    if (!pressed) {
      //User released the teleport button, check if we should teleport:
      if (destVis->visible) {
        //we have a valid position:
        destVis->visible = false;
        destVis->setChanged();
 
        auto pickedCoord = destinationTransform->position;
 
        auto navTransform = navigationTransform.resolveComponent<TransformComponent>();
        if (!useCoordinate) {
          navTransform->position = pickedCoord;
        }
        else {
          auto origin = context->transformSystem->getOrigin();
          auto globalPickedPos = origin + glm::dvec3(pickedCoord);
 
          glm::dvec3 newOrigin(globalPickedPos.x, globalPickedPos.y, 0);
          glm::dvec3 newPosition = globalPickedPos - newOrigin;
 
          logVector(logger, "origin", origin);
          logVector(logger, "pickedCoord", pickedCoord);
          logVector(logger, "globalPickedPos", globalPickedPos);
          logVector(logger, "newOrigin", newOrigin);
          logVector(logger, "newPosition", newPosition);
 
          context->transformSystem->setOrigin(newOrigin);
          navTransform->coordinates = newOrigin;
          navTransform->position = glm::vec3(newPosition) + teleportOffset;
        }
        navTransform->setChanged();
        context->transformSystem->updateTransformData(*navTransform);
      }
    }
  }
  wasPressed = pressed;
}