Attribute.h

#pragma once
#include "Engine/Core/Types.h"
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace enzo {
namespace attr {
template <typename T> using StoreContainer = std::vector<T>;
 
template <typename T> class AttributeHandle;
 
class Attribute
{
  public:
    Attribute(
        std::string name,
        attr::AttributeType type,
        bool intrinsic = false,
        bool isInternal = false
    );
    Attribute(const Attribute& other);
    AttributeType getType() const;
    const std::string& getName() const;
 
    Vector3 getVector3(Offset offset) const;
    Matrix4 getMatrix4(Offset offset) const;
    size_t getSize() const;
    unsigned int getTypeSize() const;
 
    bool isIntrinsic() const;
 
    bool isInternal() const;
 
    void resize(size_t size);
 
    void compact(const std::vector<bool>& keep);
 
    void reverse(Offset start, Offset count);
 
    template <typename T> friend class AttributeHandle;
    template <typename T> friend class AttributeHandleRO;
 
  private:
    bool internal_ = false;
    bool intrinsic_ = false;
 
    attr::AttributeType type_;
    unsigned int typeSize_ = 1;
 
    std::string name_;
 
    using StoreVariant = std::variant<
        std::shared_ptr<StoreContainer<intT>>,
        std::shared_ptr<StoreContainer<floatT>>,
        std::shared_ptr<StoreContainer<enzo::Vector3>>,
        std::shared_ptr<StoreContainer<enzo::boolT>>,
        std::shared_ptr<StoreContainer<enzo::Matrix4>>>;
    StoreVariant store_;
};
 
using attribVector = std::vector<std::shared_ptr<attr::Attribute>>;
} // namespace attr
} // namespace enzo