Primitive.h

#pragma once
#include "Engine/Attribute/Attribute.h"
#include "Engine/Attribute/AttributeHandle.h"
#include "Engine/Attribute/Point.h"
#include "Engine/Attribute/Transform.h"
#include "Engine/Core/Types.h"
#include <memory>
#include <optional>
#include <string>
 
namespace enzo::geo {
 
class Primitive
{
  public:
    // Point Iterator
    struct PointOffsets
    {
        PointOffsets(Primitive& primitive) : primitive_(primitive) {}
        struct Iterator
        {
            using iterator_category = std::forward_iterator_tag;
            using difference_type = std::ptrdiff_t;
            using value_type = Offset;
 
            value_type operator*() const { return curOffset_; }
 
            Iterator(Primitive& primitive, Offset current)
                : primitive_(primitive), curOffset_(current)
            {
                skipInvalid();
            }
 
            // Prefix increment
            Iterator& operator++()
            {
                ++curOffset_;
                skipInvalid();
                return *this;
            }
 
            // Postfix increment
            Iterator operator++(int)
            {
                Iterator tmp = *this;
                ++(*this);
                return tmp;
            }
 
            friend bool operator==(const Iterator& a, const Iterator& b)
            {
                return a.curOffset_ == b.curOffset_;
            };
            friend bool operator!=(const Iterator& a, const Iterator& b)
            {
                return a.curOffset_ != b.curOffset_;
            };
 
          private:
            enzo::geo::Primitive& primitive_;
            Offset curOffset_ = 0;
            void skipInvalid()
            {
                const Offset end = primitive_.getNumPoints();
                while (curOffset_ < end && !primitive_.isValidPoint(curOffset_))
                    ++curOffset_;
            }
        };
        Iterator begin() { return Iterator(primitive_, 0); }
        Iterator end() { return Iterator(primitive_, primitive_.getNumPoints()); }
 
      private:
        enzo::geo::Primitive& primitive_;
    };
    Primitive(std::string_view path = "/prim");
    Primitive(const Primitive& other);
    Primitive& operator=(const Primitive& rhs);
    virtual ~Primitive() = default;
 
    virtual PrimType getType() const = 0;
    virtual std::shared_ptr<Primitive> clone() const = 0;
    virtual TransformClass transformType() const = 0;
    virtual void applyTransform(const Matrix4& mat, TransformClass transformClass) = 0;
    void applyTransform(const Transform& transform, TransformClass transformClass)
    {
        applyTransform(transform.getMatrix(), transformClass);
    }
    virtual bool canMerge() const { return false; }
    virtual void merge(std::shared_ptr<Primitive> other) {}
 
    virtual bool hasOwner(attr::AttributeOwner owner) const
    {
        return owner == attr::AttributeOwner::PRIMITIVE;
    }
 
    size_t getElementCount(const attr::AttributeOwner& owner) const;
 
    Offset getNumPoints() const { return getElementCount(attr::AttributeOwner::POINT); }
    virtual PointOffsets getPoints() { return PointOffsets(*this); }
    virtual bool isValidPoint(Offset offset) const { return true; }
    virtual void deletePoints(const std::vector<Offset>& pointOffsets) {}
 
    virtual void defragment() {}
 
    std::shared_ptr<attr::Attribute> addAttribute(
        attr::AttributeOwner owner,
        std::string name,
        attr::AttributeType type,
        bool intrinsic = false,
        bool isInternal = false
    );
 
    std::shared_ptr<attr::Attribute> tryAddAttribute(
        attr::AttributeOwner owner,
        std::string name,
        attr::AttributeType type,
        bool intrinsic = false,
        bool isInternal = false
    );
 
    template <typename T>
    attr::AttributeHandle<T> addAttribute(
        attr::AttributeOwner owner,
        std::string name,
        bool intrinsic = false,
        bool isInternal = false
    )
    {
        return attr::AttributeHandle<T>(addAttribute(
            owner, std::move(name), attr::getAttributeType<T>(), intrinsic, isInternal
        ));
    }
 
    template <typename T>
    std::optional<attr::AttributeHandle<T>> tryAddAttribute(
        attr::AttributeOwner owner,
        std::string name,
        bool intrinsic = false,
        bool isInternal = false
    )
    {
        const std::shared_ptr<attr::Attribute> attribute = tryAddAttribute(
            owner,
            std::move(name),
            attr::getAttributeType<T>(),
            intrinsic,
            isInternal
        );
        if (!attribute) return std::nullopt;
        return attr::AttributeHandle<T>(attribute);
    }
 
    std::shared_ptr<attr::Attribute>
    getAttribByName(attr::AttributeOwner owner, std::string_view name, bool includeIntrinsics = false);
    std::shared_ptr<const attr::Attribute> getAttribByName(
        attr::AttributeOwner owner,
        std::string_view name,
        bool includeIntrinsics = false
    ) const;
    const size_t getNumAttributes(const attr::AttributeOwner owner) const;
    std::weak_ptr<const attr::Attribute>
    getAttributeByIndex(attr::AttributeOwner owner, unsigned int index) const;
    std::vector<std::shared_ptr<const attr::Attribute>>
    getAttributes(attr::AttributeOwner owner, bool includeIntrinsics = false) const;
    bool attributeExists(attr::AttributeOwner owner, std::string_view name);
 
    attr::AttributeHandleBool addGroup(attr::AttributeOwner owner, std::string name);
    void addToGroup(
        attr::AttributeOwner owner,
        const std::string& name,
        const std::vector<Offset>& offsets
    );
    std::shared_ptr<attr::Attribute>
    getGroupByName(attr::AttributeOwner owner, const std::string& name) const;
    size_t getNumGroups(attr::AttributeOwner owner) const;
    std::weak_ptr<const attr::Attribute>
    getGroupByIndex(attr::AttributeOwner owner, unsigned int index) const;
    std::vector<std::shared_ptr<const attr::Attribute>> getGroups(attr::AttributeOwner owner) const;
 
    void addAttributesFrom(const Primitive& source, attr::AttributeOwner owner);
 
    attr::AttributeHandleBool addPointGroup(std::string name)
    {
        return addGroup(attr::AttributeOwner::POINT, std::move(name));
    }
    attr::AttributeHandleBool addPrimitiveGroup(std::string name)
    {
        return addGroup(attr::AttributeOwner::PRIMITIVE, std::move(name));
    }
    void addToPointGroup(const std::string& name, const std::vector<Offset>& offsets)
    {
        addToGroup(attr::AttributeOwner::POINT, name, offsets);
    }
    void addToPrimitiveGroup(const std::string& name, const std::vector<Offset>& offsets)
    {
        addToGroup(attr::AttributeOwner::PRIMITIVE, name, offsets);
    }
 
    String getPath() const { return path_; };
    void setPath(const String& path) { path_ = path; };
 
  protected:
    virtual attr::attribVector& getAttributeStore(const attr::AttributeOwner& owner);
    virtual const attr::attribVector& getAttributeStore(const attr::AttributeOwner& owner) const;
    virtual attr::attribVector& getGroupStore(const attr::AttributeOwner& owner);
    virtual const attr::attribVector& getGroupStore(const attr::AttributeOwner& owner) const;
    attr::attribVector deepCopyAttributes(attr::attribVector source);
 
    std::string path_ = "/prim";
    attr::attribVector pointAttributes_;
    attr::attribVector primitiveAttributes_;
    attr::attribVector pointGroups_;
    attr::attribVector primitiveGroups_;
};
 
using PrimPtr = std::shared_ptr<Primitive>;
} // namespace enzo::geo