SeaCurrentsSystem.cpp

#include "SeaCurrentsSystem.h"
 
#include "SeaCurrentsRenderer.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/InstancedMeshRenderComponent.h"
#include "Resources/MaterialManager.h"
#include "Resources/MeshManager.h"
#include "Resources/VertexFormats.h"
#include "Systems/Core/TransformSystem.h"
 
#include <stddef.h>
#include <iterator>
 
using namespace Cogs::Geometry;
 
namespace {
  constexpr uint32_t  cColours[] = {
    0xFFC2162E,
    0xFFA65011,
    0xFFC8981E,
    0xFF0F8027,
    0xFF00B774,
    0xFF00889C,
    0xFF0262EF,
    0xFF565CED,
    0xFF0303FF,
  };
}
 
void Cogs::Core::SeaCurrentsSystem::initialize(Context* context) {
  ComponentSystem::initialize(context);
 
  mRenderer = new SeaCurrentsRenderer();
  context->renderer->registerExtension(mRenderer);
 
  VertexElement elements[] = {
    { 0,                              Cogs::Format::R32G32B32A32_FLOAT, Cogs::ElementSemantic::InstanceVector, 0, Cogs::InputType::InstanceData, 1 },
    { offsetof(InstanceData, colour), Cogs::Format::R8G8B8A8_UNORM,     Cogs::ElementSemantic::InstanceVector, 1, Cogs::InputType::InstanceData, 1 }
  };
  mVertexFormatHandle = Cogs::VertexFormats::createVertexFormat(elements, std::size(elements));
 
 
  mArrowMesh = context->meshManager->create();
 
  std::vector<glm::vec3>  vertices = {
    {  0.0f,        0.5f,       0.0f },
    {  0.2f,        0.15f,      0.0f },
    {  0.1f,        0.15f,      0.0f },
 
    {  0.1f,        0.15f,      0.0f },
    { -0.1f,        0.15f,      0.0f },
    {  0.0f,        0.5f,       0.0f },
 
    { -0.1f,        0.15f,      0.0f },
    { -0.2f,        0.15f,      0.0f },
    {  0.0f,        0.5f,       0.0f },
 
    {  0.1f,        0.15f,      0.0f },
    {  0.0f,       -0.15f,      0.0f },
    { -0.1f,        0.15f,      0.0f },
 
    {  0.1f,        0.15f,      0.0f },
    {  0.05f,      -0.5f,       0.0f },
    {  0.0f,       -0.15f,      0.0f },
 
    {  0.0f,       -0.15f,      0.0f },
    {  0.05f,      -0.5f,       0.0f },
    { -0.05f,      -0.5f,       0.0f },
 
    { -0.1f,        0.15f,      0.0f },
    {  0.0f,       -0.15f,      0.0f },
    { -0.05f,      -0.5f,       0.0f },
  };
 
  Mesh* mesh = mArrowMesh.resolve();
 
  std::vector<glm::vec4> baricentricCoords = {
    // values to compute the rate of change in the Pixel Shader
    // values of 100 (arbitrary high number in a range[0-1]) forces the interpolation to never meet the criteria to color the edge
    { 1.0f,   100.0f,   0.0f,   1.0f },
    { 0.0f,   1.0f,   0.0f,   1.0f },
    { 0.0f,   100.0f,   1.0f,   1.0f },
 
    { 1.0f,   100.0f,   100.0f,   1.0f },
    { 100.0f,   1.0f,   100.0f,   1.0f },
    { 100.0f,   100.0f,   1.0f,   1.0f },
 
    { 1.0f,   100.0f,   0.0f,   1.0f },
    { 0.0f,   1.0f,   0.0f,   1.0f },
    { 0.0f,   100.0f,   1.0f,   1.0f },
 
    { 2.0f,   100.0f, 100.0f, 1.0f },
    { 100.0f, 10.0f,  100.0f, 1.0f },
    { 100.0f, 100.0f, 2.0f,   1.0f },
 
    { 1.0f,   100.0f,   0.0f,   1.0f },
    { 100.0f,   1.0f,   0.0f,   1.0f },
    { 100.0f,   100.0f,   1.0f,   1.0f },
 
    { 1.0f,   100.0f,   100.0f,   1.0f },
    { 0.0f,   1.0f,   100.0f,   1.0f },
    { 0.0f,   100.0f,   1.0f,   1.0f },
 
    { 1.0f,   0.0f,   100.0f,   1.0f },
    { 100.0f,   1.0f,   100.0f,   1.0f },
    { 100.0f,   0.0f,   1.0f,   1.0f },
  };
 
  mesh->setName("Sea Currents Arrow");
  mesh->setPositions(vertices);
  mesh->setColors(baricentricCoords);
  mesh->setBounds({ { -0.5f, -0.5f, -0.1f}, {0.5f, 0.5f, 0.1f} });
 
 
  // Set up mesh stream layout of mesh data combined with instance data.
  arrowInstancesStreamsLayout = mesh->getStreamsLayout();
  assert(arrowInstancesStreamsLayout.numStreams + 1 < MeshStreamsLayout::maxStreams);
  arrowInstancesStreamsLayout.vertexFormats[arrowInstancesStreamsLayout.numStreams++] = mVertexFormatHandle;
  arrowInstancesStreamsLayout.updateHash();
 
}
 
void Cogs::Core::SeaCurrentsSystem::update(Context* /*context*/) {
  for (SeaCurrentsComponent& seaCurrentsComp : pool) {
    SeaCurrentsData& data = getData(&seaCurrentsComp);
 
    if (seaCurrentsComp.positions.size() == 0) continue;
 
    constexpr float   cSpeedBandMax[] = { 0.5f, 1.0f, 2.0f, 3.0f, 5.0f, 7.0f, 10.0f, 13.0f, 99.0f };
    constexpr float   cSpeedBandMin[] = { 0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 5.0f, 7.0f, 10.0f, 13.0f };
    constexpr float   cSpeedBandWidth[] = { 0.5f, 0.5f, 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 86.0f };
    
    if (!seaCurrentsComp.isValid()) {
      continue;
    }
 
    if (!mMaterial->isActive()) {
      Cogs::Core::MaterialHandle  material = context->materialManager->loadMaterial("Materials/SeaCurrentsMaterial.material");
      context->materialManager->processLoading();
      mMaterial = context->materialInstanceManager->createMaterialInstance(material);
    }
 
    if (seaCurrentsComp.hasChanged()) {
 
      lowestSpeed = context->variables->get("seacurrents.lowestSpeed", 0.01f);
      highestSpeed = context->variables->get("seacurrents.highestSpeed", 13.0f);
      minScale = context->variables->get("seacurrents.minScale", 0.2f);
      maxScale = context->variables->get("seacurrents.maxScale", 1.0f);
      //non mutating data members
 
      glm::vec2 minPos(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
      glm::vec2 maxPos(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
 
      // compute bounds
      for (const glm::vec2& position : seaCurrentsComp.positions) {
        minPos = glm::min(minPos, position);
        maxPos = glm::max(maxPos, position);
      }
 
      data.mBounds = {{minPos, -0.01f}, {maxPos, 0.01f}};
      data.mSystem = this;
 
      size_t relevantDataPoints = seaCurrentsComp.positions.size();
 
      if (!seaCurrentsComp.ignorePriorities) {
        // Find the number of points with a priority higher than the priorityLevel.
        auto it = std::upper_bound(seaCurrentsComp.priorities.begin(), seaCurrentsComp.priorities.end(), seaCurrentsComp.priorityLevel);
        // Change the number of relevant data points to match the number of points with a priority < priorityLevel
        relevantDataPoints = std::distance(seaCurrentsComp.priorities.begin(), it);
      }
 
      // Resize data collection to include only relevant data points. 
      data.mData.resize(relevantDataPoints);
 
      for (size_t idx = 0, pointCount = relevantDataPoints; idx < pointCount; ++idx) {
        float     angle = glm::radians(seaCurrentsComp.angles[idx]);
        float     speed = seaCurrentsComp.speeds[idx];
 
        uint32_t  colouridx = 0;
        glm::vec2 pos = seaCurrentsComp.positions[idx];
 
        for (; colouridx < 8; ++colouridx) {
          if (speed < cSpeedBandMax[colouridx]) {
            break;
          }
        }
        float scalingFactor = 1.0f;
        
        if (seaCurrentsComp.scalingMode == ArrowScalingMode::Normal) {
          scalingFactor = std::min(std::max(lowestSpeed, speed), highestSpeed) / highestSpeed;
        } 
        else if (seaCurrentsComp.scalingMode == ArrowScalingMode::PerBand) {
          scalingFactor = (speed - cSpeedBandMin[colouridx]) / cSpeedBandWidth[colouridx];
        }
 
        float     scale = std::lerp(minScale, maxScale, scalingFactor);
 
        data.mData[idx].pos = glm::vec4(pos, scale * seaCurrentsComp.scale, angle);
        data.mData[idx].colour = cColours[colouridx];
      }
    }
  }
}
 
void Cogs::Core::SeaCurrentsSystem::cleanup(Context* context) {
  if (mRenderer) {
    context->renderer->unregisterExtension(mRenderer);
    delete mRenderer;
    mRenderer = nullptr;
  }
}
 
ComponentHandle Cogs::Core::SeaCurrentsSystem::createComponent()
{
  ComponentHandle handle = base_type::createComponent();
  Cogs::Core::MaterialHandle  material = context->materialManager->loadMaterial("Materials/SeaCurrentsMaterial.material");
 
  context->materialManager->processLoading();
 
  mMaterial = context->materialInstanceManager->createMaterialInstance(material);
  // Ensure consistent AssetBounds.
  if (pool.size() == 1u) {
    assert(bounds == nullptr);
    bounds = std::make_unique<SeaCurrentsBounds>(this);
    context->bounds->addBoundsExtension(bounds.get());
  }
 
  return handle;
}
void Cogs::Core::SeaCurrentsSystem::destroyComponent(ComponentHandle component)
{
  base_type::destroyComponent(component);
 
  if (pool.size() == 0u && bounds) {
    context->bounds->removeBoundsExtension(bounds.get());
    bounds.reset();
  }
}
 
Cogs::Geometry::BoundingBox Cogs::Core::SeaCurrentsSystem::getWorldBounds(const SeaCurrentsComponent& seaCurrentsComponent, bool ignoreVisibility) const
{
  if (!ignoreVisibility) {
    auto sc = seaCurrentsComponent.getComponent<SceneComponent>();
    if (sc && !sc->visible)
      return Geometry::makeEmptyBoundingBox<Geometry::BoundingBox>();
  }
 
  const SeaCurrentsData& data = getData(&seaCurrentsComponent);
  return data.mTransformedBounds;
}
 
void Cogs::Core::SeaCurrentsBounds::getBounds(Context* /*context*/, Cogs::Geometry::BoundingBox& bounds)
{
  for (SeaCurrentsComponent& seaCurrentsComponent : seaCurrentSystem->pool) {
    const Cogs::Geometry::BoundingBox bbox = seaCurrentSystem->getWorldBounds(seaCurrentsComponent, false);
    if (!isEmpty(bbox))
      bounds += bbox;
  }
}
 
bool Cogs::Core::SeaCurrentsBounds::getBounds(Context* /*context*/, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const
{
  auto seaCurrentsComponent = entity->getComponent<SeaCurrentsComponent>();
  if (!seaCurrentsComponent) return false;
  // SeaCurrentsBounds always bound to same Context as entity and SeaCurrentSystem
  const Cogs::Geometry::BoundingBox bbox = seaCurrentSystem->getWorldBounds(*seaCurrentsComponent, ignoreVisibility);
  if (!isEmpty(bbox)) {
    bounds = bbox;
    return true;
  }
  else {
    return false;
  }
}