ShapeSystem.cpp

#include "ShapeSystem.h"
 
#include "Context.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
#include "Resources/ModelManager.h"
 
#include "Services/Variables.h"
 
#include "Math/IndexConversion.h"
#include "Math/NormalGenerator.h"
 
#include "Foundation/Geometry/Glm.hpp"
 
#include "Rendering/ICapabilities.h"
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ShapeSystem");
 
  const Cogs::StringView instancedLinesSettingName = "shapeSystem.instancedLine";
 
  bool buildInstancedLineList(Mesh* mesh, MaterialComponent* materialComponent, const ShapeComponent& shapeComponent)
  {
    size_t vn = shapeComponent.indexes.empty() ? shapeComponent.positions.size() : shapeComponent.indexes.size();
 
    size_t stride = 0;
    size_t instanceCount = 0;
    switch (shapeComponent.primitiveType) {
 
    case ShapePrimitiveType::LineList:
      stride = 2;
      instanceCount = vn / 2;
      break;
 
    case ShapePrimitiveType::LineStrip:
      stride = 1;
      instanceCount = std::max(size_t(1), vn) - 1;
      break;
 
    default:
      return false;
    }
 
    {
      Cogs::VertexElement format[] = {
        Cogs::VertexElement{
          .offset = 0,
          .format = Cogs::DataFormat::X32Y32Z32_FLOAT,
          .semantic = Cogs::ElementSemantic::Position,
          .semanticIndex = 0,
          .inputType = Cogs::InputType::InstanceData,
          .instanceStep = 1
        },
        Cogs::VertexElement{
          .offset = 3 * sizeof(float),
          .format = Cogs::DataFormat::X32Y32Z32_FLOAT,
          .semantic = Cogs::ElementSemantic::Position,
          .semanticIndex = 1,
          .inputType = Cogs::InputType::InstanceData,
          .instanceStep = 1
        }
      };
      Cogs::VertexFormatHandle formatHandle = Cogs::VertexFormats::createVertexFormat(format, std::size(format));
 
 
      glm::vec3 hi(-std::numeric_limits<float>::max());
      glm::vec3 lo(std::numeric_limits<float>::max());
      if (glm::vec3* ptr = (glm::vec3*)mesh->mapStream(VertexDataType::Positions, formatHandle, 0, (vn + stride - 1) / stride, stride * sizeof(glm::vec3), true); ptr != nullptr) {
        if (shapeComponent.indexes.empty()) {
          for (size_t i = 0; i < vn; i++) {
            const glm::vec3 p = shapeComponent.positions[i];
            hi = glm::max(hi, p);
            lo = glm::min(lo, p);
            ptr[i] = p;
          }
        }
        else {
          for (size_t i = 0; i < vn; i++) {
            const glm::vec3 p = shapeComponent.positions[shapeComponent.indexes[i]];
            hi = glm::max(hi, p);
            lo = glm::min(lo, p);
            ptr[i] = p;
          }
        }
        mesh->unmap(VertexDataType::Positions);
        mesh->setBounds(Cogs::Geometry::BoundingBox{ lo, hi });
      }
    }
 
    mesh->primitiveType = Cogs::PrimitiveType::TriangleStrip;
    mesh->setCount(4);
    mesh->setInstanceCount(instanceCount);
    mesh->setMeshFlag(MeshFlags::Instanced);
 
    materialComponent->primitiveType = Cogs::PrimitiveType::LineStrip;
    materialComponent->instancedLine = true;
    materialComponent->setChanged();
 
    return true;
  }
 
 
}
 
using namespace Cogs::Geometry;
 
 
void Cogs::Core::ShapeSystem::initialize(Context* context)
{
    ComponentSystem::initialize(context);
    supportsInstancing = context->renderer->getDevice()->getCapabilities()->supportsInstancing();
}
 
void Cogs::Core::ShapeSystem::update(Context * context)
{
  bool forceUpdate = false;
  if (supportsInstancing) {
    Variable* instancedLinesVar = context->variables->get(instancedLinesSettingName);
    if (instancedLinesVar->isEmpty()) {
      instancedLinesVar->setBool(false);
      forceUpdate = true;
    }
    instancedLines = instancedLinesVar->getBool();
  }
 
  for (const auto & shapeComponent : pool) {
    MeshComponent* meshComponent = shapeComponent.getComponent<MeshComponent>(); assert(meshComponent);
    MaterialComponent* materialComponent = shapeComponent.getComponent<MaterialComponent>();
 
    if (forceUpdate || shapeComponent.hasChanged()) {
      if (!HandleIsValid(meshComponent->meshHandle)) {
        meshComponent->meshHandle = context->meshManager->create();
        context->meshManager->get(meshComponent->meshHandle)->setName(shapeComponent.getContainer()->getName());
      }
 
      auto mesh = context->meshManager->get(meshComponent->meshHandle);
 
      mesh->clear();
 
      if (!shapeComponent.positions.size()) {
        continue;
      }
 
      if (instancedLines) {
        switch (shapeComponent.primitiveType) {
 
        case ShapePrimitiveType::LineList:
        case ShapePrimitiveType::LineStrip:
          if (buildInstancedLineList(mesh, materialComponent, shapeComponent)) {
            continue;
          }
          break;
 
        default:
          break;
        }
      }
 
      if (materialComponent) {
        materialComponent->instancedLine = false;
      }
      switch (shapeComponent.primitiveType) {
      case ShapePrimitiveType::Default:
        {
          if (shapeComponent.positions.size() == shapeComponent.normals.size()) {
            mesh->setPositions(shapeComponent.positions);
 
            if (shapeComponent.normals.size()) {
              mesh->setNormals(shapeComponent.normals);
            }
 
            if (shapeComponent.texCoords.size()) {
              mesh->setTexCoords(shapeComponent.texCoords);
            }
 
            reindex(shapeComponent.indexes, mesh, false);
          } else if (shapeComponent.positions.size() && !shapeComponent.normals.size()) {
            const auto & idx = shapeComponent.indexes;
 
            bool quads = idx.size() >= 5 && (idx.size() % 5) == 0 && idx[4] == -1;
 
            std::vector<glm::vec3> positions;
            std::vector<glm::vec3> normals;
            std::vector<int32_t> indexes;
            std::vector<glm::vec2> texCoords;
 
            Cogs::Geometry::generateFacetNormals(
              shapeComponent.positions.data(),
              shapeComponent.positions.size(),
              shapeComponent.indexes.data(),
              shapeComponent.indexes.size(),
              shapeComponent.texCoords.data(),
              quads,
              true,
              true,
              1.0f,
              false,
              0,
              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);
          }
        }
        break;
      case ShapePrimitiveType::DefaultLine:
        {
          if (materialComponent) {
            materialComponent->primitiveType = PrimitiveType::LineList;
          }
 
          mesh->setPositions(shapeComponent.positions);
 
          if (shapeComponent.normals.size()) {
            mesh->setNormals(shapeComponent.normals);
          }
 
          if (shapeComponent.texCoords.size()) {
            mesh->setTexCoords(shapeComponent.texCoords);
          }
 
          reindex(shapeComponent.indexes, mesh, true);
 
          if (!shapeComponent.normals.size() && materialComponent) {
            materialComponent->enableLighting = false;
            materialComponent->setChanged();
          }
        }
        break;
      case ShapePrimitiveType::LineListAdjacency:
      case ShapePrimitiveType::LineStripAdjacency:
      case ShapePrimitiveType::LineList:
      case ShapePrimitiveType::LineStrip:
      case ShapePrimitiveType::PointList:
        {
          if (materialComponent) {
            materialComponent->enableLighting = shapeComponent.normals.size() > 0;
            materialComponent->setChanged();
          }
        }
      case ShapePrimitiveType::TriangleList:
      case ShapePrimitiveType::TriangleStrip:
        {
          mesh->setPositions(shapeComponent.positions);
 
          if (shapeComponent.normals.size()) {
            mesh->setNormals(shapeComponent.normals);
          }
 
          if (shapeComponent.texCoords.size()) {
            mesh->setTexCoords(shapeComponent.texCoords);
          }
 
          if (shapeComponent.indexes.size()) {
            mesh->setIndexData(reinterpret_cast<const uint32_t *>(shapeComponent.indexes.data()), shapeComponent.indexes.size());
          }
 
          PrimitiveType::EPrimitiveType typeMap[] = {
            PrimitiveType::TriangleList,
            PrimitiveType::TriangleList,
            PrimitiveType::TriangleStrip,
            PrimitiveType::LineList,
            PrimitiveType::LineList,
            PrimitiveType::LineStrip,
            PrimitiveType::TriangleListAdjacency,
            PrimitiveType::TriangleStripAdjacency,
            PrimitiveType::LineListAdjacency,
            PrimitiveType::LineStripAdjacency,
            PrimitiveType::PointList,
          };
 
          static_assert(sizeof(typeMap) / sizeof(typeMap[0]) == (size_t)ShapePrimitiveType::ShapePrimitiveType_Size, "Type map wrong size.");
 
          mesh->primitiveType = typeMap[static_cast<int>(shapeComponent.primitiveType)];
 
          if (materialComponent) {
            materialComponent->primitiveType = mesh->primitiveType;
          }
        }
        break;
      default:
        break;
      }
    }
  }
}