CADAssetTexture.h

#pragma once
 
#include "CADAttributeMap.h"
 
#include "Context.h"
#include "Bridge/BridgeApi.h"
#include "Bridge/ResourceFunctions.h"
#include "Resources/ResourceFlags.h"
#include "Resources/Texture.h"
 
#include "Cogs.Rendering/Rendering/DataFormat.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
 
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace Cogs::Editor
{
  struct ITagEntry {
    std::string_view name;
 
    int parentId;
 
    std::span<const int> children;
  };
 
  class TagContainer {
 
    struct TagEntry {
      size_t nameOffset;
      size_t nameLength;
 
      int parentId;
 
      size_t childrenOffset;
      size_t childrenLength;
    };
 
  public:
    void clear()
    {
      tagsTxtEntries.clear();
      allNames.clear();
      allChildren.clear();
    }
 
    void addTag(std::string_view name, int parentId, std::span<const int> children)
    {
      TagEntry& tag = tagsTxtEntries.emplace_back();
      tag.nameOffset = allNames.size();
      allNames += name;
      tag.nameLength = allNames.size() - tag.nameOffset;
      tag.parentId = parentId;
      tag.childrenOffset = allChildren.size();
      allChildren.insert(allChildren.end(), children.begin(), children.end());
      tag.childrenLength = allChildren.size() - tag.childrenOffset;
    }
 
    size_t size() const { return tagsTxtEntries.size(); }
 
    ITagEntry getTagAt(size_t index) const
    {
      const TagEntry& e = this->tagsTxtEntries[index];
      return ITagEntry{
        .name = std::string_view(allNames.data() + e.nameOffset, e.nameLength),
        .parentId = e.parentId,
        .children = std::span<const int>(allChildren.data() + e.childrenOffset, e.childrenLength)
      };
    }
 
  private:
    std::vector<TagEntry> tagsTxtEntries;
    std::string allNames;
    std::vector<int> allChildren;
  };
 
  class CADAssetTexture final {
  public:
    CADAssetTexture(Cogs::Core::Context* context, bool powerOfTwoTextures = true)
      : context(context), _attributeMap(powerOfTwoTextures)
 
    {
      textureId = ::getNextTextureId(context);
      currentAttrSize = { 2, 2 };
      _attributeMap.resize(currentAttrSize);
      updateAttributeMap();
    }
 
    CADAssetTexture(const CADAssetTexture&) = delete;
 
    ~CADAssetTexture()
    {
      release();
    }
 
    CADAssetTexture& operator=(const CADAssetTexture&) = delete;
 
    ResourceId getTextureId() const { return this->textureId; }
 
    CADAttributeMap& getAttributeMap() { return this->_attributeMap; }
 
    glm::uvec2 getAttrSize() const { return this->_attributeMap.getAttrSize(); }
 
    size_t getTagCount() const { return this->tagsTxtEntries.size(); }
 
    ITagEntry getTagAt(size_t index) const
    {
      return tagsTxtEntries.getTagAt(index);
    }
 
    bool empty() const { return this->tagsTxtEntries.size() == 0U; }
 
    void showAll() {
      this->_attributeMap.init(this->_attributeMap.getDefaultColor(), this->_attributeMap.getDefaultAlpha());
      this->updateAttributeMap();
    }
 
    void updateColorById(size_t index, glm::uvec3 color, bool recurse)
    {
      this->_attributeMap.growToContainIndex(index);
      this->_attributeMap.setColor(index, color);
 
      if (recurse && this->getTagCount() > index) {
        const ITagEntry tag = this->getTagAt(index);
        for (const int childIndex : tag.children) {
          this->updateColorById(childIndex, color, recurse);
        }
      }
    }
 
    void updateAlphaById(size_t index, AttributeMapAlpha alpha, bool recurse)
    {
      this->_attributeMap.growToContainIndex(index);
      this->_attributeMap.setAlpha(index, alpha);
 
      if (recurse && this->getTagCount() > index) {
        const ITagEntry tag = this->getTagAt(index);
        for (const int childIndex : tag.children) {
          this->updateAlphaById(childIndex, alpha, recurse);
        }
      }
    }
 
    bool updateAttributeMap()
    {
      bool resized = currentAttrSize != _attributeMap.getAttrSize();
      currentAttrSize = _attributeMap.getAttrSize();
      ::loadTextureResource(context, textureId, _attributeMap.getAttributeMap().data(),
        int(currentAttrSize.x), int(currentAttrSize.y),
        int(Cogs::TextureFormat::R8G8B8A8_UNORM), 0,
        int(Cogs::Core::TextureLoadFlags::LinearColorSpace | Cogs::Core::TextureLoadFlags::NoMipMaps));
 
      return resized;
    }
 
    void addTag(std::string_view name, int parentId, std::span<const int> children)
    {
      tagsTxtEntries.addTag(name, parentId, children);
    }
 
  private:
    void release()
    {
      if (textureId != Cogs::Core::NoResourceId) {
        ::releaseTexture(context, textureId);
        textureId = Cogs::Core::NoResourceId;
      }
    }
 
  private:
    Cogs::Core::Context* context;
    CADAttributeMap _attributeMap;
    TagContainer tagsTxtEntries;
    ResourceId textureId;
    glm::uvec2 currentAttrSize;
  };
 
}