AssetDefinition.h

#pragma once
 
#include "EntityPtr.h"
#include "EntityDefinition.h"
 
#include "Rendering/TextureData.h"
 
#include "Generators/ImageType.h"
 
#include "ResourceBase.h"
#include "ResourceFlags.h"
 
#include "Services/PropertiesManager.h"
 
namespace Cogs::Core
{
  struct SceneEntityFlags
  {
    enum EFlags
    {
      None = 0,
      ParentIsName = 1 << 0,
      Sequence = 1 << 1,
      LodGroup = 1 << 2,
      Asset = 1 << 3,
      Model = 1 << 4,
 
      Children = 1 << 5,
      Empty = 1 << 6,
 
      Error = 1 << 16,
      Last = Error,
    };
  };
 
  struct SceneEntityDefinition
  {
    static constexpr uint32_t NoIndex = static_cast<uint32_t>(-1);
 
    uint32_t index;
    uint32_t nameIndex;
    uint32_t parentIndex;
    
    union
    {
      StringRef type;
      
      struct
      {
        uint32_t index;
        uint32_t flags;
        uint32_t material;
      } asset;
 
      struct
      {
        uint32_t index;
        uint16_t flags;
        uint16_t depth;
        uint32_t part;
        uint32_t size; // in KB
      } model;
 
      struct
      {
        uint32_t numLods;
      } lod;
    };
 
    uint32_t firstField;
    uint32_t numFields;
 
    uint32_t firstProperty;
    uint32_t numProperties;
 
    uint32_t firstChild;              // First child
    uint32_t numChildren;
 
    //      +------------------------------------firstChild--+
    //      |                                                |
    //      V                                                |
    // Lod_0_entity_0 ---parent-------------+--+--+--+---> Parent
    //      |        \                      |  |  |  |
    //   nextSibling  nextLodSibling --|    |  |  |  |
    //      |                               |  |  |  |
    //      V                               |  |  |  |
    // Lod_1_entity_0 ---parent-------------+  |  |  |
    //      |        \                         |  |  |
    //   nextSibling  nextLodSibling --|       |  |  |
    //      |                                  |  |  |
    //      V                                  |  |  |
    // Lod_2_entity_0 --parent-----------------+  |  |
    //      |        \                            |  |
    //   nextSibling  nextLodSibling              |  |
    //      |         /                           |  |
    //      V        V                            |  |
    // Lod_2_entity_1 ---parent-------------------+  |
    //      |        \                               |
    //   nextSibling  nextLodSibling --|             |
    //      |                                        |
    //      V                                        |
    // Lod_3_entity_0 ---parent----------------------+
    //      |        \
    //   nextSibling  nextLodSibling --|
    //      |
    //      +--|
 
    uint32_t nextSibling;             
    uint32_t nextLodSibling;          
 
    uint32_t objectId;
    uint32_t flags = 0;               
 
    bool isTrivial() const { return !numFields && !numProperties && !numChildren; }
 
    void setSequence() { flags |= SceneEntityFlags::Sequence; }
    bool isSequence() const { return flags & SceneEntityFlags::Sequence; }
    bool isParentedByName() const { return flags & SceneEntityFlags::ParentIsName; }
 
    void setEmpty() { flags |= SceneEntityFlags::Empty; }
    bool isEmpty() const { return flags & SceneEntityFlags::Empty; }
 
    void setLodGroup() { flags |= SceneEntityFlags::LodGroup; }
    bool isLodGroup() const { return flags & SceneEntityFlags::LodGroup; }
 
    void setAsset() { flags |= SceneEntityFlags::Asset; }
    bool isAsset() const { return flags & SceneEntityFlags::Asset; }
 
    void setModel() { flags |= SceneEntityFlags::Model; }
    bool isModel() const { return flags & SceneEntityFlags::Model; }
 
    bool isAssetModelOrLodGroup() const { return flags & (SceneEntityFlags::Asset | SceneEntityFlags::Model | SceneEntityFlags::LodGroup); }
 
    void setChildren() { flags |= SceneEntityFlags::Children; }
    bool hasChildren() const { return flags & SceneEntityFlags::Children; }
 
    void setError() { flags |= SceneEntityFlags::Error; }
    bool hasError() const { return flags & SceneEntityFlags::Error; }
 
    StringView getTypeName() const
    {
      if (isAsset()) return "Asset";
      else if (isModel()) return "Model";
      else if (isLodGroup()) return "LodGroup";
      else return Strings::get(type);
    }
  };
 
  constexpr uint32_t NoParentEntity = static_cast<uint32_t>(-1);
 
  struct SceneDefinition
  {
    SceneDefinition() :
      entities(MemBlockType::AssetDefintion),
      properties(MemBlockType::AssetProperties)
    {}
 
    uint32_t createEntity(uint32_t parent)
    {
      const size_t index = entities.size();
      SceneEntityDefinition& entity = entities.grow();
      entity = SceneEntityDefinition{ 
        .index = static_cast<uint32_t>(index),
        .nameIndex = 0,
        .parentIndex = parent,
        .type = NoString,
 
        .firstField = 0,
        .numFields = 0,
 
        .firstProperty = 0,
        .numProperties = 0,
 
        .firstChild = 0,
        .numChildren = 0,
 
        .nextSibling = static_cast<uint32_t>(-1),
        .nextLodSibling = static_cast<uint32_t>(-1),
        .objectId = static_cast<uint32_t>(-1),
        .flags = 0
      };
      return entity.index;
    }
 
    PropertyRange getProperties(const SceneEntityDefinition & e) const
    {
      PropertyRange range;
      range.store = &properties;
      range.firstProperty = e.firstProperty;
      range.numProperties = e.numProperties;
      return range;
    }
 
    SceneEntityDefinition & operator[](size_t index)
    {
      return entities[index];
    }
 
    const SceneEntityDefinition & operator[](size_t index) const
    {
      return entities[index];
    }
 
    uint32_t getChild(uint32_t firstChild, uint32_t childIndex) const
    {
      if (childIndex == static_cast<uint32_t>(-1)) return static_cast<uint32_t>(-1);
      if (firstChild >= entities.size()) return static_cast<uint32_t>(-1);
 
      auto childDefinition = &entities[firstChild];
 
      for (uint32_t i = 0; i < childIndex; ++i) {
        if (childDefinition->nextSibling >= entities.size()) return static_cast<uint32_t>(-1);
 
        childDefinition = &entities[childDefinition->nextSibling];
      }
 
      return childDefinition->index;
    }
 
    uint32_t numTopLevelEntities = 0;
    uint32_t numLodGroups = 0;
 
    Memory::TypedBuffer<SceneEntityDefinition> entities;
 
    PropertyStore properties;
    std::vector<FieldValue> fieldValues;
  };
 
  struct ResourceDefinition
  {
    std::string name;
    std::string reference;
    ResourceTypes type = ResourceTypes::Unknown;
    std::string source;
 
    // Material
    std::string material;
    std::string permutation;
    std::unordered_map<std::string, std::string> options;
    std::unordered_map<std::string, std::string> variants;
    std::unordered_map<std::string, FieldValue> properties;
 
    // Texture
    TextureDescription textureDescription;
    bool textureGenerator = false;
    ImageDefinition imageDefinition;
    TextureLoadFlags loadFlags = TextureLoadFlags::None;
  };
 
  using TextureDefinition = ResourceDefinition;
  using MaterialInstanceDefinition = ResourceDefinition;
 
  using ResourcesDefinition = std::vector<ResourceDefinition>;
 
  struct AssetDefinition
  {
    std::string name;
 
    SceneDefinition scene;
    ResourcesDefinition resources;
  };
}