CommandHelpers.cpp

#include "Context.h"
#include "EntityStore.h"
 
#include "Resources/Mesh.h"
#include "Resources/MaterialInstance.h"
#include "Resources/MeshManager.h"
 
#include "Platform/Instrumentation.h"
 
#include "CommandHelpers.h"
 
namespace {
  using namespace Cogs::Core;
 
 
  template<typename T>
  void copy(Cogs::Memory::TypedBuffer<T> & dst, const Cogs::Memory::TypedBuffer<T>& src)
  {
    dst.resize(src.size());
    if (src.size()) {
      std::memcpy(dst.data(), src.data(), src.byteSize());
    }
 
  }
 
 
  struct PrefixItem
  {
    Cogs::ComponentModel::ComponentPtr<TransformComponent> trComp;
    uint32_t index;
  };
 
 
  void recordPrefix(std::vector<PrefixItem>& prefix, Cogs::Core::MeshItems& items)
  {
    // Hierarchy already updated, nothing to do.
    if (prefix.back().index != ~0u)  return;
 
    // Make sure hierarchy is recorded, from root to leaf
    for (size_t i = 0; i < prefix.size(); i++) {
      if (prefix[i].index == ~0u) {
        prefix[i].index = uint32_t(items.transforms.size());
        items.transforms.emplace_back(TransformItem{ prefix[i].trComp, i == 0 ? ~0u : prefix[i - 1].index });
      }
    }
  }
 
  void getMeshItems_(std::vector<PrefixItem>& prefix, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask);
 
  void descend(std::vector<PrefixItem>& prefix, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask)
  {
    auto * sceneComp = entity->getComponent<SceneComponent>();
    if (!sceneComp) return;
 
    // Add hierarchy to prefix.
    auto trComp = Cogs::ComponentModel::ComponentPtr<TransformComponent>(entity);
    if (trComp) prefix.emplace_back(PrefixItem{ trComp, ~0u });
 
    for (auto & child : sceneComp->children) {
      getMeshItems_(prefix, items, child, primitiveTypeMask);
    }
 
    if (trComp) prefix.pop_back();
  }
 
 
  void extract(std::vector<PrefixItem>& prefix, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask)
  {
    if (auto meshComp = Cogs::ComponentModel::ComponentPtr<MeshComponent>(entity); meshComp && meshComp->meshHandle) {
      if (((1 << meshComp->meshHandle->primitiveType) & primitiveTypeMask) != 0) {
        if (auto meshRenderComp = Cogs::ComponentModel::ComponentPtr<MeshRenderComponent>(entity)) {
 
          items.meshes.emplace_back(MeshItem{ meshComp->meshHandle, meshComp,  meshRenderComp,  meshRenderComp->material.resolve(), meshRenderComp->startIndex, meshRenderComp->vertexCount, ~0u });
 
          if (!prefix.empty()) {
            recordPrefix(prefix, items);
            items.meshes.back().parent = prefix.back().index;
          }
        }
      }
    }
  }
 
 
  void getMeshItems_(std::vector<PrefixItem>& prefix, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask)
  {
    descend(prefix, items, entity, primitiveTypeMask);
    extract(prefix, items, entity, primitiveTypeMask);
  }
 
 
  void getMeshItems_(Context* context, std::vector<PrefixItem>& prefix, MeshItems& items, EntityIds entities, uint32_t primitiveTypeMask)
  {
    for (auto & entity : entities) {
      auto entityPtr = context->store->getEntity(entity);
      if (entityPtr) {
        getMeshItems_(prefix, items, entityPtr, primitiveTypeMask);
      }
    }
  }
 
  void copy(TransformComponent* dstTrComp, const TransformComponent* srcTrComp)
  {
    dstTrComp->coordinates = srcTrComp->coordinates;
    dstTrComp->transform = srcTrComp->transform;
    dstTrComp->transformFlags = srcTrComp->transformFlags;
    dstTrComp->setChanged();
  }
 
  void createNodeHierarchy(Context* context, std::vector<Cogs::ComponentModel::ComponentPtr<SceneComponent>>& hierarchy, EntityPtr parent, const std::vector<TransformItem>& transforms)
  {
    hierarchy.resize(transforms.size());
 
    for (size_t i = 0; i < transforms.size(); i++) {
      auto srcTrComp = transforms[i].trComp;
 
      auto entity = context->store->createEntity(srcTrComp->getContainer()->getName(), "Group", false);
      hierarchy[i] = Cogs::ComponentModel::ComponentPtr<SceneComponent>(entity);
 
      if (transforms[i].parent == ~0u) {
        context->store->addChild(parent.get(), entity);
      }
      else {
        assert(transforms[i].parent < i);
        context->store->addChild(hierarchy[transforms[i].parent]->getContainer(), entity);
      }
 
      copy(entity->getComponent<TransformComponent>(), srcTrComp.get());
    }
  }
 
  void createMeshResources(Context* context, std::vector<Cogs::ComponentModel::Entity*>& entities, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes)
  {
    assert(entities.size() == meshes.size());
    assert(entities.size() == originalMeshes.size());
 
    for (size_t j = 0; j < meshes.size(); j++) {
      const auto & meshRep = meshes[j];
 
      auto * meshComp = entities[j]->getComponent<MeshComponent>();
      if (meshRep.positions.size() == 0) {
        meshComp->meshHandle = MeshHandle::NoHandle;
        continue;
      }
      meshComp->meshHandle = context->meshManager->create();
      meshComp->setChanged();
 
      auto * mesh = meshComp->meshHandle.resolve();
 
      auto bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
      for (size_t i = 0; i < meshRep.positions.size(); i++) {
        bbox.min = glm::min(bbox.min, meshRep.positions[i]);
        bbox.max = glm::max(bbox.max, meshRep.positions[i]);
      }
      mesh->setBounds(bbox);
 
      mesh->setPositions(meshRep.positions.data(), meshRep.positions.data() + meshRep.positions.size());
      if (meshRep.normals.size() != 0) {
        mesh->setNormals(meshRep.normals.data(), meshRep.normals.data() + meshRep.normals.size());
      }
      if (meshRep.texcoords.size() != 0) {
        mesh->setTexCoords(meshRep.texcoords.data(), meshRep.texcoords.data() + meshRep.texcoords.size());
      }
      if (meshRep.tangents.size() != 0) {
        mesh->setTangents(meshRep.tangents.data(), meshRep.tangents.data() + meshRep.tangents.size());
      }
      if (meshRep.indices.size() != 0) {
        mesh->setIndexData(meshRep.indices.data(), meshRep.indices.size());
      }
 
      auto * originalMesh = originalMeshes[j].resolve();
      if (originalMesh->isMeshFlagSet(MeshFlags::ClockwiseWinding)) {
        mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
      }
      else {
        mesh->unsetMeshFlag(MeshFlags::ClockwiseWinding);
      }
 
      mesh->primitiveType = originalMesh->primitiveType;
 
      auto * meshRndComp = entities[j]->getComponent<MeshRenderComponent>();
      meshRndComp->startIndex = 0;
      meshRndComp->vertexCount = (uint32_t)-1;
      meshRndComp->setChanged();
    }
  }
 
 
  void createMeshNodes(Context* context, const std::vector<Cogs::ComponentModel::ComponentPtr<SceneComponent>>& hierarchy, Cogs::ComponentModel::Entity* parent, std::vector<MeshHandle>& originalMeshes, const std::vector<MeshItem>& meshItems, MeshReps& meshes)
  {
    std::vector<Cogs::ComponentModel::Entity*> entities(meshes.size());
    for (size_t i = 0; i < meshItems.size(); i++) {
      auto & item = meshItems[i];
 
      auto * meshEntityParent = parent;
      if (item.parent != (uint32_t)-1) {
        assert(item.parent < hierarchy.size());
        meshEntityParent = hierarchy[item.parent]->getContainer();
      }
 
      auto entity = context->store->createChildEntity("MeshPart", meshEntityParent, item.meshComp->getContainer()->getName());
      entities[i] = entity.get();
      
      copy(entity->getComponent<TransformComponent>(), item.meshComp->getComponent<TransformComponent>());
 
      auto * meshRndComp = entity->getComponent<MeshRenderComponent>();
      meshRndComp->material = item.meshComp->getComponent<MeshRenderComponent>()->material;
      meshRndComp->setChanged();
    }
 
    createMeshResources(context, entities, originalMeshes, meshes);
 
  }
}
 
EntityPtr Cogs::Core::createNewMeshItems(Context* context, Cogs::ComponentModel::Entity* parent, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items)
{
  // FIXME: No need to create a group if the hierarchy already have a single root node.
  auto group = context->store->createEntity("", "Group", parent == nullptr);
  if (parent) {
    context->store->addChild(parent, group);
  }
 
  std::vector<Cogs::ComponentModel::ComponentPtr<SceneComponent>> hierarchy;
  createNodeHierarchy(context, hierarchy, group, items.transforms);
  createMeshNodes(context, hierarchy, group.get(), originalMeshes, items.meshes, meshes);
  return group;
}
 
 
EntityPtr Cogs::Core::createAsSingleMeshItem(Context* context, Cogs::ComponentModel::Entity* parent, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items)
{
 
  auto entity = context->store->createChildEntity("MeshPart", parent, "Combined");
  auto * meshComp = entity->getComponent<MeshComponent>();
  meshComp->meshHandle = context->meshManager->create();
  meshComp->setChanged();
 
  auto * mesh = meshComp->meshHandle.resolve();
 
  size_t Vn = 0;
  size_t Nn = 0;
  size_t Tn = 0;
  size_t Xn = 0;
  size_t In = 0;
  for(auto & meshRep : meshes) {
    Vn += meshRep.positions.size();
    Nn += meshRep.normals.size();
    Tn += meshRep.tangents.size();
    Xn += meshRep.texcoords.size();
    In += meshRep.indices.size();
  }
 
  MeshRep singleRep;
  singleRep.positions.resize(Vn, false);
  singleRep.normals.resize(Nn, false);
  singleRep.tangents.resize(Tn, false);
  singleRep.texcoords.resize(Xn, false);
  singleRep.indices.resize(In, false);
 
 
  size_t Vo = 0;
  size_t No = 0;
  size_t To = 0;
  size_t Xo = 0;
  size_t Io = 0;
 
  for (size_t j = 0; j < meshes.size(); j++) {
    const auto & meshRep = meshes[j];
 
    if (meshRep.positions.size() == 0) continue;
 
    auto lIn = meshRep.indices.size();
    if (lIn) {
      for (size_t i = 0; i < lIn; i++) {
        singleRep.indices[Io + i] = meshRep.indices[i] + uint32_t(Vo);
      }
      Io += lIn;
    }
 
    auto lVn = meshRep.positions.size();
    std::memcpy(singleRep.positions.data() + Vo, meshRep.positions.data(), sizeof(glm::vec3)*lVn);
    Vo += lVn;
 
    // FIXME: Assumes no transforms! Not a valid assumption.
 
    auto lNn = meshRep.normals.size();
    if (lNn) {
      std::memcpy(singleRep.normals.data() + No, meshRep.normals.data(), sizeof(glm::vec3)*lNn);
      No += lNn;
    }
 
    auto lTn = meshRep.tangents.size();
    if (lTn) {
      std::memcpy(singleRep.tangents.data() + To, meshRep.tangents.data(), sizeof(glm::vec3)*lTn);
      To += lTn;
    }
 
    auto lXn = meshRep.texcoords.size();
    if (lXn) {
      std::memcpy(singleRep.texcoords.data() + Xo, meshRep.texcoords.data(), sizeof(glm::vec2)*lXn);
      Xo += lXn;
    }
 
  }
 
  auto bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
  for (size_t i = 0; i < singleRep.positions.size(); i++) {
    bbox.min = glm::min(bbox.min, singleRep.positions[i]);
    bbox.max = glm::max(bbox.max, singleRep.positions[i]);
  }
  mesh->setBounds(bbox);
 
  mesh->setPositions(singleRep.positions.data(), singleRep.positions.data() + singleRep.positions.size());
  if (singleRep.normals.size() != 0) {
    mesh->setNormals(singleRep.normals.data(), singleRep.normals.data() + singleRep.normals.size());
  }
  if (singleRep.texcoords.size() != 0) {
    mesh->setTexCoords(singleRep.texcoords.data(), singleRep.texcoords.data() + singleRep.texcoords.size());
  }
  if (singleRep.tangents.size() != 0) {
    mesh->setTangents(singleRep.tangents.data(), singleRep.tangents.data() + singleRep.tangents.size());
  }
  if (singleRep.indices.size() != 0) {
    mesh->setIndexData(singleRep.indices.data(), singleRep.indices.size());
  }
 
  auto * originalMesh = originalMeshes[0].resolve();
  if (originalMesh->isMeshFlagSet(MeshFlags::ClockwiseWinding)) {
    mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
  }
  else {
    mesh->unsetMeshFlag(MeshFlags::ClockwiseWinding);
  }
 
  mesh->primitiveType = originalMesh->primitiveType;
 
  auto * meshRndComp = entity->getComponent<MeshRenderComponent>();
  meshRndComp->material = items.meshes.front().meshRenderComp->material;
  meshRndComp->startIndex = 0;
  meshRndComp->vertexCount = (uint32_t)-1;
  meshRndComp->setChanged();
 
  return entity;
}
 
 
void Cogs::Core::MeshRep::copy(const MeshRep & other)
{
  CpuInstrumentationScope(SCOPE_EDITOR_COMMAND, "MeshRepCopy");
  ::copy(positions, other.positions);
  ::copy(normals, other.normals);
  ::copy(texcoords, other.texcoords);
  ::copy(tangents, other.tangents);
  ::copy(indices, other.indices);
}
 
 
void Cogs::Core::getMeshItems(Context* /*context*/, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask)
{
  std::vector<PrefixItem> prefix;
  getMeshItems_(prefix, items, entity, primitiveTypeMask);
 
  //if (auto * sceneComp = entity->getComponent<SceneComponent>(); sceneComp) {
  //  for (auto & child : sceneComp->children) {
  //    getMeshItems(context, items, child.get(), primitiveTypeMask);
  //  }
  //}
  //if (auto * meshComp = entity->getComponent<MeshComponent>(); meshComp && meshComp->meshHandle) {
  //  if (((1 << meshComp->meshHandle->primitiveType) & primitiveTypeMask) != 0) {
  //    if (auto * meshRenderComp = entity->getComponent<MeshRenderComponent>(); meshRenderComp) {
  //      items.emplace_back(MeshItem{ meshComp,  meshRenderComp,  meshRenderComp->material.resolve(), meshRenderComp->startIndex, meshRenderComp->vertexCount });
  //    }
  //  }
  //}
}
 
void Cogs::Core::getMeshItems(Context* context, MeshItems& items, Cogs::Core::EntityIds entities, uint32_t primitiveTypeMask)
{
  std::vector<PrefixItem> prefix;
  getMeshItems_(context, prefix, items, entities, primitiveTypeMask);
 
  //for (auto & entity : entities) {
  //  getMeshItems(context, items, context->store->getEntityPtr(entity), primitiveTypeMask);;
  //}
}
 
void Cogs::Core::remapVertices(Context* /*context*/, MeshRep& rep, const std::vector<uint32_t>& unique)
{
  CpuInstrumentationScope(SCOPE_EDITOR_COMMAND, "remapVertices");
 
  Memory::MemoryBuffer tmp(unique.size() * sizeof(float) * 4);
 
  // FIXME: check for identity.
 
  if (rep.positions.size() != 0) {
    auto * P = reinterpret_cast<glm::vec3*>(tmp.data());
    for (size_t i = 0; i < unique.size(); i++) {
      P[i] = rep.positions[unique[i]];
    }
    rep.positions.resize(unique.size(), false);
    std::memcpy(rep.positions.data(), tmp.data(), rep.positions.byteSize());
  }
  if (rep.normals.size()) {
    auto * N = reinterpret_cast<glm::vec3*>(tmp.data());
    for (size_t i = 0; i < unique.size(); i++) {
      N[i] = rep.normals[unique[i]];
    }
    rep.normals.resize(unique.size(), false);
    std::memcpy(rep.normals.data(), tmp.data(), rep.normals.byteSize());
  }
  if (rep.texcoords.size()) {
    auto * T = reinterpret_cast<glm::vec2*>(tmp.data());
    for (size_t i = 0; i < unique.size(); i++) {
      T[i] = rep.texcoords[unique[i]];
    }
    rep.texcoords.resize(unique.size(), false);
    std::memcpy(rep.texcoords.data(), tmp.data(), rep.texcoords.byteSize());
  }
  if (rep.tangents.size()) {
    auto * T = reinterpret_cast<glm::vec3*>(tmp.data());
    for (size_t i = 0; i < unique.size(); i++) {
      T[i] = rep.tangents[unique[i]];
    }
    rep.tangents.resize(unique.size(), false);
    std::memcpy(rep.tangents.data(), tmp.data(), rep.tangents.byteSize());
  }
}
 
void Cogs::Core::remapIndices(Context* /*context*/, MeshRep& rep, const std::vector<uint32_t>& map)
{
  if (rep.indices.size() == 0) return;
 
  CpuInstrumentationScope(SCOPE_EDITOR_COMMAND, "remapIndices");
 
  Memory::TypedBuffer<uint32_t> tmp(rep.indices.size());
  std::memcpy(tmp.data(), rep.indices.data(), tmp.byteSize());
 
  for (size_t i = 0; i < rep.indices.size(); i++) {
    rep.indices[i] = map[tmp[i]];
  }
 
}
 
 
 
void Cogs::Core::unpackMeshItems(Context* context, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items, UnpackOptions options)
{
  CpuInstrumentationScope(SCOPE_EDITOR_COMMAND, "unpackMeshItems");
 
  originalMeshes.clear();
 
  meshes.clear();
  for (auto item : items.meshes) {
    MeshRep mesh;
 
    originalMeshes.push_back(item.mesh);
 
    auto srcMesh = item.mesh.resolve();
 
    srcMesh->copyData(mesh.positions, Cogs::ElementSemantic::Position, Cogs::DataFormat::X32Y32Z32_FLOAT);
    if (options.discardNormals == false) {
      srcMesh->copyData(mesh.normals, Cogs::ElementSemantic::Normal, Cogs::DataFormat::X32Y32Z32_FLOAT);
    }
    assert(mesh.normals.size() == 0 || mesh.normals.size() == mesh.positions.size());
 
    if (options.discardTexCoords == false) {
      srcMesh->copyData(mesh.texcoords, Cogs::ElementSemantic::TextureCoordinate, Cogs::DataFormat::X32Y32_FLOAT);
    }
    assert(mesh.texcoords.size() == 0 || mesh.texcoords.size() == mesh.positions.size());
 
    if (options.discardTangents == false) {
      srcMesh->copyData(mesh.tangents, Cogs::ElementSemantic::Tangent, Cogs::DataFormat::X32Y32Z32_FLOAT);
    }
    assert(mesh.tangents.size() == 0 || mesh.tangents.size() == mesh.positions.size());
 
    uint32_t maxVertexCount = static_cast<uint32_t>(mesh.positions.size());
    uint32_t maxIndex = std::max(uint32_t(1), maxVertexCount) - 1u;
    auto indexes = srcMesh->getIndexes();
 
    if (!indexes.empty()) {
      uint32_t maxIndexCount = static_cast<uint32_t>(indexes.size());
      uint32_t maxIndexOffset = std::max(uint32_t(1), maxIndexCount) - 1;
      uint32_t rangeOffset = std::min(maxIndexOffset, item.offset);
      uint32_t maxRangeCount = std::max(rangeOffset, maxIndexCount) - rangeOffset;
      uint32_t rangeCount = std::min(maxRangeCount, item.count);
 
      mesh.indices.resize(rangeCount, false);
      if (rangeOffset != 0 || rangeCount != maxIndexCount) {
 
        // Extract sub-range
        std::vector<uint32_t> unique;
        unique.reserve(indexes.size());
 
        std::vector<uint32_t> map(indexes.size(), ~0u);
     
        for (uint32_t i = 0; i < rangeCount; i++) {
          auto ix0 = indexes[rangeOffset + i];
          auto ix1 = map[ix0];
          if (ix1 == ~0u) {
            ix1 = static_cast<uint32_t>(unique.size());
            unique.push_back(ix0);
            map[ix0] = ix1;
          }
          mesh.indices[i] = ix1;
        }
        remapVertices(context, mesh, unique);
      }
      else {
        std::memcpy(mesh.indices.data(), indexes.data(), sizeof(uint32_t)*indexes.size());
      }
    }
    else {
      uint32_t rangeOffset = std::min(maxIndex, item.offset);
      uint32_t maxRangeCount = std::max(rangeOffset, maxVertexCount) - rangeOffset;
      uint32_t rangeCount = std::min(maxRangeCount, item.count);
 
      // Optionally restrict to sub-range.
      if (rangeCount != maxVertexCount) {
        if (rangeOffset != 0) {
          std::memmove(mesh.positions.data(), mesh.positions.data() + rangeOffset, rangeCount * 3 * sizeof(float));
          if (mesh.normals.size() != 0) std::memmove(mesh.normals.data(), mesh.normals.data() + rangeOffset, rangeCount * 3 * sizeof(float));
          if (mesh.texcoords.size() != 0) std::memmove(mesh.positions.data(), mesh.positions.data() + rangeOffset, rangeCount * 2 * sizeof(float));
          if (mesh.tangents.size() != 0) std::memmove(mesh.tangents.data(), mesh.tangents.data() + rangeOffset, rangeCount * 3 * sizeof(float));
        }
        mesh.positions.resize(rangeCount);
        if (mesh.normals.size() != 0) mesh.normals.resize(rangeCount);
        if (mesh.texcoords.size() != 0) mesh.texcoords.resize(rangeCount);
        if (mesh.tangents.size() != 0) mesh.tangents.resize(rangeCount);
      }
 
      if (options.forceIndexed) {
        mesh.indices.resize(mesh.positions.size(), false);
        for (size_t i = 0; i < mesh.indices.size(); i++) {
          mesh.indices[i] = static_cast<uint32_t>(i);
        }
 
      }
    }
    meshes.push_back(std::move(mesh));
  }
}
 
 
void Cogs::Core::packMeshItems(Context* context, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items, bool update)
{
  CpuInstrumentationScope(SCOPE_EDITOR_COMMAND, "packMeshItems");
 
  if (update) {
    std::vector<Cogs::ComponentModel::Entity*> entities(items.meshes.size());
 
    for (size_t i = 0; i < entities.size(); i++) {
      entities[i] = items.meshes[i].meshComp->getContainer();
    }
    createMeshResources(context, entities, originalMeshes, meshes);
 
#if 0
    for (size_t i = 0; i < items.meshes.size(); i++) {
      const auto & item = items.meshes[i];
      const auto & meshRep = meshes[i];
      auto * originalMesh = originalMeshes[i].resolve();
 
      if (meshRep.positions.size() == 0) {
        item.meshComp->meshHandle = MeshHandle::NoHandle;
        continue;
      }
 
      item.meshComp->meshHandle = context->meshManager->create();
      item.meshComp->setChanged();
 
      auto * newMesh = items.meshes[i].meshComp->meshHandle.resolve();
 
      newMesh->setPositions(meshRep.positions.data(), meshRep.positions.data() + meshRep.positions.size());
      if (meshRep.normals.size() != 0) {
        newMesh->setNormals(meshRep.normals.data(), meshRep.normals.data() + meshRep.normals.size());
      }
      if (meshRep.texcoords.size() != 0) {
        newMesh->setTexCoords(meshRep.texcoords.data(), meshRep.texcoords.data() + meshRep.texcoords.size());
      }
      if (meshRep.tangents.size() != 0) {
        newMesh->setTangents(meshRep.tangents.data(), meshRep.tangents.data() + meshRep.tangents.size());
      }
      if (meshRep.indices.size() != 0) {
        newMesh->setIndexData(meshRep.indices.data(), meshRep.indices.size());
      }
 
      if (originalMesh->isMeshFlagSet(MeshFlags::ClockwiseWinding)) {
        newMesh->setMeshFlag(MeshFlags::ClockwiseWinding);
      }
      else {
        newMesh->unsetMeshFlag(MeshFlags::ClockwiseWinding);
      }
      newMesh->primitiveType = originalMesh->primitiveType;
 
      item.meshRenderComp->startIndex = 0;
      item.meshRenderComp->vertexCount = ~0;
      item.meshRenderComp->setChanged();
    }
#endif
 
  }
  else if(!originalMeshes.empty()) {
    for (size_t i = 0; i < items.meshes.size(); i++) {
      const auto & item = items.meshes[i];
 
      item.meshComp->meshHandle = originalMeshes[i];
      item.meshComp->setChanged();
 
      item.meshRenderComp->startIndex = item.offset;
      item.meshRenderComp->vertexCount = item.count;
      item.meshRenderComp->setChanged();
    }
  }
}