#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>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Options.h>
#include <UT/UT_Ramp.h>
#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>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#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>

Include dependency graph for APEX_Include.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	apex::FloatRamp

class	apex::ColorRamp

class	apex::VariadicArg< T >

class	apex::VariadicArg< T >::IndirectRange< IterT >

struct	apex::is_apex_array< T >

struct	apex::is_apex_array< ApexArray< T > >

struct	UT::DefaultClearer< T >

Namespaces
	apex

	UT

Macros
#define	APEX_ID(IdType)

#define	APEX_INDEX(IndexType)

#define	APEX_INVALID_GRAPHDATAID -1

#define	APEX_ID_CLEARER(IdType)

#define	APEX_INDEX_CLEARER(IndexType)

#define	APEX_NUMBER_FORMATTER(IdOrIndexType)

Typedefs
using	PRM_DataItemHandle = UT_SharedPtr< const PRM_DataItem >

using	apex::Bool = bool

using	apex::Int = exint

using	apex::Float = double

using	apex::String = UT_StringHolder

using	apex::Vector2 = UT_Vector2T< Float >

using	apex::Vector3 = UT_Vector3T< Float >

using	apex::Vector4 = UT_Vector4T< Float >

using	apex::Matrix3 = UT_Matrix3T< Float >

using	apex::Matrix4 = UT_Matrix4T< Float >

using	apex::Geometry = ApexGeometry

using	apex::BoolArray = ApexArray< Bool >

using	apex::IntArray = ApexArray< Int >

using	apex::FloatArray = ApexArray< Float >

using	apex::StringArray = ApexArray< String >

using	apex::Vector2Array = ApexArray< Vector2 >

using	apex::Vector3Array = ApexArray< Vector3 >

using	apex::Vector4Array = ApexArray< Vector4 >

using	apex::Matrix3Array = ApexArray< Matrix3 >

using	apex::Matrix4Array = ApexArray< Matrix4 >

using	apex::GeometryArray = ApexArray< ApexGeometry >

using	apex::FloatRampArray = ApexArray< FloatRamp >

using	apex::ColorRampArray = ApexArray< ColorRamp >

using	apex::Quaternion = UT_QuaternionT< Float >

using	apex::DataItem = PRM_DataItemHandle

using	apex::APEX_ArgPtrs = UT_Array< void * >

using	apex::APEX_GraphDataID = int64

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 >

Enumerations
enum	apex::APEX_CallbackType { apex::APEX_CallbackType::NOOP, apex::APEX_CallbackType::NORMAL, apex::APEX_CallbackType::IF_BEGIN, apex::APEX_CallbackType::IF_END, apex::APEX_CallbackType::LOOP_BEGIN, apex::APEX_CallbackType::LOOP_END }

Functions
template<typename... T, size_t... I>
auto	apex::makeref (UT_Tuple< T...> &t, std::index_sequence< I...>)

template<typename... T>
auto	apex::makerefs (UT_Tuple< T...> &t)

Macro Definition Documentation

#define APEX_ID ( IdType )

Value:

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

Definition at line 289 of file APEX_Include.h.

#define APEX_ID_CLEARER ( IdType )

Value:

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

Definition at line 344 of file APEX_Include.h.

#define APEX_INDEX ( IndexType )

Value:

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

Definition at line 298 of file APEX_Include.h.

#define APEX_INDEX_CLEARER ( IndexType )

Value:

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

Definition at line 363 of file APEX_Include.h.

#define APEX_INVALID_GRAPHDATAID -1

Definition at line 321 of file APEX_Include.h.

#define APEX_NUMBER_FORMATTER ( IdOrIndexType )

Value:

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()});                               \
    }