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} {}
};

class APEX_Graph;
using APEX_GraphHandle = APEX_COWHandle<APEX_Graph>;

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() {}
    VariadicArg(std::initializer_list<std::pair<const char *, T *>> inputs)
    {
        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;
};

} // end namespace apex

using APEX_GraphDataID = int64;
#define APEX_INVALID_GRAPHDATAID -1

// 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_StickyNoteID = UN_StickyNoteID;

using APEX_PortKind = UN_PortKind;

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

// An index into a data container, referring to a data object.
// Indices may be reused for new data objects, if old ones were deleted.
#define APEX_INDEX(Class) UN_DATA_INDEX(Class)

// A clearer for UT::ArraySet. Must be used within the UT namespace.
#define APEX_INDEX_CLEARER(IndexType) UN_INDEX_CLEARER(IndexType)

// For debug printouts
#define APEX_NUMBER_FORMATTER(IdOrIndexType) UN_NUMBER_FORMATTER(IdOrIndexType)

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

namespace UT
{
APEX_INDEX_CLEARER(APEX_ScopeID)
} // namespace UT

#endif