VectorFieldSystem.cpp

#include "VectorFieldSystem.h"
#include "VectorFieldRenderer.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "Resources/MaterialManager.h"
#include "Resources/ModelManager.h"
#include "Systems/ComponentSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Math/RayBoxIntersection.h"
 
#include "glm/glm.hpp"
 
using namespace Cogs::Geometry;
 
namespace Cogs::Core::VectorField
{
  void VectorFieldBounds::getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds)
  {
    getBounds(context, bounds, false);
  }
 
  bool VectorFieldBounds::getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const
  {
    auto entityComponent = entity->getComponent<VectorFieldComponent>();
    if (!entityComponent) return false;
 
    VectorFieldComponent* component = handle.resolveComponent<VectorFieldComponent>();
    if (component != entityComponent)
      return false;
 
    Cogs::Geometry::BoundingBox myBounds;
    if (getBounds(context, myBounds, ignoreVisibility)) {
      bounds = myBounds;
      return true;
    }
    else {
      return false;
    }
  }
 
 
  bool VectorFieldBounds::getBounds(Context *context, Cogs::Geometry::BoundingBox &bounds, bool ignoreVisibility) const
  {
    VectorFieldComponent *component = handle.resolveComponent<VectorFieldComponent>();
    VectorFieldData &data = system->getData(component);
 
    if (!ignoreVisibility) {
      SceneComponent* sceneComp = component->getComponent<SceneComponent>();
      if (sceneComp->visible == false) return false;
    }
 
    auto *transComp = component->getComponent<TransformComponent>();
    auto &worldMatrix = context->transformSystem->getLocalToWorld(transComp);
 
    bounds.min = glm::vec3(FLT_MAX);
    bounds.max = glm::vec3(FLT_MIN);
    size_t count = 0;
    if(component->positions)
      count = component->positions.size();
    for(size_t i=0; i<count; i++){
      glm::vec3 p = component->positions[i];
      glm::vec3 d = component->directions[i];
      glm::vec3 pos = p;
      if(component->animation){
        float ih = fmod(sin(i/(float)count)*43758.5453f, 1.0f);
        float t = fmod(data.time+ih, 1.0f);
        if(component->animation && component->animationUseSpeed)
          t = data.time_offset_speed.size() ? data.time_offset_speed[i] : 0.0f;
        float anim_scale = component->scale*component->length*component->animationScale;
        pos += d*anim_scale*(t-0.5f);
      }
      {
        glm::vec4 pos_w = worldMatrix*glm::vec4(pos, 1.0);
        pos = glm::vec3(pos_w);
        if(!std::isnan(pos.x)) bounds.min.x = std::min(bounds.min.x, pos.x);
        if(!std::isnan(pos.y)) bounds.min.y = std::min(bounds.min.y, pos.y);
        if(!std::isnan(pos.z)) bounds.min.z = std::min(bounds.min.z, pos.z);
        if(!std::isnan(pos.x)) bounds.max.x = std::max(bounds.max.x, pos.x);
        if(!std::isnan(pos.y)) bounds.max.y = std::max(bounds.max.y, pos.y);
        if(!std::isnan(pos.z)) bounds.max.z = std::max(bounds.max.z, pos.z);
      }
      {
        glm::vec4 pos_w = worldMatrix*glm::vec4(pos + d*component->scale, 1.0);
        pos = glm::vec3(pos_w);
        if(!std::isnan(pos.x)) bounds.min.x = std::min(bounds.min.x, pos.x);
        if(!std::isnan(pos.y)) bounds.min.y = std::min(bounds.min.y, pos.y);
        if(!std::isnan(pos.z)) bounds.min.z = std::min(bounds.min.z, pos.z);
        if(!std::isnan(pos.x)) bounds.max.x = std::max(bounds.max.x, pos.x);
        if(!std::isnan(pos.y)) bounds.max.y = std::max(bounds.max.y, pos.y);
        if(!std::isnan(pos.z)) bounds.max.z = std::max(bounds.max.z, pos.z);
      }
    }
    float r = 2.0f*component->scale;
    bounds.min -= glm::vec3(r);
    bounds.max += glm::vec3(r);
    return !isEmpty(bounds);
  }
 
  bool Cogs::Core::VectorField::VectorFieldPick::pickCamera(Context* context,
                                                            const CameraComponent& camera,
                                                            const glm::vec2& normPosition,
                                                            float /*rayLength*/,
                                                            float /*radius*/,
                                                            PickingFlags pickingFlags,
                                                            PicksReturned returnFlag,
                                                            const RayPicking::RayPickFilter& filter,
                                                            std::vector<RayPicking::RayPickHit>& hits)
  {
    VectorFieldComponent *component = handle.resolveComponent<VectorFieldComponent>();
    if (filter.isUnwantedType(*component)) {
      return false;
    }
 
    VectorFieldData &data = system->getData(component);
 
    SceneComponent *scene = component->getComponent<SceneComponent>();
    if(scene && !scene->pickable) {
      return false;
    }
 
    const RenderComponent* renderComp = component->getComponent<RenderComponent>();
    if (renderComp == nullptr || !renderComp->isVisibleInLayer(filter.layerMask)) {
      return false;
    }
 
    const RayPicking::Ordinal ordinal = filter.getOrdinal(*renderComp);
 
    auto *transComp = component->getComponent<TransformComponent>();
    auto &worldMatrix = context->transformSystem->getLocalToWorld(transComp);
 
    auto & cameraData = context->cameraSystem->getData(&camera);
    auto M = cameraData.inverseViewMatrix*glm::inverse(cameraData.rawProjectionMatrix);
 
    auto aH = M * glm::vec4(normPosition, 0.0f, 1.f);
    auto bH = M * glm::vec4(normPosition, 0.5f, 1.f);
    auto cam_pos = (1.f / aH.w)*glm::vec3(aH);
    auto forward_point = (1.f / bH.w)*glm::vec3(bH);
    auto cam_dir = forward_point - cam_pos;
 
    glm::vec3 cam_dir_n = glm::normalize(cam_dir);
 
    glm::vec3 intersection;
    if(!Geometry::intersect(data.bbox, cam_pos, cam_dir, intersection, true)) {
      return false;
    }
 
    size_t count = component->positions.size();
    for(size_t i=0; i<count; i++){
      glm::vec3 cp = component->positions[i];
      glm::vec3 cd = component->directions[i];
      glm::vec3 pos = cp;
      if(component->animation){
        float ih = fmod(sin(i/(float)count)*43758.5453f, 1.0f);
        float t = fmod(data.time+ih, 1.0f);
        if(component->animation && component->animationUseSpeed)
          t = data.time_offset_speed.size() ? data.time_offset_speed[i] : 0.0f;
        float anim_scale = component->scale*component->length*component->animationScale;
        pos += cd*anim_scale*(t-0.5f);
      }
      glm::vec4 pos_w_a = worldMatrix*glm::vec4(pos, 1.0);
      glm::vec3 dir = glm::mat3(worldMatrix)*(cd*component->scale*component->length);
      glm::vec3 pos_a = glm::vec3(pos_w_a)/pos_w_a.w;
      glm::vec3 dir_norm = glm::normalize(dir);
 
      float r = 0.05f*component->scale*component->tailScale;
 
      // Distance between lines
      float l = glm::length(cd)*component->scale*component->length;
      if(std::isnan(r) || std::isinf(r)) continue;
      if(std::isnan(l) || std::isinf(l)) continue;
      if(r < 0.01 || l < 0.01) continue;
 
      glm::vec3 p_norm = glm::cross(cam_dir_n, dir_norm);
      float pn = glm::length(p_norm);
      if(pn < 0.05f) continue;
      p_norm = p_norm/pn;
      float d1 = glm::dot(p_norm, pos_a);
      float d2 = glm::dot(p_norm, cam_pos);
      float dist = fabsf(d1-d2);
      if(dist > r) continue;
 
      // Off the end of cyliner
      glm::vec3 n_norm = glm::normalize(glm::cross(cam_dir_n, p_norm));
      glm::mat3 vs = glm::transpose(glm::mat3(cam_dir_n, p_norm, n_norm));
      glm::vec3 vs_pos = vs*(pos_a - cam_pos);
      glm::vec3 vs_dir = vs*dir;
 
      float t = -vs_pos.z/vs_dir.z;
      if(t > 1.0 || t < 0.0) continue;
      intersection = pos_a+t*dir;
 
      glm::vec4 clipPos = cameraData.rawViewProjection * glm::vec4(intersection, 1.f);
      if ((-clipPos.w > clipPos.z) && (clipPos.z > clipPos.w)) {
        return false;
      }
 
      glm::vec4 viewPos = cameraData.viewMatrix * glm::vec4(glm::vec3(intersection), 1.f);
      float viewDist = -viewPos.z;
 
      if (returnFlag == PicksReturned::Closest && !hits.empty()) {
        if (hits[0].isBehind(ordinal, viewDist)) {
          hits[0] = {*renderComp, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, intersection, ordinal, viewDist};
          return true;
        }
        // Else the intersection we found is further, so continue searching
        continue;
      }
 
      // Returning just the first intersected object should be enough for vector fields.
      hits.emplace_back(*renderComp, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, intersection, ordinal, viewDist);
      return true;
    }
 
    return false;
  }
  void VectorFieldSystem::initialize(Context *context)
  {
    ComponentSystemWithDataPool::initialize(context);
    vector_field_renderer = new VectorFieldRenderer; // TODO fix mem-leak?
    context->renderer->registerExtension(vector_field_renderer);
 
  }
  void VectorFieldSystem::update(Context *context)
  {
    for(VectorFieldComponent &component : pool){
      VectorFieldData &data = getData(&component);
      data.getBounds->getBounds(context, data.bbox);
    }
  }
  ComponentModel::ComponentHandle VectorFieldSystem::createComponent()
  {
    auto material = context->materialManager->loadMaterial("Materials/VectorMaterial.material");
    context->materialManager->processLoading();
    material_instance_cap = context->materialInstanceManager->createMaterialInstance(material);
    material_instance_cap->setPermutation("Cap");
    material_instance_base = context->materialInstanceManager->createMaterialInstance(material);
    material_instance_base->setPermutation("Base");
    model_cap = context->modelManager->loadModel("Models/Cap.cogsbin", NoResourceId, ModelLoadFlags::None);
    model_base = context->modelManager->loadModel("Models/Base.cogsbin", NoResourceId, ModelLoadFlags::None);
 
    auto comp = ComponentSystemWithDataPool::createComponent();
    VectorFieldComponent *component = comp.resolveComponent<VectorFieldComponent>();
    VectorFieldData &data = getData(component);
    data.system = this;
    data.handle = comp;
 
    data.pos_element = Cogs::VertexElement{ 0, Cogs::Format::R32G32B32_FLOAT, Cogs::ElementSemantic::InstanceVector, 0, Cogs::InputType::InstanceData, 1 };
    data.color_element = Cogs::VertexElement{ offsetof(InstanceData, color), Cogs::Format::R8G8B8A8_UNORM, Cogs::ElementSemantic::InstanceVector, 1, Cogs::InputType::InstanceData, 1 };
    data.rot_element = Cogs::VertexElement{ offsetof(InstanceData, rot), Cogs::Format::R32G32B32A32_FLOAT, Cogs::ElementSemantic::InstanceVector, 2, Cogs::InputType::InstanceData, 1 };
    data.scale_element = Cogs::VertexElement{ offsetof(InstanceData, scale), Cogs::Format::R32G32B32A32_FLOAT, Cogs::ElementSemantic::InstanceVector, 3, Cogs::InputType::InstanceData, 1 };
 
    std::vector<VertexElement> format{
      data.pos_element,
      data.color_element,
      data.rot_element,
      data.scale_element
    };
    data.pos_format = Cogs::VertexFormats::createVertexFormat(format.data(), format.size());
 
    data.buffer_count = 0;
    data.getBounds = std::make_unique<VectorFieldBounds>(this, comp);
    data.rayPick = std::make_unique<VectorFieldPick>(this, comp);
    data.time = 0.0f;
    context->bounds->addBoundsExtension(data.getBounds.get());
    context->rayPicking->addPickable(data.rayPick.get());
    return comp;
  }
  void VectorFieldSystem::destroyComponent(ComponentHandle component)
  {
    VectorFieldData &data = getData(component.resolveComponent<VectorFieldComponent>());
    if(data.getBounds) context->bounds->removeBoundsExtension(data.getBounds.get());
    if(data.rayPick) context->rayPicking->removePickable(data.rayPick.get());
    ComponentSystemWithDataPool::destroyComponent(component);
  }
}// namespace ...