APEX_Include.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        APEX_Include.h (APEX Library, C++)
 *
 * COMMENTS:
 */

#ifndef __APEX_INCLUDE_H__
#define __APEX_INCLUDE_H__

#include "APEX_API.h"
#include "APEX_Names.h"
#include "APEX_COW.h"

#include <UN/UN_Include.h>

#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_Assert.h>
#include <UT/UT_Debug.h>
#include <UT/UT_Format.h>
#include <UT/UT_Map.h>
#include <UT/UT_Matrix3.h>      // IWYU pragma: export
#include <UT/UT_Matrix4.h>      // IWYU pragma: export
#include <UT/UT_Options.h>
#include <UT/UT_Ramp.h>         // IWYU pragma: export
#include <UT/UT_Set.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Tracing.h>
#include <UT/UT_Tuple.h>
#include <UT/UT_Vector2.h>      // IWYU pragma: export
#include <UT/UT_Vector3.h>      // IWYU pragma: export
#include <UT/UT_Vector4.h>      // IWYU pragma: export
#include <SYS/SYS_Types.h>

#include <algorithm>
#include <any>
#include <functional>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <vector>

#include <stddef.h>

// Forward declarations from <PRM/PRM_Parm.h>
class PRM_DataItem;
using PRM_DataItemHandle = UT_SharedPtr<const PRM_DataItem>;

namespace apex
{

using Bool = bool;
using Int = exint;
using Float = double;
using String = UT_StringHolder;
using Vector2 = UT_Vector2T<Float>;
using Vector3 = UT_Vector3T<Float>;
using Vector4 = UT_Vector4T<Float>;
using Matrix3 = UT_Matrix3T<Float>;
using Matrix4 = UT_Matrix4T<Float>;
using Geometry = ApexGeometry;
class FloatRamp : public UT_Ramp
{
public:
    FloatRamp()
    {
        this->addNode(0, UT_FRGBA(0.0, 0.0, 0.0, 0.0));
        this->addNode(1, UT_FRGBA(1.0, 1.0, 1.0, 1.0));
    };
    FloatRamp(const UT_Ramp &ramp) : UT_Ramp{ramp} {}
};
class ColorRamp : public UT_Ramp
{
public:
    ColorRamp()
    {
        this->addNode(0, UT_FRGBA(0.0, 0.0, 0.0, 0.0));
        this->addNode(1, UT_FRGBA(1.0, 1.0, 1.0, 1.0));
    };
    ColorRamp(const UT_Ramp &ramp) : UT_Ramp{ramp} {}
};

using BoolArray = ApexArray<Bool>;
using IntArray = ApexArray<Int>;
using FloatArray = ApexArray<Float>;
using StringArray = ApexArray<String>;
using Vector2Array = ApexArray<Vector2>;
using Vector3Array = ApexArray<Vector3>;
using Vector4Array = ApexArray<Vector4>;
using Matrix3Array = ApexArray<Matrix3>;
using Matrix4Array = ApexArray<Matrix4>;
using GeometryArray = ApexArray<ApexGeometry>;
using FloatRampArray = ApexArray<FloatRamp>;
using ColorRampArray = ApexArray<ColorRamp>;

// Quaternion is not an exposed type. It's only used within callbacks
// internally to ensure we consistently use the same base type. Externally,
// Vector4 is used in the callback signatures.
using Quaternion = UT_QuaternionT<Float>;

using DataItem = PRM_DataItemHandle;

template <typename T>
class VariadicArg
{
public:
    VariadicArg() : myNames(), myData() {};
    VariadicArg(std::initializer_list<std::pair<const char *, T *>> inputs) : myNames(), myData()
    {
        myNames.setCapacity(inputs.size()); // optional metadata
        myData.setCapacity(inputs.size());
        for (auto &[name, p] : inputs)
        {
            myNames.emplace_back(name);
            myData.append(p);
        }
    }

    using value_type = T;

    void append(const UT_StringHolder &name, T *item)
    {
        myNames.emplace_back(name);
        myData.append(item);
    }

    exint size() const
    {
        if (myData.size() != myNames.size())
        {
            UTdebugPrint(this, myData.size(), myNames.size());
        }
        UT_ASSERT(myData.size() == myNames.size());
        return myData.size();
    }

    const UT_Array<UT_StringHolder> &names() const { return myNames; }

    T *operator[](exint idx)
    {
        return myData[idx];
    }

    const T *operator[](exint idx) const
    {
        return myData[idx];
    }

    exint nameToIndex(const UT_StringRef &name) const
    {
        return myNames.find(name);
    }

    void toArray(UT_Array<T> &arr) const
    {
        arr.setSize(myData.size());
        for (exint i = 0, n = myData.size(); i < n; ++i)
            arr[i] = *operator[](i);
    }

    using iterator = typename UT_Array<T *>::iterator;
    using const_iterator = typename UT_Array<T *>::const_iterator;

    iterator begin() { return myData.begin(); }
    iterator end() { return myData.end(); }
    const_iterator begin() const { return myData.begin(); }
    const_iterator end() const { return myData.end(); }

    /// A minimal array like adaptor which dereferences the VariadicArgs data
    /// before returning it. This can be useful to write generic code which
    /// deals either with VariadicArgs or ApexArrays.
    /// Note: Not compatible with ranged based for loops
    template<typename IterT>
    class IndirectRange
    {
    public:
        using value_type = T;

        exint size() const
        {
            return std::distance(myBegin, myEnd);
        }

        T &operator[](exint index)
        {
            return *myBegin[index];
        }

        const T &operator[](exint index) const
        {
            return *myBegin[index];
        }

    private:
        friend class VariadicArg<T>;
        IndirectRange() = delete;
        IndirectRange(IterT begin, IterT end) : myBegin{begin}, myEnd{end} {}
        IterT myBegin, myEnd;
    };

    IndirectRange<iterator> indirectRange()
    {
        return IndirectRange<iterator>(begin(), end());
    }

    const IndirectRange<const_iterator > indirectRange() const
    {
        return IndirectRange<const_iterator>(begin(), end());
    }

private:
    UT_Array<UT_StringHolder> myNames;
    UT_Array<T *> myData;
};

enum class APEX_CallbackType
{
    NOOP, /// Do nothing; ignored after compilation.

    NORMAL, /// Normal callback which is unconditionally executed

    /// @{ flow control

    IF_BEGIN, /// Callback is used as an IF_BEGIN: expects the signature to be exactly a Bool called
              /// condition + scope/spare
    IF_END,   /// Callback marks the end of an if block: expects the signture to be exactly
              /// scope/spare.

    LOOP_BEGIN, /// Marks the start of an arbitrary loop, expects RunData to be an iterator
    LOOP_END    /// Marks the end of an arbitrary loop, expects RunData to be an iterator and shares
                /// that rundata with the corresponding LOOP_BEGIN.

    /// @}
};

template <typename... T, size_t... I>
auto
makeref(UT_Tuple<T...> &t, std::index_sequence<I...>)
{
    return UTlhsTuple(*std::get<I>(t)...);
}

template <typename... T>
auto
makerefs(UT_Tuple<T...> &t)
{
    return makeref<T...>(t, std::make_index_sequence<sizeof...(T)>{});
}

using APEX_ArgPtrs = UT_Array<void *>;

static inline UT_StringArray
parseTag(const UT_StringRef &tag_key)
{
    UT_StringArray result;
    std::string tag_name(tag_key);
    std::string theprefix;
    std::string delimiter = ".";

    auto pos = tag_name.find(delimiter);
    while (pos != std::string::npos)
    {
        theprefix = tag_name.substr(0, pos);
        if (pos != std::string::npos)
            tag_name.erase(0, pos + delimiter.length());
        result.append(theprefix);
        pos = tag_name.find(delimiter);
    }
    result.append(tag_name);
    return result;
}

static const char *
stripQualifiers(const UT_StringLit &portname)
{
    if (portname.length() > 1 && portname.c_str()[0] == '*')
        return portname.c_str() + 1;
    return portname.c_str();
}

#define APEX_ID(IdType)                                                                            \
    class IdType : public UN_DataIndex                                                             \
    {                                                                                              \
    public:                                                                                        \
        explicit IdType(UN_DataIndex data_index = UN_DataIndex()) : UN_DataIndex(data_index)       \
        {                                                                                          \
        }                                                                                          \
    };

#define APEX_INDEX(IndexType)                                                                      \
    class IndexType : public UN_DataIndex                                                          \
    {                                                                                              \
    public:                                                                                        \
        explicit IndexType(UN_DataIndex data_index = UN_DataIndex()) : UN_DataIndex(data_index)    \
        {                                                                                          \
        }                                                                                          \
    };

APEX_ID(APEX_StickyNoteID)
APEX_INDEX(APEX_StickyNoteIndex)

template <typename T>
struct is_apex_array : std::false_type
{
};

template <typename T>
struct is_apex_array<ApexArray<T>> : std::true_type
{
};

using APEX_GraphDataID = int64;
#define APEX_INVALID_GRAPHDATAID -1

} // end namespace apex


// Apex Scope ID. It is currently defined as an index, because
// APEX (subnets) use it solely as a direct index into its arrays.
APEX_INDEX(APEX_ScopeID)


// APEX data IDs based on UN concepts:
using APEX_NodeID   = UN_NodeID;
using APEX_SubnetID = UN_SubnetID;
using APEX_GraphID  = APEX_SubnetID;
using APEX_PortID   = UN_PortID;
using APEX_WireID   = UN_WireID;

using APEX_PortKind = UN_PortKind;

using APEX_PortIDSpan  = UT_Span<const APEX_PortID>;
using APEX_PortIDRange = UT_IteratorRange<APEX_PortIDSpan::iterator>;


#define APEX_ID_CLEARER(IdType)                                                                    \
    template <>                                                                                    \
    struct DefaultClearer<IdType>                                                                  \
    {                                                                                              \
        static void clear(IdType &v)                                                               \
        {                                                                                          \
            v = IdType();                                                                          \
        }                                                                                          \
        static bool isClear(const IdType &v)                                                       \
        {                                                                                          \
            return !v.isValid();                                                                   \
        }                                                                                          \
        static void clearConstruct(IdType *p)                                                      \
        {                                                                                          \
            clear(*p);                                                                             \
        }                                                                                          \
        static const bool clearNeedsDestruction = false;                                           \
    };

#define APEX_INDEX_CLEARER(IndexType)                                                              \
    template <>                                                                                    \
    struct DefaultClearer<IndexType>                                                               \
    {                                                                                              \
        static void clear(IndexType &v)                                                            \
        {                                                                                          \
            v = IndexType();                                                                       \
        }                                                                                          \
        static bool isClear(const IndexType &v)                                                    \
        {                                                                                          \
            return !v.isValid();                                                                   \
        }                                                                                          \
        static void clearConstruct(IndexType *p)                                                   \
        {                                                                                          \
            clear(*p);                                                                             \
        }                                                                                          \
        static const bool clearNeedsDestruction = false;                                           \
    };

#define APEX_NUMBER_FORMATTER(IdOrIndexType)                                                       \
    inline size_t format(char *buffer, size_t buffer_size, const IdOrIndexType &v)                 \
    {                                                                                              \
        UT::Format::Writer w(buffer, buffer_size);                                                 \
        UT::Format::Formatter f;                                                                   \
        return f.format(w, #IdOrIndexType "({})", {v.exintValue()});                               \
    }

APEX_NUMBER_FORMATTER(APEX_ScopeID)
APEX_NUMBER_FORMATTER(apex::APEX_StickyNoteID)
APEX_NUMBER_FORMATTER(apex::APEX_StickyNoteIndex)

// For UT::ArraySet.
namespace UT
{
template <typename T>
struct DefaultClearer;

APEX_ID_CLEARER(apex::APEX_StickyNoteID)

APEX_INDEX_CLEARER(APEX_ScopeID)
APEX_INDEX_CLEARER(apex::APEX_StickyNoteIndex)

}; // namespace UT

#endif