Types.h

Go to the documentation of this file.

 
#pragma once
#include <Eigen/Dense>
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <type_traits>
#include <vector>
 
namespace enzo {
 
namespace attr {
enum class AttributeOwner
{
    POINT,
    VERTEX,
    FACE,
    PRIMITIVE
};
enum class AttributeType
{
    intT,
    floatT,
    listT,
    vectorT,
    boolT,
    matrixT,
};
using AttrType = AttributeType;
using AttrOwner = AttributeOwner;
 
inline std::vector<AttributeOwner> getAllOwners()
{
    return {AttributeOwner::POINT,
            AttributeOwner::VERTEX,
            AttributeOwner::FACE,
            AttributeOwner::PRIMITIVE};
}
 
inline std::vector<AttributeType> getAllTypes()
{
    return {AttributeType::intT,
            AttributeType::floatT,
            AttributeType::listT,
            AttributeType::vectorT,
            AttributeType::boolT,
            AttributeType::matrixT};
}
 
inline std::string getOwnerName(AttributeOwner owner)
{
    switch (owner)
    {
    case AttributeOwner::POINT:
        return "point";
    case AttributeOwner::VERTEX:
        return "vertex";
    case AttributeOwner::FACE:
        return "face";
    case AttributeOwner::PRIMITIVE:
        return "primitive";
    }
    return "";
}
 
inline std::string getTypeName(AttributeType type)
{
    switch (type)
    {
    case AttributeType::intT:
        return "int";
    case AttributeType::floatT:
        return "float";
    case AttributeType::listT:
        return "list";
    case AttributeType::vectorT:
        return "vector";
    case AttributeType::boolT:
        return "bool";
    case AttributeType::matrixT:
        return "matrix";
    }
    return "";
}
 
inline std::optional<AttributeOwner> getOwner(const std::string& name)
{
    for (AttributeOwner owner : getAllOwners())
        if (getOwnerName(owner) == name) return owner;
    return std::nullopt;
}
 
inline std::optional<AttributeType> getType(const std::string& name)
{
    for (AttributeType type : getAllTypes())
        if (getTypeName(type) == name) return type;
    return std::nullopt;
}
} // namespace attr
namespace geo {
enum class PrimType
{
    MESH,
    CAMERA
};
}
 
enum class TransformClass : uint8_t
{
    NONE = 0,
    POINT = 1,
    PRIMITIVE = 2,
    POINT_PRIORITY = 3 // POINT | PRIMITIVE
};
 
// Enum class doesn't support bitwise ops natively. These allow bit-testing
// e.g. (transformClass & TransformClass::POINT) != TransformClass::NONE
inline TransformClass operator|(TransformClass a, TransformClass b)
{
    return static_cast<TransformClass>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
inline TransformClass operator&(TransformClass a, TransformClass b)
{
    return static_cast<TransformClass>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
}
// e.g. hasFlag(prim.transformType(), TransformClass::POINT)
inline bool hasFlag(TransformClass value, TransformClass flag)
{
    return (value & flag) != TransformClass::NONE;
}
 
// Basic types
using floatT = float;
using intT = int64_t;
using boolT = bool;
using Vector2 = Eigen::Vector2f;
using Vector3 = Eigen::Vector3f;
using Vector4 = Eigen::Vector4f;
using Matrix3 = Eigen::Matrix3f;
using Matrix4 = Eigen::Matrix4f;
using String = std::string;
using Index = size_t;
using Offset = size_t;
 
namespace attr {
template <typename T> constexpr AttributeType getAttributeType()
{
    if constexpr (std::is_same_v<T, intT>) return AttributeType::intT;
    else if constexpr (std::is_same_v<T, floatT>) return AttributeType::floatT;
    else if constexpr (std::is_same_v<T, boolT>) return AttributeType::boolT;
    else if constexpr (std::is_same_v<T, Vector3>) return AttributeType::vectorT;
    else if constexpr (std::is_same_v<T, Matrix4>) return AttributeType::matrixT;
    else static_assert(sizeof(T) == 0, "No attribute type stores this C++ type");
}
} // namespace attr
 
namespace prm {
enum class Type
{
    STRING,
    FLOAT,
    BOOL,
    INT,
    TOGGLE,
    GROUP,
    DROPDOWN,
    RAMP,
    DIVIDER
};
enum class Direction
{
    HORIZONTAL,
    VERTICAL
};
enum class ValueType
{
    Float,
    Int,
    String
};
 
inline std::string toString(Type type)
{
    // Using a switch to catch missing cases at compile time.
    switch (type)
    {
    case Type::STRING:
        return "string";
    case Type::FLOAT:
        return "float";
    case Type::BOOL:
        return "bool";
    case Type::INT:
        return "int";
    case Type::TOGGLE:
        return "toggle";
    case Type::GROUP:
        return "group";
    case Type::DROPDOWN:
        return "dropdown";
    case Type::RAMP:
        return "ramp";
    case Type::DIVIDER:
        return "divider";
    }
    return "";
}
 
inline constexpr std::array kAllTypes = {
    Type::STRING,
    Type::FLOAT,
    Type::BOOL,
    Type::INT,
    Type::TOGGLE,
    Type::GROUP,
    Type::DROPDOWN,
    Type::RAMP,
    Type::DIVIDER
};
 
inline std::optional<Type> toType(const std::string& name)
{
    for (Type type : kAllTypes)
        if (toString(type) == name) return type;
    return std::nullopt;
}
 
inline ValueType toValueType(Type type)
{
    switch (type)
    {
    case Type::FLOAT:
        return ValueType::Float;
    case Type::INT:
    case Type::BOOL:
    case Type::TOGGLE:
    // Multiparm parameters (like ramp) use integers to represent their instance
    // count and store the actual data in their instances.
    case Type::RAMP:
    // Dividers are purely visual and store an int nobody reads.
    case Type::DIVIDER:
        return ValueType::Int;
    case Type::STRING:
    case Type::DROPDOWN:
        return ValueType::String;
    case Type::GROUP:
        return ValueType::Float;
    }
    return ValueType::Float;
}
} // namespace prm
namespace nt {
using NodeId = uint64_t;
 
constexpr NodeId nullNode = 0;
 
enum class SocketIOType
{
    Input,
    Output
};
} // namespace nt
} // namespace enzo