CommandHelpers.h

#pragma once
 
#include "EditorExtension.h"
 
#include "Components/Core/SceneComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/TransformComponent.h"
 
#include "EditorState.h"
 
#include "Foundation/ComponentModel/ComponentPtr.h"
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <glm/glm.hpp>
 
#include <vector>
 
namespace Cogs::ComponentModel
{
  class Entity;
}
 
namespace Cogs::Core
{
  class Context;
  class MeshComponent;
  class TransformComponent;
  class MeshRenderComponent;
  struct MaterialInstance;
 
  struct MeshRep {
    Memory::TypedBuffer<glm::vec3> positions;
    Memory::TypedBuffer<glm::vec3> normals;
    Memory::TypedBuffer<glm::vec2> texcoords;
    Memory::TypedBuffer<glm::vec3> tangents;
    Memory::TypedBuffer<uint32_t> indices;
 
    MeshRep() = default;
 
    MeshRep(const MeshRep&) = delete;
    MeshRep& operator=(const MeshRep&) = delete;
 
    MeshRep(MeshRep&&) = default;
    MeshRep& operator=(MeshRep&&) = default;
 
    void copy(const MeshRep & other);
  };
  typedef std::vector<MeshRep> MeshReps;
 
  struct UnpackOptions
  {
    bool discardNormals = false;
    bool discardTexCoords = false;
    bool discardTangents = false;
    bool forceIndexed = false;
  };
 
  struct TransformItem
  {
    Cogs::ComponentModel::ComponentPtr<TransformComponent> trComp;
    uint32_t parent = ~0u;
  };
 
  struct MeshItem
  {
    MeshHandle mesh;
    Cogs::ComponentModel::ComponentPtr<MeshComponent> meshComp;
    Cogs::ComponentModel::ComponentPtr<MeshRenderComponent> meshRenderComp;
    MaterialInstance* matlInst = nullptr;
    uint32_t offset;
    uint32_t count;
    uint32_t parent = ~0u;
  };
 
  struct MeshItems {
    std::vector<TransformItem> transforms;
    std::vector<MeshItem> meshes;
  };
 
  COGSCORE_EDITOR_API void getMeshItems(Context* context, MeshItems& items, EntityPtr entity, uint32_t primitiveTypeMask = ~0u);
 
  COGSCORE_EDITOR_API void getMeshItems(Context* context, MeshItems& items, Cogs::Core::EntityIds entities, uint32_t primitiveTypeMask = ~0u);
 
  COGSCORE_EDITOR_API void remapVertices(Context* context, MeshRep& rep, const std::vector<uint32_t>& unique);
 
  COGSCORE_EDITOR_API void remapIndices(Context* context, MeshRep& rep, const std::vector<uint32_t>& map);
 
  COGSCORE_EDITOR_API void unpackMeshItems(Context* context, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items, UnpackOptions options = UnpackOptions());
 
  COGSCORE_EDITOR_API void packMeshItems(Context* context, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items, bool update = true);
 
  COGSCORE_EDITOR_API EntityPtr createNewMeshItems(Context* context, Cogs::ComponentModel::Entity* parent, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items);
 
  COGSCORE_EDITOR_API EntityPtr createAsSingleMeshItem(Context* context, Cogs::ComponentModel::Entity* parent, std::vector<MeshHandle>& originalMeshes, MeshReps& meshes, MeshItems& items);
}