Model.h

#pragma once
 
#include "Services/PropertiesManager.h"
 
#include "ResourceBase.h"
 
#include "Skeleton.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  struct Mesh;
 
  const size_t NoParentPart = uint32_t(-1);
  const uint32_t NoIndex = uint32_t(-1);
 
  const glm::mat4 ModelPartIdentity = glm::mat4(1.0f);
 
  struct ModelPart
  {
    ModelPart() = default;
    ModelPart(ModelPart & modelPart) = delete;
    ModelPart(ModelPart && modelPart) = default;
 
    uint32_t parentIndex = NoParentPart;
    uint32_t boundsIndex = NoIndex;
    uint32_t meshIndex = NoIndex;
    uint32_t materialIndex = NoIndex;
 
    uint32_t startIndex = 0;
    uint32_t vertexCount = static_cast<uint32_t>(-1);
 
    uint32_t nameIndex = NoIndex;
    uint32_t transformIndex = NoIndex;
 
    uint32_t firstProperty = 0;
    uint32_t numProperties = 0;
 
    uint32_t primitiveType = static_cast<uint32_t>(-1);
    uint32_t pad;
  };
 
  struct Model : public ResourceBase
  {
    Model() = default;
 
    Model(const Model & other) = delete;
 
    Model(Model && other) noexcept = default;
 
    Model & operator=(Model && other) noexcept = default;
 
    void setPartName(ModelPart & part, const StringView & name)
    {
      part.nameIndex = properties.addProperty("n", name);
    }
 
    StringView getPartName(const ModelPart & part) const
    {
      if (part.nameIndex == NoIndex) return {};
      return properties.getString(part.nameIndex);
    }
 
    void setPartTransform(ModelPart & part, const glm::mat4 & t)
    {
      glm::mat4 tt = t;
      auto values = std::span(glm::value_ptr(tt), 16);
      part.transformIndex = properties.addProperty("t", values);
    }
 
    const glm::mat4 & getPartTransform(const ModelPart & part) const
    {
      if (part.transformIndex != NoIndex) {
        auto values = properties.getFloatArray(part.transformIndex);
        return *reinterpret_cast<const glm::mat4 *>(values.data());
      }
 
      return ModelPartIdentity;
    }
 
    std::vector<MeshHandle> meshes;
    std::vector<MaterialInstanceHandle> materials;
 
    std::vector<Geometry::BoundingBox> bounds;
    std::vector<ModelPart> parts;
 
    PropertyStore properties;
 
    // 2019-01-24 chrisdy: This skeleton appears not to be used outside importers/exporters,
    // not even by the model instantiation code. The animation & rendering code uses the one
    // stored inside the animation.
    Skeleton skeleton;
 
    AnimationHandle animation;
  };
}