ExtrusionSystem.cpp

#include "ExtrusionSystem.h"
 
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Data/DataSetComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Context.h"
 
#include "Resources/Mesh.h"
#include "Resources/VertexFormats.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "Utilities/Math.h"
 
#include "Math/CrossSectionGenerator.h"
#include "Math/ExtrusionGenerator.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/ValueQuery.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
using namespace Cogs::Geometry;
 
static void generateExtrusionVertices(float radius, const size_t numSegments, const std::vector<glm::vec3> & positions, std::vector<Cogs::Core::PositionNormalTexVertex> & vertices)
{
  std::vector<glm::vec3> crossection(numSegments);
 
  CrossSectionGenerator::generateCircularCrossection(crossection.data(), static_cast<int>(numSegments), radius, 0, glm::pi<float>() * 2.0f, false);
 
  vertices.resize(numSegments * positions.size());
 
  glm::vec3 direction = positions[1] - positions[0];
 
  for (size_t i = 0; i < positions.size(); ++i) {
    if (i > 0 && i < (positions.size() - 2)) {
      direction = positions[i + 1] - positions[i - 1];
      direction = glm::normalize(direction);
    }
 
    glm::quat rotation = Cogs::Core::getRotation(glm::vec3(0, 0, -1), direction);
 
    for (size_t j = 0; j < crossection.size(); ++j) {
      const size_t index = (i * numSegments) + j;
 
      glm::vec3 position = rotation * crossection[j];
      position = glm::normalize(position);
      glm::vec3 normal = position;
      position *= radius;
      position += positions[i];
 
      Cogs::Core::PositionNormalTexVertex vertex = { position, normal, glm::vec2(static_cast<float>(j) / static_cast<float>(crossection.size()), 0) };
 
      vertices[index] = vertex;
    }
  }
}
 
template<class IndexType>
static void generateExtrusionIndices(const unsigned int numSections, const unsigned int numSegments, std::vector<IndexType> & indices)
{
  const unsigned int numFaces = numSegments * (numSections - 1) * 2;
  const unsigned int numIndices = numFaces * 3;
 
  indices.resize(numIndices);
 
  ExtrusionGenerator::generateTriangleIndices(indices.data(), numSections, numSegments, true, false, 0);
}
 
void Cogs::Core::ExtrusionSystem::update(Context * context)
{
  auto & meshManager = context->meshManager;
 
  for (const auto & component : pool) {
    if (!component.active) continue;
 
    auto meshComponent = component.getComponent<MeshComponent>();
 
    if (meshComponent->meshHandle == MeshHandle::NoHandle) {
      meshComponent->meshHandle = context->meshManager->create();
    }
 
    auto mesh = meshManager->get(meshComponent->meshHandle);
 
    if (component.trajectory) {
      updateExtrusion(component, mesh);
    } else if (component.extrusion && component.dataSet) {
      updateLogExtrusion(component, context, mesh);
    } else if (component.highlightTarget) {
      updateHighlightExtrusion(component, context, mesh);
    } else {
      mesh->clear();
    }
  }
}
 
void Cogs::Core::ExtrusionSystem::updateExtrusion(const ExtrusionComponent & component, Mesh * mesh)
{
  const auto trajectoryData = component.trajectory->getComponent<TrajectoryComponent>();
 
  if (!trajectoryData || !trajectoryData->positions.size()) return;
 
  auto & data = getData<ExtrusionData>(&component);
 
  if (component.hasChanged() || trajectoryData->hasChanged()) {
    std::vector<PositionNormalTexVertex> extrusionVertices;
 
    if (component.coverEntireTrajectory) {
      generateExtrusionVertices(component.radius * component.diameterScale, component.numSegments, trajectoryData->positions, extrusionVertices);
 
      for (size_t i = 0; i < trajectoryData->indexes.size(); ++i) {
        for (size_t j = 0; j < component.numSegments; ++j) {
          extrusionVertices[i * component.numSegments + j].tex.y = trajectoryData->indexes[i];
        }
      }
    } else {
      auto & depthList = data.depthList;
      depthList.clear();
 
      SampleListGenerator::generateIndexedSamples(
        component.startDepth,
        component.endDepth,
        trajectoryData->indexes.data(),
        static_cast<int>(trajectoryData->indexes.size()),
        depthList);
 
      data.basePositions.resize(depthList.size());
      data.baseDirections.resize(depthList.size());
 
      PathGenerator::generateLinearPath(depthList.data(),
                                        static_cast<int>(depthList.size()),
                                        trajectoryData->indexes.data(),
                                        trajectoryData->positions.data(),
                                        static_cast<int>(trajectoryData->indexes.size()),
                                        data.basePositions.data(),
                                        data.baseDirections.data());
 
      generateExtrusionVertices(component.radius * component.diameterScale, component.numSegments, data.basePositions, extrusionVertices);
    }
 
    mesh->setVertexData(extrusionVertices.data(), extrusionVertices.size());
 
    std::vector<unsigned int> extrusionIndices;
 
    generateExtrusionIndices(static_cast<unsigned int>(component.coverEntireTrajectory ? trajectoryData->positions.size() : data.basePositions.size()), component.numSegments, extrusionIndices);
 
    mesh->setIndexes(std::move(extrusionIndices));
 
    mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
  }
}
 
void Cogs::Core::ExtrusionSystem::updateLogExtrusion(const ExtrusionComponent & component, Context * context, Mesh * mesh)
{
  const auto transform = component.getComponent<TransformComponent>();
  const auto extrusion = component.extrusion->getComponent<ExtrusionComponent>();
  const auto extrusionTransform = extrusion->getComponent<TransformComponent>();
  const auto trajectory = extrusion->trajectory->getComponent<TrajectoryComponent>();
  const auto dataSet = component.dataSet->getComponent<DataSetComponent>();
 
  context->transformSystem->copyTransform(extrusionTransform, transform);
 
  auto material = component.getComponent<MaterialComponent>();
 
  auto colorMap = component.colorMap;
 
  if (colorMap) {
    auto colorMapMaterial = colorMap->getComponent<MaterialComponent>();
 
    if (material->diffuseMap != colorMapMaterial->diffuseMap) {
      material->diffuseMap = colorMapMaterial->diffuseMap;
      material->diffuseColor = glm::vec4(1, 1, 1, 1);
      material->setChanged();
    }
  }
 
  if (extrusion->hasChanged() ||
      trajectory->hasChanged() ||
      dataSet->hasChanged() ||
      component.hasChanged()) {
    auto & data = getData<ExtrusionData>(&component);
    auto & logData = getData<ExtrusionLogData>(&component);
 
    const float endDepth = component.coverEntireTrajectory ? std::min(dataSet->indexes[dataSet->indexes.size() - 1], trajectory->indexes[trajectory->indexes.size() - 1]) : component.startDepth;
    const float startDepth = component.coverEntireTrajectory ? std::max(dataSet->indexes[0], trajectory->indexes[0]) : component.endDepth;
 
    std::vector<float> & depthList = data.depthList;
    depthList.clear();
 
    SampleListGenerator::generateIndexedSamples<float>(
      startDepth,
      endDepth,
      trajectory->indexes.data(),
      static_cast<int>(trajectory->indexes.size()),
      depthList);
 
    std::vector<float> & samples = data.samples;
    samples.clear();
 
    SampleListGenerator::createUniqueVector(
      depthList.data(),
      depthList.size(),
      dataSet->indexes.data(),
      static_cast<int>(dataSet->indexes.size()),
      startDepth,
      endDepth,
      samples);
 
    std::vector<glm::vec3> & basePositions = data.basePositions;
    basePositions.resize(samples.size());
 
    std::vector<glm::vec3> & baseDirections = data.baseDirections;
    baseDirections.resize(samples.size());
 
    std::vector<float> & values = logData.values;
    logData.values.resize(samples.size());
 
    ValueQuery::getValuesAtDepths(samples.data(), static_cast<int>(samples.size()), dataSet->indexes.data(), dataSet->values.data(), static_cast<int>(dataSet->values.size()), values.data());
 
    auto minMax = std::minmax_element(dataSet->values.begin(), dataSet->values.end());
 
    SampleListGenerator::normalizeValues<float, true>(values.data(), values.data(), static_cast<int>(values.size()), *minMax.first, *minMax.second);
 
    PathGenerator::generateLinearPath(samples.data(), static_cast<int>(samples.size()), trajectory->indexes.data(), trajectory->positions.data(), static_cast<int>(trajectory->positions.size()), basePositions.data(), baseDirections.data());
 
    logData.radius = extrusion->radius * extrusion->diameterScale * 1.05f;
 
    std::vector<PositionNormalTexVertex> extrusionVertices;
 
    generateExtrusionVertices(logData.radius, component.numSegments, data.basePositions, extrusionVertices);
 
    const size_t numSamples = data.samples.size();
 
    size_t texIdx = 0;
    for (size_t s = 0; s < numSamples; ++s) {
      for (size_t ss = 0; ss < component.numSegments; ++ss) {
        extrusionVertices[texIdx++].tex = glm::vec2(logData.values[s], 0);
      }
    }
 
    mesh->setVertexData(extrusionVertices.data(), extrusionVertices.size());
 
    std::vector<unsigned int> extrusionIndices;
 
    generateExtrusionIndices(static_cast<unsigned int>(data.basePositions.size()), component.numSegments, extrusionIndices);
 
    mesh->setIndexData(extrusionIndices.data(), extrusionIndices.size());
 
    mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
  }
}
 
void Cogs::Core::ExtrusionSystem::updateHighlightExtrusion(const ExtrusionComponent & component, Context * context, Mesh * mesh)
{
  const auto transform = component.getComponent<TransformComponent>();
  const auto extrusionComponent = component.highlightTarget->getComponent<ExtrusionComponent>();
  const auto extrusionTransform = extrusionComponent->getComponent<TransformComponent>();
 
  if (!extrusionComponent->active) return;
 
  context->transformSystem->copyTransform(extrusionTransform, transform);
 
  TrajectoryComponent * trajectory;
 
  if (extrusionComponent->extrusion) {
    // Log
    auto well = extrusionComponent->extrusion->getComponent<ExtrusionComponent>();
    trajectory = well->trajectory->getComponent<TrajectoryComponent>();
  } else {
    // Wellbore
    trajectory = extrusionComponent->trajectory->getComponent<TrajectoryComponent>();
  }
 
  const auto & targetData = getData<ExtrusionData>(extrusionComponent);
  const auto & targetLogData = getData<ExtrusionLogData>(extrusionComponent);
  auto & data = getData<ExtrusionData>(&component);
 
  if (extrusionComponent->hasChanged() ||
      trajectory->hasChanged() ||
      component.hasChanged()) {
    const float startDepth = std::max(component.highlightStart, trajectory->indexes[0]);
    const float endDepth = std::min(component.highlightEnd, trajectory->indexes[trajectory->indexes.size() - 1]);
    data.samples.clear();
 
    SampleListGenerator::generateIndexedSamples<float>(
      startDepth,
      endDepth,
      extrusionComponent->extrusion ? targetData.depthList.data() : trajectory->indexes.data(),
      static_cast<int>(extrusionComponent->extrusion ? targetData.depthList.size() : trajectory->indexes.size()),
      data.samples);
 
    data.basePositions.resize(data.samples.size());
    data.baseDirections.resize(data.samples.size());
 
    PathGenerator::generateLinearPath(data.samples.data(), static_cast<int>(data.samples.size()), trajectory->indexes.data(), trajectory->positions.data(), static_cast<int>(trajectory->positions.size()), data.basePositions.data(), data.baseDirections.data());
 
    if (data.samples.size() > 1) {
      std::vector<PositionNormalTexVertex> extrusionVertices;
 
      generateExtrusionVertices(extrusionComponent->extrusion ? targetLogData.radius * 1.05f : extrusionComponent->radius * 1.05f, component.numSegments, data.basePositions, extrusionVertices);
 
      mesh->setVertexData(extrusionVertices.data(), extrusionVertices.size());
 
      std::vector<unsigned int> extrusionIndices;
 
      generateExtrusionIndices((unsigned int) data.basePositions.size(), component.numSegments, extrusionIndices);
 
      mesh->setIndexes(std::move(extrusionIndices));
 
      auto materialComponent = component.getComponent<MaterialComponent>();
      materialComponent->blendMode = BlendMode::Add;
      materialComponent->setChanged();
 
      if (true) {
        /*if (renderComponent->materialHandles[1] == MaterialInstanceHandle::NoHandle) {
          renderComponent->materialHandles[1] = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
        }
 
        auto material = context->materialInstanceManager->get(renderComponent->materialHandles[1]);
        material->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(0, 0, 0, 1));
 
        std::vector<uint32_t> outlineIndexes(component.numSegments * 4);
        size_t index = 0;
 
        for (uint32_t i = 0; i < component.numSegments; ++i) {
          outlineIndexes[index++] = i;
          outlineIndexes[index++] = (i < static_cast<size_t>(component.numSegments - 1)) ? i + 1 : 0;
        }
 
        const uint32_t baseOffset = static_cast<uint32_t>(data.basePositions.size() - 1) * component.numSegments;
 
        for (uint32_t i = 0; i < component.numSegments; ++i) {
          outlineIndexes[index++] = baseOffset + i;
          outlineIndexes[index++] = baseOffset + ((i < static_cast<size_t>(component.numSegments - 1)) ? i + 1 : 0);
        }
 
        mesh->addSubMesh(outlineIndexes, PrimitiveType::LineList);*/
      }
 
      mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
    } else {
      mesh->clear();
    }
  }
}