Attribute.h

#pragma once
#include "Engine/Types.h"
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace enzo {
namespace ga {
template <typename T> using StoreContainer = std::vector<T>;
 
template <typename T> class AttributeHandle;
 
class Attribute {
  public:
    Attribute(std::string name, ga::AttributeType type, bool intrinsic = false);
    Attribute(const Attribute &other);
    AttributeType getType() const;
    std::string getName() const;
 
    bt::Vector3 getVector3(Offset offset) const;
    bt::Matrix4 getMatrix4(Offset offset) const;
    size_t getSize() const;
    unsigned int getTypeSize() const;
 
    bool isIntrinsic() const;
 
    void resize(size_t size);
 
    template <typename T> friend class AttributeHandle;
    template <typename T> friend class AttributeHandleRO;
 
  private:
    // private attributes are attributes that are hidden from the user
    // for internal use
    // bool private_=false;
    // hidden attributes are user accessible attributes that the user may
    // or may want to use
    // bool hidden_=false;
    // allows the user to read the attribute but not modify it
    // bool readOnly_=false;
    bool intrinsic_ = false;
 
    ga::AttributeType type_;
    unsigned int typeSize_ = 1;
 
    std::string name_;
 
    // void* data_;
 
    // data stores
    std::shared_ptr<StoreContainer<bt::intT>> intStore_;
    std::shared_ptr<StoreContainer<bt::floatT>> floatStore_;
    std::shared_ptr<StoreContainer<enzo::bt::Vector3>> vector3Store_;
    std::shared_ptr<StoreContainer<enzo::bt::boolT>> boolStore_;
    std::shared_ptr<StoreContainer<enzo::bt::Matrix4>> matrix4Store_;
};
 
using attribVector = std::vector<std::shared_ptr<ga::Attribute>>;
} // namespace ga
} // namespace enzo