MeshGenerator.cpp

#include "MeshGenerator.h"
 
#include "MeshGeneratorCube.h"
#include "MeshGeneratorSphere.h"
#include "MeshGeneratorCylinder.h"
#include "MeshGeneratorCone.h"
#include "MeshGeneratorCircularArc.h"
 
#include "Resources/MeshManager.h"
 
#include <unordered_map>
 
namespace Cogs
{
  namespace Core
  {
    struct ShapeCache
    {
      std::unordered_map<size_t, MeshHandle> shapes;
    };
  }
}
 
Cogs::Core::MeshGenerator::MeshGenerator(Context * context) :
  context(context),
  cache(std::make_unique<ShapeCache>())
{
}
 
Cogs::Core::MeshGenerator::~MeshGenerator()
{
}
 
void Cogs::Core::MeshGenerator::cleanup()
{
  cache.reset();
}
 
Cogs::Core::MeshHandle Cogs::Core::MeshGenerator::getMesh(ShapeType shape, int samples, glm::vec3 size, float arcStart, float arcEnd)
{
  ShapeDefinition definition = {
    shape,
    refinementLevel(samples, kRefinementLevels, kMaxSamples),
    size,
    arcStart,
    arcEnd
  };
 
  size_t hashValue = hash(definition);
 
  auto found = cache->shapes.find(hashValue);
 
  if (found != cache->shapes.end()) {
    return found->second;
  }
 
  auto meshHandle = context->meshManager->create();
  auto mesh = meshHandle.resolve();
 
  getMesh(mesh, definition);
 
  cache->shapes[hashValue] = MeshHandle(mesh);
  
  return MeshHandle(mesh);
}
 
void Cogs::Core::MeshGenerator::purgeCache()
{
  cache->shapes.clear();
}
 
 
void Cogs::Core::MeshGenerator::getMesh(Mesh * mesh, const ShapeDefinition & definition)
{
  switch (definition.type) {
  case ShapeType::Plane:
    planeFactory(mesh, definition);
    break;
  case ShapeType::Sphere:
  case ShapeType::SphereGeoTexSph:
    sphereGeoTexSphFactory<ShapeType::SphereGeoTexSph>(mesh, definition, kRefinementLevels, kMaxSamples);
    break;
  case ShapeType::SphereGeoTexCyl:
    sphereGeoTexSphFactory<ShapeType::SphereGeoTexCyl>(mesh, definition, kRefinementLevels, kMaxSamples);
    break;
  case ShapeType::Cylinder:
    cylinderFactory(mesh, definition, kRefinementLevels, kMaxSamples);
    break;
  case ShapeType::Cone:
    coneFactory(mesh, definition, kRefinementLevels, kMaxSamples);
    break;
  case ShapeType::Cube:
  case ShapeType::CubeTex2D:
    cubeTex2DFactory(mesh, definition);
    break;
  case ShapeType::WireCube:
    wireCubeFactory(mesh, definition);
    break;
  case ShapeType::CoordSys:
    coordSysFactory(mesh, definition);
    break;
  case ShapeType::CircularArc:
    circularArcFactory(mesh, definition);
    break;
  default:
    break;
  }
}