VariableExtrusionSystem.cpp

#include "VariableExtrusionSystem.h"
#include "Context.h"
#include "EntityStore.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Systems/Core/RenderSystem.h"
 
#include "Utilities/Math.h"
 
#include "Math/ExtrusionGenerator.h"
#include "Math/CrossSectionGenerator.h"
#include "Math/IndexConversion.h"
#include "Math/NormalGenerator.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
using namespace Cogs::Geometry;
 
void Cogs::Core::VariableExtrusionSystem::update(Context * context)
{
  const bool workParallel = context->engine->workParallel();
 
  for (const auto & component : pool) {
    if (!component.isActive()) continue;;
    if (!component.hasChanged() && (!component.trajectory || !component.trajectory->getComponent<TrajectoryComponent>()->hasChanged())) continue;
    
    auto & componentData = getData(&component);
    
    if (!component.closed && !componentData.sideShape) {
      componentData.sideShape = context->store->createChildEntity("Default", component.getContainer());
 
      componentData.sideShape->getComponent<MaterialComponent>()->material = context->store->getEntity(component.getContainer()->getId());
    }
 
    auto updateComponent = [&, context]()
    {
      auto & data = getData(&component);
 
      updatePath(context, component);
 
      if (data.pathLength < 2) {
        return;
      }
 
      const auto materialComponent = component.getComponent<MaterialComponent>();
 
      auto masterMaterial = materialComponent->material.lock();
 
      data.useTexture = HandleIsValid(materialComponent->diffuseMap) || (masterMaterial && HandleIsValid(masterMaterial->getComponent<MaterialComponent>()->diffuseMap));
 
      data.primaryAxis = glm::vec3(0, 0, -1);
 
      updateSegmentCount(context, component);
      //updateWinding(context, component);  // missing implementation
      updateRotations(context, component);
      updateCrossSections(context, component);
      updateOffsets(context, component);
      updateTransformation(context, component);
      offsetCrossSections(context, component);
      updateTextureCoordinates(context, component);
      updateIndexes(context, component);
      updateSideShape(context, component);
      updateNormals(context, component);
    };
 
    if (workParallel) {
      context->taskManager->enqueueChild(context->renderSystem->getTaskGroup(), updateComponent);
    } else {
      updateComponent();
    }
  }
}
 
void Cogs::Core::VariableExtrusionSystem::updatePath(Context * /*context*/, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
 
  data.positions.clear();
  data.directions.clear();
  data.pathLength = 0;
  data.numSegments = 0;
 
  if (!component.trajectory) return;
 
  auto trajectoryComponent = component.trajectory->getComponent<TrajectoryComponent>();
 
  data.positions.resize(component.depths.size());
  data.directions.resize(component.depths.size());
 
  if (component.useOffset) {
    data.offsetDepths.clear();
    data.offsetDepths.resize(component.depths.size());
 
    for (size_t i = 0; i < component.depths.size(); ++i) {
      data.offsetDepths[i] = component.depths[i] + component.depthOffset;
    }
 
    Geometry::PathGenerator::generateLinearPath(data.offsetDepths.data(),
                                      data.offsetDepths.size(),
                                      trajectoryComponent->indexes.data(),
                                      trajectoryComponent->positions.data(),
                                      static_cast<int>(trajectoryComponent->positions.size()),
                                      data.positions.data(),
                                      data.directions.data());
  } else {
    Geometry::PathGenerator::generateLinearPath(component.depths.data(),
                                                component.depths.size(),
                                                trajectoryComponent->indexes.data(),
                                                trajectoryComponent->positions.data(),
                                                static_cast<int>(trajectoryComponent->positions.size()),
                                                data.positions.data(),
                                                data.directions.data());
  }
 
  data.pathLength = data.positions.size();
}
 
void Cogs::Core::VariableExtrusionSystem::updateRotations(Context * /*context*/, const VariableExtrusionComponent & component)
{ 
  auto & data = getData(&component);
 
  data.rotations.resize(data.directions.size());
 
  glm::vec3 primaryAxis = glm::vec3(0, 0, -1);
 
  for (size_t i = 0; i < data.directions.size(); ++i) {
    data.rotations[i] = getRotation(primaryAxis, data.directions[i]);
  }
 
  if (component.useTwist && component.twist.size() == component.profile.size()) {
    float angle = 0;
    
    if (component.enableRotation && !component.useSimpleRotation) {
      angle = component.angle;
    }
 
    for (size_t i = 0; i < data.rotations.size(); ++i) {
      data.rotations[i] = glm::angleAxis(component.twist[i] + angle, data.directions[i]) * data.rotations[i];
    }
  } else {
    for (size_t i = 0; i < data.rotations.size(); ++i) {
      data.rotations[i] = glm::angleAxis(component.angle, data.directions[i]) * data.rotations[i];
    }
  }
}
 
void Cogs::Core::VariableExtrusionSystem::updateCrossSections(Context * context, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
  auto mesh = getMesh(context, component);
  auto positionData = mesh->mapPositions(0, data.numSegments * data.positions.size());
 
  if (component.useMorph && component.morph.size() == component.profile.size()) {
    if (data.useTexture) {
      data.crossSection.assign(component.crossSection.begin(), component.crossSection.end());
      data.morphCrossSection.assign(component.morphCrossSection.begin(), component.morphCrossSection.end());
 
      data.crossSection.push_back(data.crossSection[0]);
      data.morphCrossSection.push_back(data.morphCrossSection[0]);
 
      ExtrusionGenerator::generateCrossSections(positionData.data,
                                                static_cast<int>(data.positions.size()),
                                                data.crossSection.data(),
                                                data.morphCrossSection.data(),
                                                component.morph.data(),
                                                static_cast<int>(data.numSegments),
                                                data.rotations.data());
    } else {
      ExtrusionGenerator::generateCrossSections(positionData.data,
                                                static_cast<int>(data.positions.size()),
                                                component.crossSection.data(),
                                                component.morphCrossSection.data(),
                                                component.morph.data(),
                                                static_cast<int>(data.numSegments),
                                                data.rotations.data());
    }
  } else {
    std::vector<glm::vec3> crossSection(data.numSegments, glm::vec3(0, 0, 0));
    CrossSectionGenerator::generateCircularCrossection(crossSection.data(),
                                                       static_cast<int>(data.numSegments),
                                                       1.0f, 
                                                       0, 
                                                       component.closed ? glm::pi<float>() * 2.0f : glm::pi<float>(),
                                                       !component.closed || data.useTexture);
 
    ExtrusionGenerator::generateCrossSections(positionData.data,
                                              static_cast<int>(data.positions.size()),
                                              crossSection.data(),
                                              static_cast<int>(data.numSegments),
                                              data.rotations.data());
  }
 
  if (component.radiusScale != 1.0f) {
    ExtrusionGenerator::modulateSections(positionData.data, 
                                         static_cast<int>(data.positions.size()),
                                         static_cast<int>(data.numSegments),
                                         &component.radiusScale, 
                                         0);
  }
 
  ExtrusionGenerator::modulateSections(positionData.data,
                                       static_cast<int>(data.positions.size()),
                                       static_cast<int>(data.numSegments),
                                       reinterpret_cast<const float *>(component.profile.data()),
                                       2);
}
 
void Cogs::Core::VariableExtrusionSystem::updateOffsets(Context * context, const VariableExtrusionComponent & component)
{
  const auto & data = getData(&component);
  auto mesh = getMesh(context, component);
 
  auto positionData = mesh->mapPositions(0, data.numSegments * data.positions.size());
 
  std::vector<glm::vec3> offsets(data.pathLength, glm::vec3(0, 0, 0));
 
  for (size_t i = 0; i < offsets.size(); ++i) {
    const float offset = component.profile[i][1];
 
    if (offset != 0) {
      // We only bother calculating the offset if it is not zero.
      offsets[i] = data.rotations[i] * data.primaryAxis;
 
      offsets[i] *= offset;
    }
  }
 
  ExtrusionGenerator::offsetCrossSections(positionData.data,
                                          static_cast<int>(data.pathLength),
                                          static_cast<int>(data.numSegments), 
                                          offsets.data());
}
 
void Cogs::Core::VariableExtrusionSystem::updateTransformation(Context * /*context*/, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
  auto transformComponent = component.getComponent<TransformComponent>();
 
  if (component.enableRotation && component.useSimpleRotation) {
    transformComponent->position = data.positions.front();
 
    auto offset = transformComponent->position;
 
    for (size_t i = 0; i < data.pathLength; ++i) {
      data.positions[i] -= offset;
    }
  } else {
    transformComponent->position = glm::vec3(0, 0, 0);
  }
 
  transformComponent->setChanged();
}
 
void Cogs::Core::VariableExtrusionSystem::offsetCrossSections(Context * context, const VariableExtrusionComponent & component)
{
  const auto & data = getData(&component);
  auto mesh = getMesh(context, component);
 
  auto positionData = mesh->mapPositions(0, data.numSegments * data.positions.size());
 
  ExtrusionGenerator::offsetCrossSections(positionData.data,
                                          static_cast<int>(data.pathLength),
                                          static_cast<int>(data.numSegments),
                                          data.positions.data());
}
 
void Cogs::Core::VariableExtrusionSystem::updateTextureCoordinates(Context * /*context*/, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
 
  const size_t numTextureCoordinates = data.pathLength * data.numSegments;
 
  data.textureCoordinates.resize(numTextureCoordinates);
 
  ExtrusionGenerator::generateDepthBasedTextureCoordinates(data.pathLength, 
                                                           data.numSegments, 
                                                           component.depths.data(), 
                                                           reinterpret_cast<const float *>(component.profile.data()) + 1,
                                                           2, 
                                                           data.textureCoordinates.data());
 
  const glm::vec2 & textureScale = component.textureScale;
  const glm::vec2 & textureOffset = component.textureOffset;
 
  if (textureOffset != glm::vec2(0, 0)) {
    for (size_t i = 0; i < numTextureCoordinates; ++i) {
      data.textureCoordinates[i][0] += textureOffset[0];
      data.textureCoordinates[i][1] += textureOffset[1];
    }
  }
 
  if (textureScale != glm::vec2(1, 1)) {
    for (size_t i = 0; i < numTextureCoordinates; ++i) {
      data.textureCoordinates[i][0] *= textureScale[0];
      data.textureCoordinates[i][1] *= textureScale[1];
    }
  }
}
 
void Cogs::Core::VariableExtrusionSystem::updateIndexes(Context * /*context*/, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
 
  // If the shape is open or textured we need one more segment than the closed/untextured case.
  const size_t numIndexes = (data.pathLength - 1) * (data.numSegments - ((component.closed && !data.useTexture) ? 0 : 1)) * 8;
 
  data.indexes.resize(numIndexes);
 
  ExtrusionGenerator::generateTriangleIndices(data.indexes.data(), static_cast<int>(data.pathLength), static_cast<int>(data.numSegments), component.closed, data.useTexture);
}
 
void Cogs::Core::VariableExtrusionSystem::updateSideShape(Context * context, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
 
  
 
  if (component.closed) {
    if (data.sideShape) {
      auto meshComponent = data.sideShape->getComponent<MeshComponent>();
 
      if (meshComponent->meshHandle) {
        meshComponent->getMesh(context)->clear();
      }
    }
  } else {
    auto meshComponent = data.sideShape->getComponent<MeshComponent>();
 
    if (!HandleIsValid(meshComponent->meshHandle)) {
      meshComponent->meshHandle = context->meshManager->create();
    }
 
    auto regularMesh = getMesh(context, component);
    auto mesh = meshComponent->meshHandle.resolve();
 
    mesh->clear();
 
    const size_t pathLength = data.pathLength;
    const int32_t numSegments = static_cast<int32_t>(data.numSegments);
 
    auto positions = regularMesh->mapPositions(0, regularMesh->getCount());
 
    std::vector<int32_t> indexes((data.pathLength + 2) * 2);
 
    for (size_t i = 0; i < data.pathLength; ++i) {
      indexes[i] = static_cast<int32_t>(i) * numSegments;
      indexes[i + pathLength + 2_uz] = static_cast<int32_t>(i) * numSegments + numSegments - 1;
    }
 
    indexes[pathLength] = 0;
    indexes[pathLength + 1_uz] = -1;
    
    indexes[pathLength + pathLength + 2_uz] = numSegments - 1;
    indexes[pathLength + pathLength + 3_uz] = -1;
 
    std::vector<glm::vec3> newPositions;
    std::vector<glm::vec3> normals;
    std::vector<int32_t> newIndexes;
    std::vector<glm::vec2> texCoords;
 
    {
      auto tessPositions = mesh->mapPositions(0, indexes.size() - 2);
 
      // Copy the points needed for side polygons into the side shape mesh and
      // simultaneously reconstruct the index array relative to this mesh.
      size_t currentIdx = 0;
      size_t currentIIdx = 0;
      while (currentIIdx < indexes.size()) {
        tessPositions[currentIdx] = positions[indexes[currentIIdx]];
 
        indexes[currentIIdx++] = static_cast<int32_t>(currentIdx++);
 
        if (indexes[currentIIdx] == -1) ++currentIIdx;
      }
 
      // Fetch updated tessellated triangle indexes.
      auto tesselatedIndexes = tesselatePolygons(indexes, mesh);
 
      Cogs::Geometry::generateFacetNormals(
        tessPositions.data,
        mesh->getCount(),
        tesselatedIndexes.data(),
        tesselatedIndexes.size(),
        data.textureCoordinates.data(),
        false,
        true,
        true,
        1.0f,
        false,
        0,
        newPositions,
        normals,
        newIndexes,
        &texCoords);
    }
 
    mesh->setPositions(std::move(newPositions));
    mesh->setNormals(std::move(normals));
    
    if (texCoords.size()) {
      mesh->setTexCoords(std::move(texCoords));
    }
 
    reindex(newIndexes, mesh, false);
  }
}
 
void Cogs::Core::VariableExtrusionSystem::updateNormals(Context * context, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
  auto mesh = getMesh(context, component);
  const size_t numElements = data.numSegments * data.positions.size();
  auto positionData = mesh->mapPositions(0, numElements);
 
  std::vector<glm::vec3> positions;
  std::vector<glm::vec3> normals;
  std::vector<int32_t> indexes;
  std::vector<glm::vec2> texCoords;
 
  Cogs::Geometry::generateFacetNormals(
    positionData.data,
    numElements,
    data.indexes.data(),
    data.indexes.size(),
    data.textureCoordinates.data(),
    false,
    true,
    false,
    component.creaseAngle,
    data.useTexture,
    data.numSegments,
    positions,
    normals,
    indexes,
    &texCoords);
 
  mesh->setPositions(std::move(positions));
  mesh->setNormals(std::move(normals));
 
  if (texCoords.size()) {
    mesh->setTexCoords(std::move(texCoords));
  }
 
  reindex(indexes, mesh, false);
}
 
Cogs::Core::Mesh * Cogs::Core::VariableExtrusionSystem::getMesh(Context * context, const VariableExtrusionComponent & component)
{
  auto meshComponent = component.getComponent<MeshComponent>();
 
  if (!HandleIsValid(meshComponent->meshHandle)) {
    meshComponent->meshHandle = context->meshManager->create();
  }
 
  return meshComponent->meshHandle.resolve();
}
 
void Cogs::Core::VariableExtrusionSystem::updateSegmentCount(Context * /*context*/, const VariableExtrusionComponent & component)
{
  auto & data = getData(&component);
 
  const bool useTexture = data.useTexture;
 
  // If we need texturing, we must add an extra segment to the cross section to avoid the texture wrapping
  // back to zero from the last to the first segment.
  int textureExtra = useTexture ? 1 : 0;
 
  if (component.useMorph && component.morph.size() == component.profile.size()) {
    // When morphing we just use the number of elements in the given cross section.
    data.numSegments = component.crossSection.size() + textureExtra;
  } else {
    data.numSegments = component.closed ? component.segmentCount : component.segmentCount / 2 + 1;
 
    data.numSegments += textureExtra;
  }
}