PickingBeamComponent.cpp

#include "PickingBeamComponent.h"
 
#include "Types.h"
#include "Input/InputManager.h"
#include "Resources/MaterialManager.h"
 
#include "Components/Geometry/MeshGeneratorComponent.h"
#include "Components/Core/MeshRenderComponent.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/matrix_decompose.hpp>
 
#include <algorithm>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("PickingBeamComponent");
}
 
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
 
//static
void Cogs::Core::PickingBeamComponent::registerType()
{
  Field fields[] = {
    Field(Name("beamOffset"), &PickingBeamComponent::beamOffset),
    Field(Name("beamRotation"), &PickingBeamComponent::beamRotation),
    Field(Name("diffuseColor"), &PickingBeamComponent::diffuseColor),
    Field(Name("emissiveColor"), &PickingBeamComponent::emissiveColor),
    Field(Name("active"), &PickingBeamComponent::active),
    Field(Name("lastPickedEntity"), &PickingBeamComponent::lastPickedEntity),
    Field(Name("lastPickedPos"), &PickingBeamComponent::lastPickedPos),
  };
  Method methods[] = {
    Method(Name("initialize"), &PickingBeamComponent::initialize),
    Method(Name("update"), &PickingBeamComponent::update),
  };
 
  DynamicComponent::registerDerivedType<PickingBeamComponent>().setMethods(methods).setFields(fields);
}
 
void Cogs::Core::PickingBeamComponent::initialize(Cogs::Core::Context * context)
{
  this->context = context;
  beam = context->store->findEntity("aimBeam", getContainer());
  if (!beam) {
    beam = context->store->createChildEntity("Group", getContainer(), "aimBeam");
  }
  aimTransform = getComponentHandle<TransformComponent>();
  EntityPtr beamGeometry = context->store->findEntity("aimCylinder", this->beam.get());
  if (!beamGeometry) {
    beamGeometry = context->store->createChildEntity("Cylinder", this->beam.get(), "aimCylinder");
  }
  beamGeometry->getComponent<MeshGeneratorComponent>()->shape = Cogs::Core::ShapeType::Cylinder;
 
  MaterialHandle defaultMat = context->materialManager->getDefaultMaterial();
  MaterialInstanceHandle materialInstance = context->materialInstanceManager->createMaterialInstance(defaultMat);
  materialInstance->setOption("CullMode", "None");
  materialInstance->setOption("Transparency", "On");
  materialInstance->setOption("DepthTestEnabled", enableDepthTest ? "On" : "Off");
 
  MeshRenderComponent *beamMeshRender = beamGeometry->getComponent<MeshRenderComponent>();
  beamMeshRender->material = materialInstance;
  beamMeshRender->unsetRenderFlag(Cogs::Core::RenderFlags::CastShadows);
  beamMeshRender->setChanged();
 
  RenderComponent *beamRender = beamGeometry->getComponent<RenderComponent>();
  beamRender->drawOrder = transparencyLayer;
  beamRender->setChanged();
 
  this->beamGeometryTransform = beamGeometry->getComponentHandle<TransformComponent>();
  TransformComponent *beamGeometryTrans = beamGeometryTransform.resolveComponent<TransformComponent>();
  beamGeometryTrans->position = glm::vec3(0, 0, -2500);
  beamGeometryTrans->scale = glm::vec3(0.002f, 0.002f, 2500);
  beamGeometryTrans->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();
 
  CameraComponent* beamCam = beam.get()->getComponent<CameraComponent>();
  if (!beamCam) {
    beamCam = context->store->addComponent<CameraComponent>(beam.get());
  }
  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->setChanged();
 
  beamCamera = beamCam->getComponentHandle<CameraComponent>();
 
  beamScene = beamGeometry->getComponentHandle<SceneComponent>();
 
  destinationMarker = context->store->findEntity("destinationMarker", getContainer());
  if (!destinationMarker) {
    destinationMarker = context->store->createChildEntity("Group", getContainer(), "destinationMarker");
  }
  EntityPtr destGeometry = context->store->findEntity("BasicMeshGeneratorEntity", destinationMarker.get());
  if (!destGeometry) {
    destGeometry = context->store->createChildEntity("BasicMeshGeneratorEntity", destinationMarker.get(), "destinationSphere");
  }
  destGeometry->getComponent<MeshGeneratorComponent>()->shape = Cogs::Core::ShapeType::Sphere;
  destGeometry->getComponent<MeshGeneratorComponent>()->setChanged();
 
  MeshRenderComponent *destMeshRender = destGeometry->getComponent<MeshRenderComponent>();
  destMeshRender->material = materialInstance;
  destMeshRender->unsetRenderFlag(Cogs::Core::RenderFlags::CastShadows);
  destMeshRender->setChanged();
 
  RenderComponent *destRender = destGeometry->getComponent<RenderComponent>();
  destRender->drawOrder = transparencyLayer;
  destRender->setChanged();
 
  TransformComponent *destTransform = destGeometry->getComponent<TransformComponent>();
  destTransform->scale = glm::vec3(0.25f);
  destTransform->setChanged();
 
  destinationScene = destinationMarker->getComponentHandle<SceneComponent>();
  destinationTransform = destinationMarker->getComponentHandle<TransformComponent>();
 
  SceneComponent *destVis = destinationScene.resolveComponent<SceneComponent>();
  destVis->pickable = false;
  destVis->visible = false;
  destVis->setChanged();
 
  mainCamera = context->cameraSystem->getMainCamera()->getComponentHandle<CameraComponent>();
}
 
void Cogs::Core::PickingBeamComponent::update()
{
  auto beamVis = beamScene.resolveComponent<SceneComponent>();
  auto destVis = destinationScene.resolveComponent<SceneComponent>();
 
  if (active)
  {
    //FIXME: Store this as member variable or similar:
    auto materialInstance = destinationMarker->getComponent<SceneComponent>()->children[0].get()->getComponent<MeshRenderComponent>()->material;
    materialInstance->setProperty("diffuseColor", &diffuseColor, sizeof(glm::vec4));
    materialInstance->setProperty("emissiveColor", &emissiveColor, sizeof(glm::vec3));
 
    //FIXME: Make sure the picking cam has had its transform and frustum updated before picking:
    context->transformSystem->update(context);
    context->cameraSystem->update(context);
 
    if (!wasActive)
    {
      beamVis->visible = true;
      beamVis->setChanged();
      context->sceneSystem->updateState(*beamVis);
    }
 
    auto destTrans = destinationTransform.resolveComponent<TransformComponent>();
 
    auto beamCam = beamCamera.resolveComponent<CameraComponent>();
    auto size = beamCam->viewportSize;
 
    auto beamTrans = beamGeometryTransform.resolveComponent<TransformComponent>();
    auto aimTrans = aimTransform.resolveComponent<TransformComponent>();
 
    const glm::vec2 windowPosition(size.x / 2, size.y / 2);
    std::vector<RayPicking::RayPickHit> hits;
    context->rayPicking->pickCamera(context, *beamCam, windowPosition, std::numeric_limits<float>::max(), defaultPickingRadius, PickingFlags::None, PicksReturned::Closest, {}, hits);
 
    float dist = 5000;
    if (!hits.empty()) {
      lastPickedEntity = hits.front().entity;
      lastPickedPos = context->transformSystem->getOrigin() + glm::dvec3(hits.front().position);
      //move the picked point into the aim entity (avatar) frame:
      glm::vec3 scale, trans, skew;
      glm::quat orient;
      glm::vec4 persp;
      glm::decompose(context->transformSystem->getLocalToWorld(aimTrans), scale, orient, trans, skew, persp);
 
      dist = glm::distance(hits.front().position, trans);
      dist /= scale.x;
 
      destTrans->coordinates = lastPickedPos;
      destTrans->setChanged();
      context->transformSystem->updateTransformData(*destTrans);
 
      if (!destVis->visible) {
        destVis->visible = true;
        destVis->setChanged();
        context->sceneSystem->updateState(*destVis);
      }
    }
    else {
      lastPickedEntity = NoEntity;
      lastPickedPos = glm::dvec3(0);
      if (destVis->visible) {
        destVis->visible = false;
        destVis->setChanged();
        context->sceneSystem->updateState(*destVis);
      }
    }
 
    //adjust length of picking beam:
    beamTrans->scale = glm::vec3(0.002f, 0.002f, dist / 2);
    beamTrans->position = glm::vec3(0, 0, -dist / 2);
    beamTrans->setChanged();
    context->transformSystem->updateTransformData(*beamTrans);
  }
  else
  {
    //not active
    if (wasActive) {
      beamVis->visible = false;
      beamVis->setChanged();
      destVis->visible = false;
      destVis->setChanged();
      context->sceneSystem->updateState(*beamVis);
      context->sceneSystem->updateState(*destVis);
    }
  }
  wasActive = active;
}