CADAttributeMap.h

#pragma once
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
 
#include <algorithm>
#include <span>
#include <vector>
 
namespace Cogs::Editor
{
  enum class AttributeMapPixelState : uint8_t {
    Default = 0,
    Selected = 1,
    Highlighted = 2,
    Hidden = 3,
    SelectedAndHighlighted = 4,
    Unused00 = 5,
    Unused01 = 6,
    Unused02 = 7,
    Unused03 = 8,
    Unused04 = 9,
    Unused05 = 10,
    Unused06 = 11,
    Unused07 = 12,
    Unused08 = 13,
    Unused09 = 14,
    Unused10 = 15,
    Unused11 = 16,
    Unused12 = 17,
    Unused13 = 18,
    Unused14 = 19,
    Unused15 = 20,
    Unused16 = 21,
    Unused17 = 22,
    Unused18 = 23,
    Unused19 = 24,
    Unused20 = 25,
    Unused21 = 26,
    Unused22 = 27,
    Unused23 = 28,
    Unused24 = 29,
    Unused25 = 30,
    Unused26 = 31,
    Unused27 = 32,
    Unused28 = 33,
    Unused29 = 34,
    Unused30 = 35,
    Unused31 = 36,
    Unused32 = 37,
    Unused33 = 38,
    Unused34 = 39,
    Unused35 = 40,
    Unused36 = 41,
    Unused37 = 42,
    Unused38 = 43,
    Unused39 = 44,
    Unused40 = 45,
    Unused41 = 46,
    Unused42 = 47,
    Unused43 = 48,
    Unused44 = 49,
    Unused45 = 50,
    Unused46 = 51,
    Unused47 = 52,
    Unused48 = 53,
    Unused49 = 54,
    Unused50 = 55,
    Unused51 = 56,
    Unused52 = 57,
    Unused53 = 58,
    Unused54 = 59,
    Unused55 = 60,
    Unused56 = 61,
    Unused57 = 62,
    Unused58 = 63,
  };
 
  enum class AttributeMapPixelTransparency : uint8_t {
    Off = 0,
    Low = 1,
    Medium = 2,
    High = 3,
  };
 
  struct AttributeMapAlpha {
    AttributeMapPixelTransparency transparency;
    AttributeMapPixelState state;
  };
 
 
  class CADAttributeMap final {
  public:
    explicit CADAttributeMap(bool powerOfTwoTextures = true)
      : powerOfTwoTextures(powerOfTwoTextures)
    {
    }
    CADAttributeMap(const CADAttributeMap&) = delete;
    CADAttributeMap& operator=(const CADAttributeMap&) = delete;
 
    std::span<const uint8_t> getAttributeMap() const { return this->_attributeMap; }
 
    glm::uvec2 getAttrSize() const { return this->_attrSize; }
 
    void init(glm::uvec3 color, AttributeMapAlpha alpha)
    {
      uint32_t size = this->_attrSize.x * this->_attrSize.y;
      for (uint32_t i = 0; i < size; i++) {
        this->setColor(i, color);
        this->setAlpha(i, alpha);
      }
    }
 
    bool growToContainIndex(size_t index)
    {
      if (this->isValidIndex(index)) {
        return false;
      }
 
      const glm::uvec2 newSize = CADAttributeMap::getAttributeSize(index + 1, powerOfTwoTextures);
      this->resize(newSize);
      return true;
    }
 
    void setColor(size_t index, glm::uvec3 color)
    {
      const size_t offset = index * 4;
      this->_attributeMap[offset + 0] = uint8_t(color[0]);
      this->_attributeMap[offset + 1] = uint8_t(color[1]);
      this->_attributeMap[offset + 2] = uint8_t(color[2]);
    }
 
    glm::vec3 getColor(size_t index) const {
      const size_t offset = index * 4;
      return glm::vec3(this->_attributeMap[offset + 0], this->_attributeMap[offset + 1], this->_attributeMap[offset + 2]);
    }
 
    void setAlpha(size_t index, AttributeMapAlpha alpha)
    {
      this->_attributeMap[index * 4 + 3] = CADAttributeMap::encodeAlpha(alpha);
    }
 
    AttributeMapAlpha getAlpha(size_t index)
    {
      return CADAttributeMap::decodeAlpha(this->_attributeMap[index * 4 + 3]);
    }
 
 
    bool isValidIndex(size_t index) const
    {
      return index * 4U < this->_attributeMap.size();
    }
 
    uint8_t getAttribute(size_t index, size_t attrOffset)
    {
      return this->_attributeMap[index * 4 + attrOffset];
    }
 
    void setAttribute(size_t index, size_t attrOffset, uint8_t attribute)
    {
      this->_attributeMap[index * 4 + attrOffset] = attribute;
    }
 
    void resize(glm::uvec2 attrSize)
    {
      // Data stored in texture. Avoid empty texture.
      attrSize.x = std::max(2U, attrSize.x);
      attrSize.y = std::max(2U, attrSize.y);
 
      if (attrSize != this->_attrSize) {
        glm::uvec2 oldSize = this->_attrSize;
        this->_attrSize = attrSize;
        this->_attributeMap.resize(this->_attrSize.x * this->_attrSize.y * 4);
 
        if (attrSize.x > oldSize.x || attrSize.y > oldSize.y) {
          // Fill rest with defaults:
          uint32_t oldMaxIndex = oldSize.x * oldSize.y;
          uint32_t newMaxSize = attrSize.x * attrSize.y;
          for (uint32_t i = oldMaxIndex; i < newMaxSize; ++i) {
            this->setColor(i, defaultColor);
            this->setAlpha(i, defaultAlpha);
          }
        }
      }
    }
 
    static glm::uvec2 getAttributeSize(size_t tagCount, bool powerOfTwo)
    {
      static constexpr uint32_t MinTexSize = 8;
      uint32_t sizeX = MinTexSize;
      while (sizeX * sizeX < tagCount) {
        sizeX = sizeX * 2;
      }
 
      if (powerOfTwo) {
        return { sizeX, sizeX };
      }
      else {
        uint32_t sizeY = MinTexSize;
        while (sizeX * sizeY < tagCount) {
          sizeY = sizeY * 2;
        }
        return { sizeX, sizeY };
      }
    }
 
    AttributeMapAlpha getDefaultAlpha() const
    {
      return defaultAlpha;
    }
 
    void setDefaultAlpha(AttributeMapAlpha alpha)
    {
      defaultAlpha = alpha;
    }
 
    glm::uvec3 getDefaultColor() const { return defaultColor; }
 
    void setDefaultColor(glm::uvec3 color)
    {
      defaultColor = color;
    }
 
    static constexpr uint8_t encodeAlpha(AttributeMapAlpha data) noexcept
    {
      // Bits 0-1 cover transparency
      // Bits 2-7 cover state
      // This works by first adding the 6 bits for the state, then shifting these bits to the left by 2.
      // Secondly, it adds the two bits for transparency again with a bitwise OR '|' operator.
      // This means that if the state has a value higher than 31 (00111111), it will fail, as the two rightmost bits will be discarded.
      // It also means that if transparency has a value higher than 3 (00000011), it will affect the state.
      const uint8_t bits = (uint8_t(data.state) << 2) | uint8_t(data.transparency);
      return bits;
    }
 
    static constexpr AttributeMapAlpha decodeAlpha(uint8_t alpha)
    {
      // Bits 0-1 cover transparency
      // Bits 2-7 cover state
      AttributeMapPixelTransparency transparency = AttributeMapPixelTransparency(alpha & 3U); // bitwise AND with 00000011 to only retain bits 0-1
      AttributeMapPixelState state = AttributeMapPixelState(alpha >> 2U); // shift 2 to the right to extract the value of bits 2-7
      return { transparency, state };
    }
 
  private:
    bool powerOfTwoTextures = true;
    glm::uvec2 _attrSize = {};
    std::vector<uint8_t> _attributeMap;
    glm::uvec3 defaultColor = { 0,0,0 };
    AttributeMapAlpha defaultAlpha = { AttributeMapPixelTransparency::Off, AttributeMapPixelState::Default, };
  };
}