Detailed Description

This namespace contains the API of the nodes framework.

Namespaces
	details

	InPortComponentAccessTypes

	MATERIALEXCHANGE

	MaterialNodeSpaces

	NODESPACE

	OutPortComponentAccessTypes

	PREVIEW

	PREVIEWIMAGEREQUEST

	PREVIEWIMAGESUBSCRIPTION

Classes
class	GraphDescription

class	CoreNodeWrapperInterface

class	CoreNodeWrapperLib

class	ComponentAccessType

class	NodeOrTemplate

class	NodeDescriptionAssetInterface

class	NodeDescriptionAssetTypeInterface

class	NodeErrorInterface

class	NodeTemplateArgumentErrorInterface

class	NodeExecutionErrorInterface

class	MissingNodeAssetErrorInterface

class	SerializationNodeData

class	ImportAdapterInterface

class	NodeSystemManagerInterface

class	NodesGraphModelInterface

struct	NodeWithAssetId

class	NodesGraphHelpersInterface

class	NodesLib

struct	GNodeDataPtr

class	GNodeHandle

class	NodeSystemInterface

class	NodeSystem

class	GNodeBase

class	MutableGNodeBase

class	GNodeFunctions

class	GNode

class	MutableGNodeFunctions

class	MutableGNode

class	GNodeIteratorBase

class	GNodeIterator

class	NodeFunctions

class	Node

class	MutableNodeFunctions

class	MutableNode

class	MutableRoot

class	PortListFunctions

class	PortList

class	MutablePortListFunctions

class	MutablePortList

class	PortFunctions

class	Port

class	MutablePortFunctions

class	MutablePort

class	NodeSystemClassInterface

class	NodeSystemDataInterface

class	NodeSystemDerivationHandlerInterface

class	TemplateArguments

class	NodeTemplateInterface

class	NodeSystemBasedNodeTemplateInterface

struct	Chain

class	DerivedAttributeInterface

class	NodeSpaceInterface

class	NodeSpaceHelpersInterface

class	GraphSetUndoMode

struct	PackedMaterialParameter

struct	TypedMaterialParameter

class	MaterialExchangeInterface

class	NodeMaterialImportInterface

class	NodeMaterialExportInterface

class	NodeMaterialImportHelperInterface

struct	PreviewImageProviderOutputImage

struct	PreviewImageProviderOutput

class	PreviewImageProviderInterface

class	PreviewImageSubscriptionInterface

Typedefs
using	ComponentAccessDef = StrongRef< ComponentAccessType >

using	ComponentAccessDefWithId = Tuple< StrongRef< ComponentAccessType >, Id >

using	LanguageDictionary = DataDictionary

using	PortDescriptionProvider = Delegate< Result< void >(DataDictionary &description, const GraphNode &port, const Id &category)>

using	PortEnumDescriptionProvider = Delegate< Result< void >(const GraphNode &port, const CString &additionalArgs, Int enumEntryIdx, DataDictionary &description, const Id &category)>

using	NodesDescriptionAssetApplyFinalizer = Delegate< Result< void >(const NodeDescriptionAsset &asset, const GraphNode &, const DataDictionary &)>

using	ConstantOptimizer = Delegate< Result< Data >(const ConstDataPtr &value)>

using	OriginalGraph = Tuple< nodes::NodesGraphModelRef, TimeStamp >

using	NodesGraphHelper = NodesGraphHelpersInterface

template<Bool MUTABLE>
using	GNodeSelector = typename std::conditional< MUTABLE, MutableGNode, GNode >::type

template<Bool MUTABLE>
using	PortListSelector = typename std::conditional< MUTABLE, MutablePortList, PortList >::type

template<Bool MUTABLE>
using	PortSelector = typename std::conditional< MUTABLE, MutablePort, Port >::type

using	Connection = Tuple< Port, Wires >

using	MutableConnection = Tuple< MutablePort, Wires >

template<Bool MUTABLE>
using	ConnectionSelector = typename std::conditional< MUTABLE, MutableConnection, Connection >::type

template<Bool MUTABLE>
using	NodeSelector = typename std::conditional< MUTABLE, MutableNode, Node >::type

template<typename BASE >
using	PortFunctionsSuper = typename std::conditional< BASE::HAS_ERROR, typename std::conditional< BASE::MUTABLE, MutablePortListFunctions< BASE >, PortListFunctions< BASE > >::type, PortListSelector< BASE::MUTABLE > >::type

using	NodePathArraySet = ArraySet< NodePath, true, FastNodePathHash >

using	NodePathArraySetRef = StrongCOWRef< NodePathArraySet >

using	SampleFloat32 = Vec4< Float32 >

using	SamplesFloat32 = BaseArray< SampleFloat32 >

using	SamplesFloat32Ref = StrongRef< SamplesFloat32 >

using	SamplesFloat32ConstRef = StrongRef< const SamplesFloat32 >

using	PreviewImageSubscriptionResultFunc = Delegate< void(PREVIEW::STAGE stage, const ImageTextureRef &image)>

Enumerations
enum class	PORT_FLAGS { NONE , HIDDEN , USED_FOR_TEMPLATE_ARGUMENT , USED_FOR_INPUTPORTTYPE_TEMPLATE_ARGUMENT , CONSTANT , VARIADIC , VARIADIC_TEMPLATE , INHERITS_NESTED_PORTS , SYNTHESIZES_NESTED_PORTS , HAS_CHILDREN , USED_FOR_INPUTBUNDLE_TEMPLATE_ARGUMENT , CHAIN , DYNAMIC , USED_FOR_DYNAMIC_TYPE , USED_FOR_PORTTYPE_DEPENDENCY , USED_FOR_PORTTYPE_DEPENDENCY_MASK , HAS_FIXED_TYPE , USED_FOR_VALUE_MODE_TEMPLATE_ARGUMENT }

enum class	PORT_CONNECTION_STATE { NONE , SAME_LEVEL , OUTER_LEVEL , PROPAGATED , AUTO_PROPAGATED , NORMAL_MASK , PROPAGATED_MASK }

enum class	GNODE_FLAGS : UInt64 { NONE , DIRECT_PORT , DERIVED_PORT_INHERITED , DERIVED_PORT_SYNTHESIZED , CONTEXT_SOURCE , CONTEXT_TARGET , FUNCTION_INSTANTIATION , CONTEXT_PARAMETER_PORT , TAPPING_PORT , DERIVATION_FILTER_SOURCE , DERIVATION_FILTER_TARGET , ALL_MASK }

enum class	VALUEMODE : Char { NONE , DYNAMIC , CONSTANT , UNKNOWN_CONSTANT }

enum class	UNDO_MODE { NONE , START , ADD }

Functions
	MAXON_DATATYPE (ComponentAccessType, "net.maxon.nodes.datatype.componentaccesstype")

	MAXON_ATTRIBUTE (Bool, IsComponentAccessBundle, "componentaccessbundleport3", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, IsComponentAccessChild, "componentaccesschild3", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (ComponentAccessDefWithId, ComponentAccessDefAttr, "componentaccessdef", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, AllowNestedAccess, "co_allownested")

	MAXON_REGISTRY (ComponentAccessDef, InPortComponentAccessTypes, "net.maxon.node.registry.inportcomponentaccess")

	MAXON_REGISTRY (ComponentAccessDef, OutPortComponentAccessTypes, "net.maxon.node.registry.outportcomponentaccess")

	MAXON_ATTRIBUTE (void, NodeCategoryExistingNodes, "net.maxon.nodecategory.existingnodes")

	MAXON_ATTRIBUTE (DataDictionary, PortDescriptionData, "portDescriptionData")

	MAXON_ATTRIBUTE (DataDictionary, PortDescriptionUi, "portDescriptionUi")

	MAXON_ATTRIBUTE (LazyLanguageDictionary, PortDescriptionStringLazy, "portDescriptionStringLazy")

	MAXON_ATTRIBUTE (DataDescriptionDefinition, NodeDescriptionData, "nodeDescriptionData")

	MAXON_ATTRIBUTE (DataDescriptionDefinition, NodeDescriptionUi, "nodeDescriptionUi")

	MAXON_ATTRIBUTE (LazyLanguageStringDataDescriptionDefinition, NodeDescriptionStringLazy, "nodeDescriptionStringLazy")

	MAXON_REGISTRY (PortDescriptionProvider, PortDescriptionProviders, "net.maxon.nodes.portdescriptionproviders")

	MAXON_REGISTRY (PortEnumDescriptionProvider, PortEnumDescriptionProviders, "net.maxon.nodes.portenumdescriptionproviders")

	MAXON_ATTRIBUTE (IdAndVersion, AssetId, "net.maxon.node.attribute.assetid", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Id, RepositoryId, "net.maxon.node.attribute.repositoryid", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, IsInsideAsset, "net.maxon.node.attribute.isinsideasset", MAXON_ATTRIBUTE_READONLY)

enum maxon::nodes::PORT_FLAGS	MAXON_ENUM_FLAGS (PORT_FLAGS)

	MAXON_ATTRIBUTE (DataType, SynthesizedType, "synthesizedtype", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (DataType, OutputTypeConstraint, "outputtypeconstraint", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (DataType, PortType, "type", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (PORT_FLAGS, PortFlags, "portflags", MAXON_ATTRIBUTE_READONLY)

	MAXON_DATATYPE (NodeOrTemplate, "net.maxon.node.datatype.nodeortemplate")

	MAXON_INTERNED_ID ("net.maxon.node.port.nodesystem", NodeSystemPort)

	MAXON_ATTRIBUTE (InternedId, ScaffoldId, "net.maxon.node.attribute.scaffoldid")

	MAXON_ATTRIBUTE (Bool, IsEditableGroup, "isgroup", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, IsConvertibleToGroup, "convertibletogroup")

	MAXON_ATTRIBUTE (Bool, IndissolubleGroup, "indissolublegroup")

	MAXON_ATTRIBUTE (Bool, IgnoreBase, "ignorebase")

	MAXON_ATTRIBUTE (Bool, InternalDescriptionDerivation, "internaldescriptionderivation")

	MAXON_ATTRIBUTE (Asset, AssetInstance, "net.maxon.node.attribute.asset", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (IdAndVersion, OriginalAsset, "net.maxon.node.originalasset")

	MAXON_ATTRIBUTE (IdAndVersion, CapsuleAssetId, "net.maxon.node.attribute.capsuleassetid", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Error, ExecutionError, "executionerror")

	MAXON_ATTRIBUTE (Error, ExecutionMessage, "executionmsg")

	MAXON_REGISTRY (NodesDescriptionAssetApplyFinalizer, NodesDescriptionAssetApplyFinalizers, "net.maxon.node.registry.asset.nodedescriptionfinalizers")

	MAXON_DECLARATION (NodeSystemClass, BaseCoreNodesNodeSystemClass, "net.maxon.corenode.basenodesystemclass")

	MAXON_DECLARATION (NodeSystemClass, CoreNodesNodeSystemClass, "net.maxon.corenode.nodesystemclass")

	MAXON_DECLARATION (Factory< DescriptionProcessor(Delegate< Result< Bool >(const NodeSystemClass &cls)> &&support)>, CoreNodesDescriptionProcessor, "net.maxon.corenode.factory.descriptionprocessor")

	MAXON_REGISTRY (ConstantOptimizer, ConstantOptimizers, "net.maxon.nodes.registry.constantoptimizers")

	MAXON_ATTRIBUTE (Bool, FunctionResult, "functionresult")

	MAXON_ATTRIBUTE (Bool, NoCleanupOnFinalize, "skipfinalizemodification")

	MAXON_REGISTRY (ImportAdapter, ImportAdapters, "net.maxon.node.registry.importadapters")

class NodeTemplate	MAXON_FORWARD ("maxon/nodetemplate.h")

	MAXON_ATTRIBUTE (void, Messages, "messages")

enum maxon::nodes::PORT_CONNECTION_STATE	MAXON_ENUM_FLAGS (PORT_CONNECTION_STATE)

	MAXON_ATTRIBUTE (PORT_CONNECTION_STATE, PortConnectionState, "portconnectionstate")

	MAXON_DECLARATION (Class< NodeSystemManagerRef >, NodeSystemManagerClass, "net.maxon.node.class.nodesystemmanager")

	MAXON_DECLARATION (Class< NodesGraphModelRef >, NodesGraphModelClass, "net.maxon.node.class.nodesgraphmodel")

Result< Node >	ToNode (const GraphNode &node)

Result< PortList >	ToPortList (const GraphNode &node)

Result< Port >	ToPort (const GraphNode &node)

Result< MutableNode >	ToMutableNode (const GraphNode &node)

Result< MutablePortList >	ToMutablePortList (const GraphNode &node)

Result< MutablePort >	ToMutablePort (const GraphNode &node)

Bool	HasBase (const GraphNode &node, const Id &asset)

	MAXON_ATTRIBUTE (OriginalGraph, OriginalGraphAttr, "net.maxon.nimbus.originalgraph")

class NodeSystemData	MAXON_FORWARD ("maxon/nodesystem_data.h")

class NodeSystemClass	MAXON_FORWARD ("maxon/nodesystem_class.h")

class NodeSystemDerivationHandler	MAXON_FORWARD ("maxon/nodesystem_derivation.h")

enum maxon::nodes::GNODE_FLAGS UInt64	MAXON_ENUM_FLAGS (GNODE_FLAGS)

enum maxon::nodes::VALUEMODE Char	MAXON_ENUM_LIST (VALUEMODE)

	MAXON_DATATYPE (MutableRoot, "net.maxon.node.datatype.mutableroot")

	MAXON_DECLARATION (NodeSystemClass, DefaultNodeSystemClass, "net.maxon.node.nodesystemclass")

	MAXON_DECLARATION (Class< NodeSystemDerivationHandler >, NodeSystemDerivationHandlerBaseClass, "net.maxon.node.class.nodesystemderivationhandlerbase")

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (TemplateArguments **, OverloadRank0)

	MAXON_ATTRIBUTE (Url, InstantiateContextBasePath, "net.maxon.nodes.nodesystem.instantiatecontext.basepath")

	MAXON_ATTRIBUTE (AssetMetaData, InstantiateContextMeta, "net.maxon.node.nodesystem.instantiatecontext.metadata")

	MAXON_REGISTRY (Delegate< Result< void >(const MutableRoot &)>, DescriptionFinalizers, "net.maxon.node.registry.descriptionfinalizers")

	MAXON_ATTRIBUTE (Bool, InheritNestedPorts, "inheritnestedports")

	MAXON_ATTRIBUTE (Bool, SynthesizeNestedPorts, "synthesizenestedports")

	MAXON_ATTRIBUTE (Bool, InheritNestedPortsSource, "inheritnestedportssource")

	MAXON_ATTRIBUTE (Bool, SynthesizeNestedPortsSource, "synthesizenestedportssource")

	MAXON_ATTRIBUTE (Bool, InheritPortSource, "inheritportsource")

	MAXON_ATTRIBUTE (Bool, SynthesizePortSource, "synthesizeportsource")

	MAXON_ATTRIBUTE (Bool, SynthesizeTypeSource, "synthesizetypesource")

	MAXON_ATTRIBUTE (Bool, LoopDependencySource, "loopdependencysource")

	MAXON_ATTRIBUTE (Bool, LoopDependencyTarget, "loopdependencytarget")

	MAXON_ATTRIBUTE (Bool, Dynamic, "dynamic")

	MAXON_ATTRIBUTE (Bool, HierarchicalDynamic, "hierarchicaldynamic")

	MAXON_ATTRIBUTE (Bool, TransientDynamic, "transientdynamic")

	MAXON_ATTRIBUTE (Bool, TemplateParameter, "templateparameter")

	MAXON_ATTRIBUTE (Bool, AllowDynamicArgument, "allowdynamicargument")

	MAXON_ATTRIBUTE (DataType, TypeTemplateParameter, "porttypetemplateparameter")

	MAXON_ATTRIBUTE (Bool, BundleTemplateParameter, "bundletemplateparameter")

	MAXON_ATTRIBUTE (Bool, ValueModeTemplateParameter, "valuemodetemplateparameter")

	MAXON_ATTRIBUTE (Data, TemplateArgument, "templateargument", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, StickyTypeTemplateParameter, "stickyporttypetemplateparameter")

	MAXON_ATTRIBUTE (Error, TemplateError, "templateerror")

	MAXON_ATTRIBUTE (Bool, ConstantParameter, "constantparameter")

	MAXON_ATTRIBUTE (Bool, SynthesizePortValue, "synthesizevalue")

	MAXON_ATTRIBUTE (Bool, TappingPort, "tappingport")

	MAXON_ATTRIBUTE (Bool, Permanent, "permanent")

	MAXON_ATTRIBUTE (Bool, HiddenFromInside, "hiddeninside")

	MAXON_ATTRIBUTE (Bool, HiddenFromOutside, "hiddenoutside")

	MAXON_ATTRIBUTE (Bool, InternalHidden, "net.maxon.node.attribute.internalhidden")

	MAXON_ATTRIBUTE (DataType, FixedPortType, "fixedtype")

	MAXON_ATTRIBUTE (DataType, DynamicTypeConstraint, "dynamictypeconstraint")

	MAXON_ATTRIBUTE (Bool, EnforceType, "enforcetype")

	MAXON_ATTRIBUTE (TupleDataType, FunctionParameters, "functionparams")

	MAXON_ATTRIBUTE (InternedId, ContextReference, "ctxref")

	MAXON_ATTRIBUTE (InternedId, ContextDefinition, "ctxdef")

	MAXON_ATTRIBUTE (Bool, ExternalContext, "externalcontext")

	MAXON_ATTRIBUTE (Bool, CreatedByPropagation, "net.maxon.node.createdbypropagation")

	MAXON_ATTRIBUTE (NodePath, PortGroup, "net.maxon.node.portgroup")

	MAXON_ATTRIBUTE (Int, ReqOrderIndex, "net.maxon.node.attribute.orderindex")

	MAXON_ATTRIBUTE (Int, ReqInsertIndex, "net.maxon.node.attribute.insertindex")

	MAXON_ATTRIBUTE (Bool, OverrideOrderIndex, "overrideorderindex")

	MAXON_ATTRIBUTE (Bool, ForceVariadicPortNameDerivation, "forcevariadicportnamederivation")

	MAXON_ATTRIBUTE (Bool, DisableVariadicPortNameDerivation, "disablevariadicportnamederivation")

	MAXON_ATTRIBUTE (Bool, InheritUiAttributes, "inherituiattributes")

	MAXON_ATTRIBUTE (Bool, SynthesizeUiAttributes, "synthesizeuiattributes")

	MAXON_DATATYPE (Chain, "net.maxon.node.datatype.chain")

	MAXON_ATTRIBUTE (StrongCOWRef< Chain >, ChainCounterPort, "chaincounterport")

	MAXON_ATTRIBUTE (InternedId, GlobalContext, "globalcontext")

	MAXON_ATTRIBUTE (InternedId, ScenePortMode, "sceneportmode", MAXON_ATTRIBUTE_READONLY)

	MAXON_ATTRIBUTE (Bool, UseAttributeResources, "useattributeresources")

	MAXON_ATTRIBUTE (Bool, AllowMultipleConnections, "allowmultipleconnections")

	MAXON_ATTRIBUTE (Bool, StreamPort, "streamport")

	MAXON_ATTRIBUTE (Bool, ScopePort, "scopeport")

	MAXON_ATTRIBUTE (Bool, RerouterPort, "rerouterport")

	MAXON_ATTRIBUTE (Bool, FloatingPort, "floatingport")

	MAXON_REGISTRY (GraphAttribute, Attributes, "net.maxon.node.registry.attributes")

	MAXON_REGISTRY (NodeSpaceRef, MaterialNodeSpaces, "net.maxon.nodes.registry.materialnodespaces")

	MAXON_DECLARATION (Class< NodeSpaceRef >, NodeSpaceBaseClass, "net.maxon.class.nodespace.base")

enum maxon::nodes::UNDO_MODE	MAXON_ENUM_LIST (UNDO_MODE)

	MAXON_ATTRIBUTE (UNDO_MODE, UndoMode, "net.maxon.nodes.undomode")

	MAXON_ATTRIBUTE (Bool, NimbusUndoAttribute, "net.maxon.nodes.nimbusundoattribute")

	MAXON_DATATYPE (PackedMaterialParameter, "net.maxon.nodes.datatype.packedmaterialparameter")

	MAXON_DATATYPE (PreviewImageProviderOutputImage, "net.maxon.nodes.datatype.previewimageprovideroutputimage")

Variables
static const IsEditableGroup_PrivateHelper &	IsGroup

static constexpr Char	g_corePrefix []

static constexpr Char	g_lifetimeNodePrefix

static constexpr Char	g_userNodeIdSeparator

maxon::nodes::NodeSystemManagerInterface	MAXON_ENUM_FLAGS

maxon::nodes::NodeSystemInterface	MAXON_ENUM_LIST

Typedef Documentation

◆ ComponentAccessDef

using ComponentAccessDef = StrongRef<ComponentAccessType>

◆ ComponentAccessDefWithId

using ComponentAccessDefWithId = Tuple<StrongRef<ComponentAccessType>, Id>

◆ LanguageDictionary

using LanguageDictionary = DataDictionary

◆ PortDescriptionProvider

using PortDescriptionProvider = Delegate<Result<void>(DataDictionary& description, const GraphNode& port, const Id& category)>

Callback type for port description update/modify events. Overwrite or modify the content of the loaded description based on node graph state, attributes, connections, ...

Parameters

[in,out]	description	The description to update.
[in]	port	The path to parse. Content depends on #category.
[in]	category	The #description category, DATADESCRIPTION_CATEGORY_DATA/UI/STRING.

Returns: OK on success.

◆ PortEnumDescriptionProvider

using PortEnumDescriptionProvider = Delegate<Result<void>(const GraphNode& port, const CString& additionalArgs, Int enumEntryIdx, DataDictionary& description, const Id& category)>

Callback type for port description update/modify events. These are called after PortDescriptionProviders if any applies to #port's node. Overwrite or modify the content of the loaded description based on node graph state, attributes, connections, ...

Parameters

[in]	port	The path to parse. Content depends on #category.
[in]	additionalArgs	Additional arguments given to the description provider (in the form "memberindex#net.maxon.someid,int" where we have 1 string with 2 additional arguments "net.maxon.someid" and "int").
[in]	enumEntryIdx	The index of the registered enumeration entry in DESCRIPTION::DATA::BASE::ENUM (useful for insertion).
[in,out]	description	The description to update.
[in]	category	The #description category, DATADESCRIPTION_CATEGORY_DATA/UI/STRING.

Returns: OK on success.

◆ NodesDescriptionAssetApplyFinalizer

using NodesDescriptionAssetApplyFinalizer = Delegate<Result<void>(const NodeDescriptionAsset& asset , const GraphNode&, const DataDictionary&)>

See also: NodesDescriptionAssetApplyFinalizers.

◆ ConstantOptimizer

using ConstantOptimizer = Delegate<Result<Data>(const ConstDataPtr& value)>

◆ OriginalGraph

using OriginalGraph = Tuple<nodes::NodesGraphModelRef, TimeStamp>

◆ NodesGraphHelper

using NodesGraphHelper = NodesGraphHelpersInterface

◆ GNodeSelector

using GNodeSelector = typename std::conditional<MUTABLE, MutableGNode, GNode>::type

The type alias GNodeSelector selects between MutableGNode (mutable case) and GNode (read-only case).

Template Parameters

MUTABLE true for MutableGNode, false for GNode

◆ PortListSelector

using PortListSelector = typename std::conditional<MUTABLE, MutablePortList, PortList>::type

The type alias PortListSelector selects between MutablePortList (mutable case) and PortList (read-only case).

Template Parameters

MUTABLE true for MutablePortList, false for PortList

◆ PortSelector

using PortSelector = typename std::conditional<MUTABLE, MutablePort, Port>::type

The type alias PortSelector selects between MutablePort (mutable case) and Port (read-only case).

Template Parameters

MUTABLE true for MutablePort, false for Port

◆ Connection

using Connection = Tuple<Port, Wires>

The type alias @CLASS contains the connected port in its first member and the Wires of the connection in its second member. So it's rather a half-connection since the starting port isn't contained. Connections are reported by PortFunctions::GetConnections.

◆ MutableConnection

using MutableConnection = Tuple<MutablePort, Wires>

The type alias @CLASS contains the connected port in its first member and the Wires of the connection in its second member. So it's rather a half-connection since the starting port isn't contained. Connections are reported by PortFunctions::GetConnections.

◆ ConnectionSelector

using ConnectionSelector = typename std::conditional<MUTABLE, MutableConnection, Connection>::type

The type alias ConnectionSelector selects between MutableConnection (mutable case) and Connection (read-only case).

Template Parameters

MUTABLE true for MutableConnection, false for Connection

◆ NodeSelector

using NodeSelector = typename std::conditional<MUTABLE, MutableNode, Node>::type

The type alias NodeSelector selects between MutableNode (mutable case) and Node (read-only case).

Template Parameters

MUTABLE true for MutableNode, false for Node

◆ PortFunctionsSuper

using PortFunctionsSuper = typename std::conditional<BASE::HAS_ERROR, typename std::conditional<BASE::MUTABLE, MutablePortListFunctions<BASE>, PortListFunctions<BASE> >::type, PortListSelector<BASE::MUTABLE> >::type

◆ NodePathArraySet

using NodePathArraySet = ArraySet<NodePath, true, FastNodePathHash>

◆ NodePathArraySetRef

using NodePathArraySetRef = StrongCOWRef<NodePathArraySet>

◆ SampleFloat32

using SampleFloat32 = Vec4<Float32>

Convenience definitions for the immutable preview image.

◆ SamplesFloat32

using SamplesFloat32 = BaseArray<SampleFloat32>

◆ SamplesFloat32Ref

using SamplesFloat32Ref = StrongRef<SamplesFloat32>

◆ SamplesFloat32ConstRef

using SamplesFloat32ConstRef = StrongRef<const SamplesFloat32>

◆ PreviewImageSubscriptionResultFunc

using PreviewImageSubscriptionResultFunc = Delegate<void(PREVIEW::STAGE stage, const ImageTextureRef& image)>

This delegate defines the informer about preview image results for an observed node as visible in the node previews of the attribute manager as well as the material node editor. The preview computations are performed as asynchronous streams and dispatched to all registered PreviewImageSubscriptionResultFunc delegates. Because the call to PreviewImageSubscriptionResultFunc is blocking for preview computations it is recommended to keep its implementation light-weight and hand over heavier computations to another job.

Generally, a change in the observed node will trigger such a state transition: CALCULATING -> CALCULATING -> CALCULATING -> FINISHED | THREADCANCELLED | ERROR The amount of CALCULATING steps depends on how the executed PreviewImageProvider handles progressive results.

The provided image may be null on error, cancellation or at first calculation @stage. Is it prohibited to modify the provided image in any way. Shared ownership with other observers must be assumed.

Parameters

[in]	stage	The state of the preview result.
[in]	image	The preview image result, may be null.

Enumeration Type Documentation

◆ PORT_FLAGS

enum PORT_FLAGS

strong

Type of the PortFlags attribute.

Enumerator
NONE	No flag set.
HIDDEN	The port shall be hidden.
USED_FOR_TEMPLATE_ARGUMENT	The port is used for an argument for a TemplateParameter of a node template.
USED_FOR_INPUTPORTTYPE_TEMPLATE_ARGUMENT	The port's type is used to deduce an argument for a TypeTemplateParameter of a downstream input port of a node template.
CONSTANT	It is required that the port has a constant value.
VARIADIC	The port is a variadic port, possibly with a fixed count (don't confuse with a variadic port instance).
VARIADIC_TEMPLATE	The port is a true variadic port (don't confuse with a variadic port instance). Set in addition to VARIADIC.
INHERITS_NESTED_PORTS	The port inherits nested ports from upstream ports, see InheritNestedPorts.
SYNTHESIZES_NESTED_PORTS	The port synthesizes nested ports from downstream ports, see SynthesizeNestedPorts.
HAS_CHILDREN	The port has children (so it's a port bundle or a variadic port).
USED_FOR_INPUTBUNDLE_TEMPLATE_ARGUMENT	The port is used for an argument for an BundleTemplateParameter of an input port of a node template.
CHAIN	The port belongs to a chain.
DYNAMIC	The port is marked with the Dynamic or TransientDynamic attribute.
USED_FOR_DYNAMIC_TYPE	There's a downstream port with dynamic type (see DynamicTypeConstraint) where this port's type may have an influence on.
USED_FOR_PORTTYPE_DEPENDENCY	There's a downstream port which has some dependency on the type of the current port, for example a component access input bundle.
USED_FOR_PORTTYPE_DEPENDENCY_MASK	Combination of USED_FOR_INPUTPORTTYPE_TEMPLATE_ARGUMENT and USED_FOR_PORTTYPE_DEPENDENCY. When any of the flags of this mask are set, this means that the type of the current port has an influence on some downstream port. Then the template argument matching algorithm makes sure that the deduced type of the current port is propagated to inner groups/templates.
HAS_FIXED_TYPE	The port's synthesized type is derived from a FixedPortType at the port or one of its downstream ports.
USED_FOR_VALUE_MODE_TEMPLATE_ARGUMENT	The port's value mode is used to deduce an argument for a ValueModeTemplateParameter of a downstream port of a node template.

◆ PORT_CONNECTION_STATE

enum PORT_CONNECTION_STATE

strong

Type of the PortConnectionState attribute.

Enumerator
NONE	No flag set.
SAME_LEVEL	There is a normal (non-propagation) connection to a port of a node at the same level.
OUTER_LEVEL	There is a normal (non-propagation) connection to a port of an enclosing node.
PROPAGATED	There is a propagation connection to an enclosing node.
AUTO_PROPAGATED	There is an auto-propagation connection to an enclosing node.
NORMAL_MASK	Use this mask to test for SAME_LEVEL or OUTER_LEVEL.
PROPAGATED_MASK	Use this mask to test for PROPAGATED or AUTO_PROPAGATED.

◆ GNODE_FLAGS

enum GNODE_FLAGS : UInt64

strong

This enum class contains a set of flags which can be queried for g-nodes. The flags can't be set directly, they are either set at creation of a port (see MutablePortListFunctions::AddPort) or derived automatically during node system validation.

Enumerator
NONE	No flag set.
DIRECT_PORT	This flag is set for a port which has been created directly by user code, as opposed to derived ports (DERIVED_PORT_INHERITED, DERIVED_PORT_SYNTHESIZED) which are created based on port bundles of connected ports.
DERIVED_PORT_INHERITED	This flag is set for a port which has been created (or would have been created) during the derivation of inherited ports, namely when a port derives an inner port from an incoming connection from a port bundle. See also DIRECT_PORT DERIVED_PORT_SYNTHESIZED
DERIVED_PORT_SYNTHESIZED	This flag is set for a port which has been created (or would have been created) during the derivation of synthesized ports, namely when a port derives an inner port from an outgoing connection to a port bundle. See also DIRECT_PORT DERIVED_PORT_INHERITED
CONTEXT_SOURCE	This flag is set for a port which is a source port of a CONTEXT wire (or which has an enclosing port with that property).
CONTEXT_TARGET	This flag is set for a port which is a target port of a CONTEXT wire (or which has an enclosing port with that property).
FUNCTION_INSTANTIATION	This flag is set for a port which has the FunctionParameters attribute set (or which has an enclosing port with that property). Such a port provides a context containing the function parameters, and it instantiates its predecessor subgraph for a compilation into a function.
CONTEXT_PARAMETER_PORT	This flag is set for the context port of a built-in NODE::CONTEXT::GET node.
TAPPING_PORT	This flag is set for a port for which the TappingPort attribute is true (or which has an enclosing port with that property).
DERIVATION_FILTER_SOURCE	This flag can be set for a port to enable connection filtering for derivation: A connection from a port marked in such a way to a port which has the DERIVATION_FILTER_TARGET flag set has to pass the filter function NodeSystemDerivationHandlerInterface::FilterDerivationConnection, otherwise it isn't reported by PortFunctions::GetConnections.
DERIVATION_FILTER_TARGET	See DERIVATION_FILTER_SOURCE.
ALL_MASK	Combination of all flags of this enum.

◆ VALUEMODE

enum VALUEMODE : Char

strong

This enum defines what kind of value a port has.

Enumerator
NONE	The port doesn't have a value at all.
DYNAMIC	The port's value is dynamic, so it can't be computed during validation because it depends on values not known at that time.
CONSTANT	The port's value is a known constant, so the EffectivePortValue attribute yields a valid value.
UNKNOWN_CONSTANT	The port's value is an unknown constant. This mode happens when the value mode CONSTANT is injected into a template/group but the corresponding constant value is not injected (because the template/group isn't interested in the value itself).

◆ UNDO_MODE

enum UNDO_MODE

strong

Type of the UndoMode attribute.

Enumerator
NONE	Don't add an undo entry.
START	Start a new undo and create an entry.
ADD	Add an undo entry, but don't start a new undo.

Function Documentation

◆ MAXON_DATATYPE() [1/6]

maxon::nodes::MAXON_DATATYPE	(	ComponentAccessType	,
		"net.maxon.nodes.datatype.componentaccesstype"
	)

◆ MAXON_ATTRIBUTE() [1/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IsComponentAccessBundle	,
		"componentaccessbundleport3"	,
		MAXON_ATTRIBUTE_READONLY
	)

This attribute is true on a port which has component access children ports.

◆ MAXON_ATTRIBUTE() [2/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IsComponentAccessChild	,
		"componentaccesschild3"	,
		MAXON_ATTRIBUTE_READONLY
	)

This attribute is true for a component access child port.

◆ MAXON_ATTRIBUTE() [3/90]

maxon::nodes::MAXON_ATTRIBUTE	(	ComponentAccessDefWithId	,
		ComponentAccessDefAttr	,
		"componentaccessdef"	,
		MAXON_ATTRIBUTE_READONLY
	)

This attribute is set for a component access bundle ports which can potentially use access ports. It links to a definition in either InPortComponentAccessTypes or OutPortComponentAccessTypes.

◆ MAXON_ATTRIBUTE() [4/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		AllowNestedAccess	,
		"co_allownested"
	)

This attribute is set in a component access' definition meta data to enable use of nested access ports. For instance to enable showing decomposed X Y Z ports under a matrix's translation access port.

◆ MAXON_REGISTRY() [1/10]

maxon::nodes::MAXON_REGISTRY	(	ComponentAccessDef	,
		InPortComponentAccessTypes	,
		"net.maxon.node.registry.inportcomponentaccess"
	)

◆ MAXON_REGISTRY() [2/10]

maxon::nodes::MAXON_REGISTRY	(	ComponentAccessDef	,
		OutPortComponentAccessTypes	,
		"net.maxon.node.registry.outportcomponentaccess"
	)

◆ MAXON_ATTRIBUTE() [5/90]

maxon::nodes::MAXON_ATTRIBUTE	(	void	,
		NodeCategoryExistingNodes	,
		"net.maxon.nodecategory.existingnodes"
	)

◆ MAXON_ATTRIBUTE() [6/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataDictionary	,
		PortDescriptionData	,
		"portDescriptionData"
	)

Data/Ui/String description of a node port.

◆ MAXON_ATTRIBUTE() [7/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataDictionary	,
		PortDescriptionUi	,
		"portDescriptionUi"
	)

◆ MAXON_ATTRIBUTE() [8/90]

maxon::nodes::MAXON_ATTRIBUTE	(	LazyLanguageDictionary	,
		PortDescriptionStringLazy	,
		"portDescriptionStringLazy"
	)

◆ MAXON_ATTRIBUTE() [9/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataDescriptionDefinition	,
		NodeDescriptionData	,
		"nodeDescriptionData"
	)

Data/Ui/String descriptions of a group node. Set from Resource Editor/Node Editor while group resources (types, default values, ...) are edited.

◆ MAXON_ATTRIBUTE() [10/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataDescriptionDefinition	,
		NodeDescriptionUi	,
		"nodeDescriptionUi"
	)

◆ MAXON_ATTRIBUTE() [11/90]

maxon::nodes::MAXON_ATTRIBUTE	(	LazyLanguageStringDataDescriptionDefinition	,
		NodeDescriptionStringLazy	,
		"nodeDescriptionStringLazy"
	)

◆ MAXON_REGISTRY() [3/10]

maxon::nodes::MAXON_REGISTRY	(	PortDescriptionProvider	,
		PortDescriptionProviders	,
		"net.maxon.nodes.portdescriptionproviders"
	)

PortDescriptionProvider registry, keys are the node resource ids. Values are the delegates. Delegate will get called every time the node's description has to be updated. Hence the provider will affect the description of all node instance of the "key" node.

◆ MAXON_REGISTRY() [4/10]

maxon::nodes::MAXON_REGISTRY	(	PortEnumDescriptionProvider	,
		PortEnumDescriptionProviders	,
		"net.maxon.nodes.portenumdescriptionproviders"
	)

PortEnumDescriptionProvider registry, keys are the enum token ids. Values are the delegates. Delegate will get called every time a node's description gets updated if the node uses the key as a special enum entry. For instance a Resource Editor enum entry to list all align options would look like this "enum#net.maxon.neutron.datatype.enum.alignaxis" where the token identifier is "enum". This is similar to ProcessEnumListDelegates registry but here you have access to the node graph.

◆ MAXON_ATTRIBUTE() [12/90]

maxon::nodes::MAXON_ATTRIBUTE	(	IdAndVersion	,
		AssetId	,
		"net.maxon.node.attribute.assetid"	,
		MAXON_ATTRIBUTE_READONLY
	)

Id of the asset. Not set in case the node is not an asset (group). The value of this attribute is set automatically upon first request.

◆ MAXON_ATTRIBUTE() [13/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Id	,
		RepositoryId	,
		"net.maxon.node.attribute.repositoryid"	,
		MAXON_ATTRIBUTE_READONLY
	)

Id of the database where the object is stored. The value of this attribute is set automatically upon first request.

◆ MAXON_ATTRIBUTE() [14/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IsInsideAsset	,
		"net.maxon.node.attribute.isinsideasset"	,
		MAXON_ATTRIBUTE_READONLY
	)

True if the node is inside an asset and, thus, not user-accessible during editing of node graph.

◆ MAXON_ENUM_FLAGS() [1/3]

enum maxon::nodes::PORT_FLAGS maxon::nodes::MAXON_ENUM_FLAGS ( PORT_FLAGS )

◆ MAXON_ATTRIBUTE() [15/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		SynthesizedType	,
		"synthesizedtype"	,
		MAXON_ATTRIBUTE_READONLY
	)

This derived attribute tells about the synthesized type of an input or output port. The type is derived from right to left. For ports which have a FixedPortType, the synthesized type is the same as that type. For ports with a variable type such as input ports with a TypeTemplateParameter or a DynamicTypeConstraint the synthesized type is a constraint which defines the minimal requirements for the actual port type.

The value of this attribute is set automatically during validation depending on the port and its connections.

◆ MAXON_ATTRIBUTE() [16/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		OutputTypeConstraint	,
		"outputtypeconstraint"	,
		MAXON_ATTRIBUTE_READONLY
	)

This derived attribute tells about the type constraint of an output port. This is only needed in the context of TypeTemplateParameter output ports. The type constraint is derived from left to right. For ports which have a FixedPortType, the type constraint is the same as that type. Otherwise, for ports with a variable type such as output ports with a TypeTemplateParameter the constraint defines the minimal requirements for the actual port type.

The value of this attribute is set automatically during validation depending on the port and its connections.

◆ MAXON_ATTRIBUTE() [17/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		PortType	,
		"type"	,
		MAXON_ATTRIBUTE_READONLY
	)

This derived attribute tells about the effective type of an input or output port. The value of this attribute is set automatically during validation depending on the port and its connections.

◆ MAXON_ATTRIBUTE() [18/90]

maxon::nodes::MAXON_ATTRIBUTE	(	PORT_FLAGS	,
		PortFlags	,
		"portflags"	,
		MAXON_ATTRIBUTE_READONLY
	)

The PortFlags attribute is a derived attribute which can be queried at a port to get some information about the port, see PORT_FLAGS.

◆ MAXON_DATATYPE() [2/6]

maxon::nodes::MAXON_DATATYPE	(	NodeOrTemplate	,
		"net.maxon.node.datatype.nodeortemplate"
	)

◆ MAXON_INTERNED_ID()

maxon::nodes::MAXON_INTERNED_ID	(	"net.maxon.node.port.nodesystem"	,
		NodeSystemPort
	)

◆ MAXON_ATTRIBUTE() [19/90]

maxon::nodes::MAXON_ATTRIBUTE	(	InternedId	,
		ScaffoldId	,
		"net.maxon.node.attribute.scaffoldid"
	)

Id of the scaffold to which the node is attached. Optional.

◆ MAXON_ATTRIBUTE() [20/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IsEditableGroup	,
		"isgroup"	,
		MAXON_ATTRIBUTE_READONLY
	)

When this attribute is true for the root node of a node system then that node system is a user-editable group. By default, a node system is a user-editable group unless it's a direct instantiation of a non-group template (a template where IsGroupBase() returns false) or an instance of such an instantiation.

◆ MAXON_ATTRIBUTE() [21/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IsConvertibleToGroup	,
		"convertibletogroup"
	)

This attribute can be set to true for a root node of a template instantiation to tell that the instantiation can be converted to a user-editable group.

◆ MAXON_ATTRIBUTE() [22/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IndissolubleGroup	,
		"indissolublegroup"
	)

When this attribute is true for a group node this means that the group can't be dissolved into its components (e.g. because it has some extra semantics like ports which receive context or hidden nodes inherited from a base, for example the loop-carried-value node).

◆ MAXON_ATTRIBUTE() [23/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		IgnoreBase	,
		"ignorebase"
	)

This attribute can be set to true for nodes that will ignore their first base in HasBase and GetAllBases calls.

◆ MAXON_ATTRIBUTE() [24/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InternalDescriptionDerivation	,
		"internaldescriptionderivation"
	)

This attribute can be set on a node to restrict description derivation to the node itself. Any connected nodes aren't considered for description derivation. This can help to speed up description derivation when a node knows that its descriptions are self-contained.

The value of this attribute must not be modified after first validation.

◆ MAXON_ATTRIBUTE() [25/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Asset	,
		AssetInstance	,
		"net.maxon.node.attribute.asset"	,
		MAXON_ATTRIBUTE_READONLY
	)

This attribute contains the node asset's instance. AssetInstance is DerivedAttribute::KIND::COMPUTED and cannot be written to.

◆ MAXON_ATTRIBUTE() [26/90]

maxon::nodes::MAXON_ATTRIBUTE	(	IdAndVersion	,
		OriginalAsset	,
		"net.maxon.node.originalasset"
	)

Set when an asset is converted to group, reset when the group is saved as asset.

◆ MAXON_ATTRIBUTE() [27/90]

maxon::nodes::MAXON_ATTRIBUTE	(	IdAndVersion	,
		CapsuleAssetId	,
		"net.maxon.node.attribute.capsuleassetid"	,
		MAXON_ATTRIBUTE_READONLY
	)

Id and the version of the original Asset Id NodeTemplate of a scene node capsule. The value of this attribute is set on capsule creation and its stored on the root node of the capsule graph.

◆ MAXON_ATTRIBUTE() [28/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Error	,
		ExecutionError	,
		"executionerror"
	)

Set a detailed node error in this attribute to indicate graph execution failure. The message will be visible to users, so it shall be readable. The error can be set on any node (including root node) so that users can pinpoint the source of the issue.

◆ MAXON_ATTRIBUTE() [29/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Error	,
		ExecutionMessage	,
		"executionmsg"
	)

Set a detailed node message in this attribute to indicate graph execution non blocking issue. The message will be visible to users, so it shall be readable. The message can be set on any node (including root node) so that users can pinpoint the source of the issue.

◆ MAXON_REGISTRY() [5/10]

maxon::nodes::MAXON_REGISTRY	(	NodesDescriptionAssetApplyFinalizer	,
		NodesDescriptionAssetApplyFinalizers	,
		"net.maxon.node.registry.asset.nodedescriptionfinalizers"
	)

Register delegates to be called after a NodeDescriptionAsset was applied on a node. Transaction will still be opened.

◆ MAXON_DECLARATION() [1/8]

maxon::nodes::MAXON_DECLARATION	(	NodeSystemClass	,
		BaseCoreNodesNodeSystemClass	,
		"net.maxon.corenode.basenodesystemclass"
	)

This is the base class of node systems which are aware of core nodes. You can inherit from this class to implement your own node space which shall use core nodes to do constant evaluation during validation.

◆ MAXON_DECLARATION() [2/8]

maxon::nodes::MAXON_DECLARATION	(	NodeSystemClass	,
		CoreNodesNodeSystemClass	,
		"net.maxon.corenode.nodesystemclass"
	)

This is the base class of true core-node-based node systems. While BaseCoreNodesNodeSystemClass uses core nodes only to do constant evaluation, a node system based on CoreNodesNodeSystemClass can be compiled into a core node system.

◆ MAXON_DECLARATION() [3/8]

maxon::nodes::MAXON_DECLARATION	(	Factory< DescriptionProcessor(Delegate< Result< Bool >(const NodeSystemClass &cls)> &&support)>	,
		CoreNodesDescriptionProcessor	,
		"net.maxon.corenode.factory.descriptionprocessor"
	)

This factory can be used to create a DescriptionProcessor which builds core-node-based nodes from descriptions. The method NodeTemplateInterface::SupportsImpl of the built node template is implemented by the delegate passed to the factory, so you can easily set up a filter which enables the node only for a specific node system class:

MAXON_DECLARATION_REGISTER(maxon::DescriptionProcessors, "net.maxonsdk.nodespace.corenodedescriptionprocessor")
{
  return maxon::nodes::CoreNodesDescriptionProcessor().Create(
    [] (const maxon::nodes::NodeSystemClass& cls) -> maxon::Result<maxon::Bool>
    {
      return cls.GetClass() == NodeSystemClassExample::GetClass();
    });
}

◆ MAXON_REGISTRY() [6/10]

maxon::nodes::MAXON_REGISTRY	(	ConstantOptimizer	,
		ConstantOptimizers	,
		"net.maxon.nodes.registry.constantoptimizers"
	)

◆ MAXON_ATTRIBUTE() [30/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		FunctionResult	,
		"functionresult"
	)

◆ MAXON_ATTRIBUTE() [31/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		NoCleanupOnFinalize	,
		"skipfinalizemodification"
	)

This attribute can be set at a root node to skip the cleanup during NodeSystemClassFinalizeModification. The usual cleanup made by BaseCoreNodesNodeSystemClass and its subclasses contains the removal of unconnected propagated ports and of description entries which belong to no longer existing ports.

◆ MAXON_REGISTRY() [7/10]

maxon::nodes::MAXON_REGISTRY	(	ImportAdapter	,
		ImportAdapters	,
		"net.maxon.node.registry.importadapters"
	)

The registry of ImportAdapter objects.

◆ MAXON_FORWARD() [1/4]

class NodeTemplate MAXON_FORWARD ( "maxon/nodetemplate.h" )

◆ MAXON_ATTRIBUTE() [32/90]

maxon::nodes::MAXON_ATTRIBUTE	(	void	,
		Messages	,
		"messages"
	)

◆ MAXON_ENUM_FLAGS() [2/3]

enum maxon::nodes::PORT_CONNECTION_STATE maxon::nodes::MAXON_ENUM_FLAGS ( PORT_CONNECTION_STATE )

◆ MAXON_ATTRIBUTE() [33/90]

maxon::nodes::MAXON_ATTRIBUTE	(	PORT_CONNECTION_STATE	,
		PortConnectionState	,
		"portconnectionstate"
	)

The PortConnectionState attribute is a derived attribute which can be queried at a port to get some information about the port connection state (see also PORT_CONNECTION_STATE). For input ports the information is about incoming connections, for output ports about outgoing connections.

◆ MAXON_DECLARATION() [4/8]

maxon::nodes::MAXON_DECLARATION	(	Class< NodeSystemManagerRef >	,
		NodeSystemManagerClass	,
		"net.maxon.node.class.nodesystemmanager"
	)

The default implementation of NodeSystemManagerInterface. This class has to be used as base class for custom implementations.

◆ MAXON_DECLARATION() [5/8]

maxon::nodes::MAXON_DECLARATION	(	Class< NodesGraphModelRef >	,
		NodesGraphModelClass	,
		"net.maxon.node.class.nodesgraphmodel"
	)

The default implementation of NodesGraphModelInterface. This class has to be used as base class for custom implementations.

◆ ToNode()

Result<Node> maxon::nodes::ToNode ( const GraphNode & node )

Converts a GraphNode to a Node. If node doesn't point to a valid true node, an IllegalArgumentError is returned.

Returns: The node as a Node.

◆ ToPortList()

Result<PortList> maxon::nodes::ToPortList ( const GraphNode & node )

Converts a GraphNode to a PortList. If node doesn't point to a valid port list, an IllegalArgumentError is returned.

Returns: The node as a PortList.

◆ ToPort()

Result<Port> maxon::nodes::ToPort ( const GraphNode & node )

Converts a GraphNode to a Port. If node doesn't point to a valid port, an IllegalArgumentError is returned.

Returns: The node as a Port.

◆ ToMutableNode()

Result<MutableNode> maxon::nodes::ToMutableNode ( const GraphNode & node )

Converts a GraphNode to a MutableNode. If node doesn't point to a valid true node, an IllegalArgumentError is returned. If there is no active graph transaction, an IllegalStateError is returned.

Returns: The node as a MutableNode.

◆ ToMutablePortList()

Result<MutablePortList> maxon::nodes::ToMutablePortList ( const GraphNode & node )

Converts a GraphNode to a MutablePortList. If node doesn't point to a valid port list, an IllegalArgumentError is returned. If there is no active graph transaction, an IllegalStateError is returned.

Returns: The node as a MutablePortList.

◆ ToMutablePort()

Result<MutablePort> maxon::nodes::ToMutablePort ( const GraphNode & node )

Converts a GraphNode to a MutablePort. If node doesn't point to a valid port, an IllegalArgumentError is returned. If there is no active graph transaction, an IllegalStateError is returned.

Returns: The node as a MutablePort.

◆ HasBase()

Bool maxon::nodes::HasBase	(	const GraphNode &	node,
		const Id &	asset
	)

Checks if the given node has the node template asset as a base. See NodeSystemInterface::HasBase().

Parameters

[in] asset The asset identifier of a node template.

Returns: True if the node has an instantiation of the template given by asset as a direct or indirect base, false otherwise.

◆ MAXON_ATTRIBUTE() [34/90]

maxon::nodes::MAXON_ATTRIBUTE	(	OriginalGraph	,
		OriginalGraphAttr	,
		"net.maxon.nimbus.originalgraph"
	)

◆ MAXON_FORWARD() [2/4]

class NodeSystemData maxon::nodes::MAXON_FORWARD ( "maxon/nodesystem_data.h" )

◆ MAXON_FORWARD() [3/4]

class NodeSystemClass MAXON_FORWARD ( "maxon/nodesystem_class.h" )

◆ MAXON_FORWARD() [4/4]

class NodeSystemDerivationHandler maxon::nodes::MAXON_FORWARD ( "maxon/nodesystem_derivation.h" )

◆ MAXON_ENUM_FLAGS() [3/3]

enum maxon::nodes::GNODE_FLAGS UInt64 maxon::nodes::MAXON_ENUM_FLAGS ( GNODE_FLAGS )

◆ MAXON_ENUM_LIST() [1/2]

enum maxon::nodes::VALUEMODE Char maxon::nodes::MAXON_ENUM_LIST ( VALUEMODE )

◆ MAXON_DATATYPE() [3/6]

maxon::nodes::MAXON_DATATYPE	(	MutableRoot	,
		"net.maxon.node.datatype.mutableroot"
	)

◆ MAXON_DECLARATION() [6/8]

maxon::nodes::MAXON_DECLARATION	(	NodeSystemClass	,
		DefaultNodeSystemClass	,
		"net.maxon.node.nodesystemclass"
	)

The base implementation class of NodeSystemClass. You have to use this class as base class whenever you implement NodeSystemClassInterface. It implements all methods.

◆ MAXON_DECLARATION() [7/8]

maxon::nodes::MAXON_DECLARATION	(	Class< NodeSystemDerivationHandler >	,
		NodeSystemDerivationHandlerBaseClass	,
		"net.maxon.node.class.nodesystemderivationhandlerbase"
	)

The base implementation class of NodeSystemDerivationHandler. You can use this class as base class whenever you implement a derivation handler.

◆ PrivateGetDataType()

ResultOk<const DataType&> maxon::nodes::PrivateGetDataType	(	TemplateArguments **	,
		OverloadRank0
	)

◆ MAXON_ATTRIBUTE() [35/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Url	,
		InstantiateContextBasePath	,
		"net.maxon.nodes.nodesystem.instantiatecontext.basepath"
	)

PRIVATE.

◆ MAXON_ATTRIBUTE() [36/90]

maxon::nodes::MAXON_ATTRIBUTE	(	AssetMetaData	,
		InstantiateContextMeta	,
		"net.maxon.node.nodesystem.instantiatecontext.metadata"
	)

PRIVATE.

◆ MAXON_REGISTRY() [8/10]

maxon::nodes::MAXON_REGISTRY	(	Delegate< Result< void >(const MutableRoot &)>	,
		DescriptionFinalizers	,
		"net.maxon.node.registry.descriptionfinalizers"
	)

An InstantiationTrace is used as argument for NodeTemplate::Instantiate to track the nesting of calls to that method and prevent infinite recursions. Whenever an implementation of NodeTemplateInterface::InstantiateImpl calls that method itself, it has to check before that the current instantiation hasn't already been made in an enclosing call (because then we'd run into an infinite recursion), and it has to add the current instantiation to the trace:

    MAXON_METHOD Result<NodeSystem> InstantiateImpl(const InstantiationTrace& parent, const TemplateArguments& args) const
    {
      iferr_scope;
   
      if (parent.Contains(self, args, nullptr))
      {
        // This would lead to infinite recursion, handle error case.
        ...
      }
      else
      {
        // The current instantiation isn't part of the parent trace, we can instantiate another template.
        // We have to add the current instantiation to the trace when calling Instantiate.
        NodeSystem other = someTemplate.Instantiate(InstantiationTrace(parent, self, args, nullptr), someArguments) iferr_return;
        ...
      }
      ...
    }
//----------------------------------------------------------------------------------------
class InstantiationTrace
{
public:
  //----------------------------------------------------------------------------------------
      Extends an instantiation trace by a further element. This can be used within
      NodeTemplateInterface::InstantiateImpl when another instantiation is made, see InstantiationTrace.
      @param[in] parent             The parent InstantiationTrace.
      @param[in] nt                 The current NodeTemplate (which wants to make an instantiation itself).
      @param[in] args               The arguments for the current NodeTemplate nt.
      @param[in] extra              Some extra value to mark this element of the trace, will be used for Contains.
  //----------------------------------------------------------------------------------------
  InstantiationTrace(const InstantiationTrace& parent, const NodeTemplate& nt, const TemplateArguments& args, const void* extra) : _class(parent._class), _repository(parent._repository), _context(parent._context), _parent(&parent), _template(nt), _arguments(args), _extra(extra)
  {
  }
 
  //----------------------------------------------------------------------------------------
      Checks if the instantiation (t, args, extra) is already contained in this instantiation trace.
      This is to prevent infinite recursions when a NodeTemplate instantiates another NodeTemplate, see InstantiationTrace.
      @param[in] t                  A node template.
      @param[in] args               Template arguments for t.
      @param[in] extra              This pointer has to match the extra value given for the InstantiationTrace constructor.
      @return                       true if (t, args, extra) is already contained in this trace, false otherwise.
  //----------------------------------------------------------------------------------------
  Bool Contains(const NodeTemplate& t, const TemplateArguments& args, const void* extra) const
  {
    return ContainsImpl(t, &args, extra);
  }
 
  //----------------------------------------------------------------------------------------
      Checks if the instantiation (t, extra) is already contained in this instantiation trace (template arguments are ignored for the comparison).
      This is to prevent infinite recursions when a NodeTemplate instantiates another NodeTemplate, see InstantiationTrace.
      @param[in] t                  A node template.
      @param[in] extra              This pointer has to match the extra value given for the InstantiationTrace constructor.
      @return                       true if (t, extra) is already contained in this trace (ignoring template arguments), false otherwise.
  //----------------------------------------------------------------------------------------
  Bool Contains(const NodeTemplate& t, const void* extra) const
  {
    return ContainsImpl(t, nullptr, extra);
  }
 
  //----------------------------------------------------------------------------------------
      Checks if the instantiation (t, args, extra) is already contained in this instantiation trace.
      This is to prevent infinite recursions when a NodeTemplate instantiates another NodeTemplate, see InstantiationTrace.
      @param[in] t                  The identifier of a node template.
      @param[in] args               Template arguments for t.
      @param[in] extra              This pointer has to match the extra value given for the InstantiationTrace constructor.
      @return                       true if (t, args, extra) is already contained in this trace, false otherwise.
  //----------------------------------------------------------------------------------------
  Bool Contains(const Id& t, const TemplateArguments& args, const void* extra) const
  {
    return ContainsImpl(t, &args, extra);
  }
 
  //----------------------------------------------------------------------------------------
      Returns the node system class to use for instantiations. This has been set by the constructor
      of the outmost trace element.
      @return                       The node system class to use.
  //----------------------------------------------------------------------------------------
  const NodeSystemClass& GetNodeSystemClass() const
  {
    return _class.Get();
  }
 
  //----------------------------------------------------------------------------------------
      Returns the asset repository to use for asset lookup. This has been set by the constructor
      of the outmost trace element.
      @return                       The asset repository to use.
  //----------------------------------------------------------------------------------------
  const AssetRepositoryRef& GetLookupRepository() const
  {
    return _repository;
  }
 
  const DataDictionary& GetAdditionalContext() const
  {
    return _context;
  }
 
  //----------------------------------------------------------------------------------------
      Constructs the beginning of an instantiation trace.
      @param[in] cls                The node system class to use.
      @param[in] repo               The asset repository to use for lookup of assets.
  //----------------------------------------------------------------------------------------
  InstantiationTrace(const NodeSystemClass& cls, const AssetRepositoryRef& repo) : _class(reinterpret_cast<const ForwardRef<NodeSystemClass>&>(cls)), _repository(repo), _context()
  {
  }
 
  //----------------------------------------------------------------------------------------
      Constructs the beginning of an instantiation trace.
      @param[in] cls                The node system class to use.
      @param[in] repo               The asset repository to use for lookup of assets.
      @param[in] additionalContext  Supplementary instantiation context parameters.
  //----------------------------------------------------------------------------------------
  InstantiationTrace(const NodeSystemClass& cls, const AssetRepositoryRef& repo, const DataDictionary& additionalContext) : _class(reinterpret_cast<const ForwardRef<NodeSystemClass>&>(cls)), _repository(repo), _context(additionalContext)
  {
  }
 
  //----------------------------------------------------------------------------------------
      Creates a new node system using the node system class and lookup repository of this InstantiationTrace.
      This is the same as @c{trace.GetNodeSystemClass().CreateNodeSystem(trace.GetLookupRepository())}.
      @return                       The MutableRoot of a new empty compound node system.
  //----------------------------------------------------------------------------------------
  Result<MutableRoot> CreateNodeSystem() const;
 
  //----------------------------------------------------------------------------------------
      Creates an @ref usernodes_instancing "instance" of the given node system,
      see NodeSystem::CreateInstance().
      This is the same as @c{system.CreateInstance(trace.GetLookupRepository())}.
     
      Whenever the node system needs to do an asset lookup during the following modifications,
      the lookup repository of this InstantiationTrace is used.
     
      @param[in] system             The node system of which an instance shall be created.
      @return                       A MutableRoot of a new node system which uses the given system as its base.
  //----------------------------------------------------------------------------------------
  Result<MutableRoot> CreateInstance(const NodeSystem& system) const;
 
private:
  Bool ContainsImpl(const NodeTemplate& t, const TemplateArguments* args, const void* extra) const;
  Bool ContainsImpl(const Id& t, const TemplateArguments* args, const void* extra) const;
 
  ForwardRef<NodeSystemClass> _class;
  AssetRepositoryRef _repository;
  DataDictionary _context;
  const InstantiationTrace* const _parent = nullptr;
  const NodeTemplate _template = {};
  const TemplateArguments _arguments = {};
  const void* const _extra = nullptr;
 
  friend class NodeTemplateInterface;
  friend class NodeSystemImpl;
};
 
 
//----------------------------------------------------------------------------------------
    A base implementation class of NodeTemplate. You can use this class as
    base class whenever you implement NodeTemplateInterface. It provides default
    implementations for all methods except NodeTemplateInterface::Instantiate.
//----------------------------------------------------------------------------------------
MAXON_DECLARATION(Class<NodeTemplate>, NodeTemplateBaseClass, "net.maxon.node.class.nodetemplatebase");
 
 
//----------------------------------------------------------------------------------------
    A base implementation class for a decorator of NodeTemplate. You can use this class as
    base class whenever you implement such a decorator. The class forwards calls
    of all methods of NodeTemplateInterface to the decorated object.
//----------------------------------------------------------------------------------------
MAXON_DECLARATION(Class<NodeTemplate>, NodeTemplateDecoratorBaseClass, "net.maxon.node.class.nodetemplatedecoratorbase");
 
 
 
//----------------------------------------------------------------------------------------
    This registry contains all built-in nodes (those which are defined by code or by resource descriptions).
    They are also accessible via the built-in asset repository, however the built-in
    repository returns a decorated version which has resource descriptions and meta data
    from BuiltinNodesMetaData applied on top and also caches instantiations of the node template.
    In general you should work with the decorated version, there's the convenience method
    @c{NodesLib::LoadBuiltinTemplate} for that purpose.
   
    The macro MAXON_DECLARATION_REGISTER_BUILTINNODE helps to register a built-in node.
//----------------------------------------------------------------------------------------
MAXON_REGISTRY(NodeTemplate, BuiltinNodes, "net.maxon.node.registry.builtinnodes");
 
//----------------------------------------------------------------------------------------
    This registry contains meta data for built-in nodes when they are accessed via the
    built-in asset repository.
//----------------------------------------------------------------------------------------
MAXON_REGISTRY(DataDictionary, BuiltinNodesMetaData, "net.maxon.node.registry.builtinnodesmetadata");
 
 
//----------------------------------------------------------------------------------------
    This registry collects delegates which are called after descriptions have been applied
    on top of nodes registered at BuiltinNodes. You have to register a delegate using
    the exact id of the node whose description shall be finalized. For example to override
    values of the first knot of the gradient node (so that it differs from the second knot,
    per-knot-values can't be defined in the resource description at the moment) the following code is used:
    @code{nodes_descriptionfinalizer}
    MAXON_DECLARATION_REGISTER(nodes::DescriptionFinalizers, PATTERN::NODE::GENERATOR::GRADIENT::GetId())
    {
      return nodes::DescriptionFinalizers::EntryType([] (const nodes::MutableRoot& root)-> Result<void>
      {
        iferr_scope;
        nodes::MutablePort knot0 = root.GetInputs().FindPort(PATTERN::NODE::GENERATOR::GRADIENT::GRADIENT).FindPort(Id("_0")) iferr_return;
        if (knot0)
        {
          knot0.FindPort(RENDER::PORTBUNDLE::GRADIENT::COLOR).SetPortValue(ColorA()) iferr_return;
          knot0.FindPort(RENDER::PORTBUNDLE::GRADIENT::POSITION).SetPortValue(Float(0.0)) iferr_return;
        }
        return OK;
      });
    }

◆ MAXON_ATTRIBUTE() [37/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InheritNestedPorts	,
		"inheritnestedports"
	)

This attribute controls whether nested ports shall be derived for a port or not. The derivation is based on the nested ports of connected source ports, i.e., it goes from left to right. By default the value of this attribute is true.

See also: SynthesizeNestedPorts

◆ MAXON_ATTRIBUTE() [38/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizeNestedPorts	,
		"synthesizenestedports"
	)

This attribute controls whether nested ports shall be derived for a port or not. The derivation is based on the nested ports of connected target ports, i.e., it goes from right to left. By default the value of this attribute is true.

See also: InheritNestedPorts

◆ MAXON_ATTRIBUTE() [39/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InheritNestedPortsSource	,
		"inheritnestedportssource"
	)

This attribute controls whether the port is used as source for the derivation of nested ports. Only if the value is true connected downstream ports will inherit nested ports of this port. By default the value of this attribute is true.

See also: InheritPortSource; InheritNestedPorts

◆ MAXON_ATTRIBUTE() [40/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizeNestedPortsSource	,
		"synthesizenestedportssource"
	)

This attribute controls whether the port is used as source for the derivation of nested ports. Only if the value is true connected upstream ports will inherit nested ports of this port. By default the value of this attribute is true.

See also: SynthesizeNestedPorts; SynthesizePortSource

◆ MAXON_ATTRIBUTE() [41/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InheritPortSource	,
		"inheritportsource"
	)

This attribute controls whether the port is used as source for the derivation of nested ports. Only if the value is true this port will be inherited to a connected downstream port of its parent port. By default the value of this attribute is true.

See also: InheritNestedPortsSource

◆ MAXON_ATTRIBUTE() [42/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizePortSource	,
		"synthesizeportsource"
	)

This attribute controls whether the port is used as source for the derivation of nested ports. Only if the value is true this port will be inherited to a connected upstream port of its parent port. By default the value of this attribute is true.

See also: SynthesizeNestedPortsSource

◆ MAXON_ATTRIBUTE() [43/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizeTypeSource	,
		"synthesizetypesource"
	)

This attribute controls whether the port is used as source for the derivation of the data type. Only if the value is true connected upstream ports will use the data type in the derivation. By default the value of this attribute is true.

◆ MAXON_ATTRIBUTE() [44/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		LoopDependencySource	,
		"loopdependencysource"
	)

This attribute has to be set to true for a port which is the source of a loop-carried dependency. Corresponding targets have to be marked with LoopDependencyTarget and reachable through dependency wires, where the first wire (starting at the source) needs to have a parallel slink wire and the last wire (reaching the target) needs to have a parallel tlink wire.

◆ MAXON_ATTRIBUTE() [45/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		LoopDependencyTarget	,
		"loopdependencytarget"
	)

This attribute has to be set to true for a port which is the target of a loop-carried dependency, see LoopDependencySource.

◆ MAXON_ATTRIBUTE() [46/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		Dynamic	,
		"dynamic"
	)

This attribute tells whether the port's value is usually set or computed at run-time of the compiled node system. You have to mark all run-time inputs of a node system with this flag, also a node with an underlying computation method for the values of its output ports (for example, a core node wrapper) has to set this value for all of its outputs. Note that the value of the port may still be computed at compile-time as a constant value during validation if all required inputs have constant values.

The value of this attribute must not be modified after first validation.

◆ MAXON_ATTRIBUTE() [47/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		HierarchicalDynamic	,
		"hierarchicaldynamic"
	)

This attribute has the same effect as Dynamic, but works hierarchically and won't be serialized. The value is used not only for the port itself, but also for all of its nested ports unless overridden by a further attribute assignment. It may only be used at unconnected input ports.

◆ MAXON_ATTRIBUTE() [48/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		TransientDynamic	,
		"transientdynamic"
	)

This attribute is similar to Dynamic, but it may be modified after first validation and won't be serialized. It's used for ports which are dynamic due to node-system-external circumstances, for example when a port's value is animated from the outside.

◆ MAXON_ATTRIBUTE() [49/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		TemplateParameter	,
		"templateparameter"
	)

This attribute has to be set for input ports which define a template parameter of a NodeTemplate. It enables a special handling of those ports during validation: Whenever the effective value of such a port doesn't match the value used for the template instantiation, the template is re-instantiated with the effective value as argument for the template parameter, and the new instantiation replaces the previous one in the node system.

A variadic port which is a template parameter of a NodeTemplate has to be marked with DESCRIPTION::DATA::BASE::ISVARIADIC instead, this also activates the special handling.

See also: TypeTemplateParameter; BundleTemplateParameter

◆ MAXON_ATTRIBUTE() [50/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		AllowDynamicArgument	,
		"allowdynamicargument"
	)

This attribute can be set on a port to allow the node's output to be a VALUE_MODE::CONSTANT (validation time known value). It can be used on meta nodes which often transform a VALUE_MODE::DYNAMIC input into some VALUE_MODE::CONSTANT output. In other words, the attribute will prevent the flags PORT_FLAGS::CONSTANT and PORT_FLAGS::USED_FOR_TEMPLATE_ARGUMENT from propagating from the node's downstream connections to the input port with #AllowDynamicArgument set. By default the value of this attribute is false.

◆ MAXON_ATTRIBUTE() [51/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		TypeTemplateParameter	,
		"porttypetemplateparameter"
	)

This attribute has to be set for input ports whose PortType defines a template parameter of a NodeTemplate. Similar to TemplateParameter it enables a special handling of those ports during validation: whenever the port type of such a port doesn't match the value used for the template instantiation (which can be found in the TemplateArgument attribute of the port) the template is re-instantiated with the port type as argument for the template parameter, and the new instantiation replaces the previous one in the node system.

The value of this attribute is not just a Bool but a DataType which defines a constraint for the allowed template arguments (using the function DataType::IsBaseOfOrSame). For example

Generic poses no restrictions
GenericArithmetic allows only arithmetic types
Array<Generic> allows arrays of arbitrary type.

◆ MAXON_ATTRIBUTE() [52/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		BundleTemplateParameter	,
		"bundletemplateparameter"
	)

This attribute has to be set for ports whose set of nested ports defines a template parameter of a NodeTemplate. Similar to TemplateParameter it enables a special handling of those ports during validation: whenever the set of nested ports of such a port doesn't match the value used for the template instantiation, the template is re-instantiated with the set as argument for the template parameter, and the new instantiation replaces the previous one in the node system.

◆ MAXON_ATTRIBUTE() [53/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		ValueModeTemplateParameter	,
		"valuemodetemplateparameter"
	)

This attribute has to be set for ports whose value mode defines a template parameter of a NodeTemplate. Similar to TemplateParameter it enables a special handling of those ports during validation: whenever the value mode of such a port doesn't match the value used for the template instantiation, the template is re-instantiated with the new mode as argument for the template parameter, and the new instantiation replaces the previous one in the node system.

◆ MAXON_ATTRIBUTE() [54/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Data	,
		TemplateArgument	,
		"templateargument"	,
		MAXON_ATTRIBUTE_READONLY
	)

This attribute is a computed attribute which can be queried for template parameter ports and returns the actually used template argument for that parameter. Usually this is the same as the EffectivePortValue, but there are cases where both differ, for example if EffectivePortValue has an illegal template argument which the node template substitutes by a legal one.

◆ MAXON_ATTRIBUTE() [55/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		StickyTypeTemplateParameter	,
		"stickyporttypetemplateparameter"
	)

This attribute is useful only when combined with TypeTemplateParameter attribute (true). Otherwise, the attribute just has no effect. It allows the template argument to stick to the port even if the type template source port is disconnected. In other words, the port will remember the last data type that was connected to it even if disconnected. Usually, this allows to have a NodeTemplate maintain its outputs after a template input is disconnected, otherwise outgoing connections could be lost. If false, a NodeTemplate will get reinstantiated after disconnection of the template input. The sticky (true) state is useful when some output ports are defined from the type template argument (to avoid losing ports). By default the value of this attribute is true.

◆ MAXON_ATTRIBUTE() [56/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Error	,
		TemplateError	,
		"templateerror"
	)

Set a detailed NodeTemplate error in this attribute to indicate graph validation failure using a red colored node or group. The message will be visible to users, so it shall be readable. This error is quite useful to avoid cases of incompatible scenes after type changes or type removal.

◆ MAXON_ATTRIBUTE() [57/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		ConstantParameter	,
		"constantparameter"
	)

This attribute has to be set for input ports which require a constant value. Whenever the user connects the port in a way such that a constant value for the port can't be computed, this is an error in the node setup.

◆ MAXON_ATTRIBUTE() [58/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizePortValue	,
		"synthesizevalue"
	)

This attribute can be set by a NodeTemplate at a port to prevent the derivation of a PortValue for that port. By default the value of this attribute is true.

◆ MAXON_ATTRIBUTE() [59/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		TappingPort	,
		"tappingport"
	)

This attribute has to be set for ports whose values shall be accessible at evaluation time.

◆ MAXON_ATTRIBUTE() [60/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		Permanent	,
		"permanent"
	)

This attribute has to be set to true for ports which mustn't be deleted.

◆ MAXON_ATTRIBUTE() [61/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		HiddenFromInside	,
		"hiddeninside"
	)

This attribute can be set to true for ports which shall be hidden when seen from the inside (so when they belong to the group which is currently shown in the node editor).

◆ MAXON_ATTRIBUTE() [62/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		HiddenFromOutside	,
		"hiddenoutside"
	)

This attribute can be set to true for ports which shall be hidden when seen from the outside (so when they belong to a child node of the group which is currently shown in the node editor).

◆ MAXON_ATTRIBUTE() [63/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InternalHidden	,
		"net.maxon.node.attribute.internalhidden"
	)

This attribute can be set for nodes or ports to hide them. Defaults to false.

◆ MAXON_ATTRIBUTE() [64/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		FixedPortType	,
		"fixedtype"
	)

This attribute has to be set for input or output ports which have a known fixed type (as opposed to a port with a dynamic type which is derived from e.g. its connections).

◆ MAXON_ATTRIBUTE() [65/90]

maxon::nodes::MAXON_ATTRIBUTE	(	DataType	,
		DynamicTypeConstraint	,
		"dynamictypeconstraint"
	)

This attribute has to be set for input ports with a dynamic type when there shall be a constraint on the set of allowed types. This is not needed for TypeTemplateParameter ports because there the constraint is automatically taken from the value of the TypeTemplateParameter attribute. The value of this attribute is used for the derivation of the SynthesizedType.

◆ MAXON_ATTRIBUTE() [66/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		EnforceType	,
		"enforcetype"
	)

This attribute can be set to true for a port which has a valid FixedPortType to enforce that values flowing through that port are converted to the port type. It is only needed for ports which just forward the value. For example the ports of a wrapped core node dont't have to set this attribute because value forwarding ends at those ports anyway, but the value node needs to set it because it just forwards values from its input port to its output port. Without this attribute the port types of intermediate ports are ignored.

◆ MAXON_ATTRIBUTE() [67/90]

maxon::nodes::MAXON_ATTRIBUTE	(	TupleDataType	,
		FunctionParameters	,
		"functionparams"
	)

You have to set this attribute at the final port of a subgraph which shall be compiled into a function. The members of the given TupleDataType are the function parameters, and the port (and its nested ports) define the function results. The function parameters become context members of the subgraph, so they can be queried anywhere in that subgraph by using ports with a matching ContextReference attribute.

◆ MAXON_ATTRIBUTE() [68/90]

maxon::nodes::MAXON_ATTRIBUTE	(	InternedId	,
		ContextReference	,
		"ctxref"
	)

You have to set this attribute at a port which, when it doesn't receive a value through a connection or a default value, shall receive the value from the context member identified by the given InternedId.

◆ MAXON_ATTRIBUTE() [69/90]

maxon::nodes::MAXON_ATTRIBUTE	(	InternedId	,
		ContextDefinition	,
		"ctxdef"
	)

You have to set this attribute at a port which is used to provide values for context members if the port's name doesn't match the desired name of the context members.

◆ MAXON_ATTRIBUTE() [70/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		ExternalContext	,
		"externalcontext"
	)

You have to set this attribute if a port shall define context members for its immediately enclosing port.

◆ MAXON_ATTRIBUTE() [71/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		CreatedByPropagation	,
		"net.maxon.node.createdbypropagation"
	)

A port can be marked with this flag if it has been created by propagation of a port of an inner node to its enclosing node. Then it will automatically be removed by NodeSystemClassInterface::FinalizeModification when the inner propagation connection is removed.

◆ MAXON_ATTRIBUTE() [72/90]

maxon::nodes::MAXON_ATTRIBUTE	(	NodePath	,
		PortGroup	,
		"net.maxon.node.portgroup"
	)

A port can be put into a port group by this attribute. The port group is only used for visual purposes, it has no functional meaning. The NodePath is used as a group path, so if a port shall be part of a top-level group then use a NodePath of one element, for a nested group you have to use more path elements. This is deprecated, use PortDescriptionUi for group assignments. Deprecated.

◆ MAXON_ATTRIBUTE() [73/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Int	,
		ReqOrderIndex	,
		"net.maxon.node.attribute.orderindex"
	)

The ReqOrderIndex attribute is used to define the order of ports within the same parent. The values needn't be contiguous, just their relative order matters. Defaults to 0.

◆ MAXON_ATTRIBUTE() [74/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Int	,
		ReqInsertIndex	,
		"net.maxon.node.attribute.insertindex"
	)

The InsertIndex attribute tells about the temporal order in which sibling ports have been added to the graph. This is not to be confused with OrderIndex which defines the actual order to use. Defaults to 0.

◆ MAXON_ATTRIBUTE() [75/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		OverrideOrderIndex	,
		"overrideorderindex"
	)

This attribute can be set on ports for which a NodeTemplate wants to keep control over the ordering of some or all of it's ports. If set to true, the ReqOrderIndex set on the port by the NodeTemplate will be kept when resources are applied on the node. By default the value of this attribute is false.

◆ MAXON_ATTRIBUTE() [76/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		ForceVariadicPortNameDerivation	,
		"forcevariadicportnamederivation"
	)

This attribute is set to enforce the name derivation mechanism for variadic ports.

◆ MAXON_ATTRIBUTE() [77/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		DisableVariadicPortNameDerivation	,
		"disablevariadicportnamederivation"
	)

This attribute is set to prevent the name derivation mechanism for variadic ports. DisableVariadicPortNameDerivation will override ForceVariadicPortNameDerivation (if latter is set to true, i.e. it is applied after ForceVariadicPortNameDerivation).

◆ MAXON_ATTRIBUTE() [78/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		InheritUiAttributes	,
		"inherituiattributes"
	)

This attribute can be set to false for a port to prevent that UI attributes are inherited from connected upstream ports. By default the value of this attribute is true.

◆ MAXON_ATTRIBUTE() [79/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		SynthesizeUiAttributes	,
		"synthesizeuiattributes"
	)

This attribute can be set to false for a port to prevent that UI attributes are synthesized from connected downstream ports. By default the value of this attribute is true.

◆ MAXON_DATATYPE() [4/6]

maxon::nodes::MAXON_DATATYPE	(	Chain	,
		"net.maxon.node.datatype.chain"
	)

◆ MAXON_ATTRIBUTE() [80/90]

maxon::nodes::MAXON_ATTRIBUTE	(	StrongCOWRef< Chain >	,
		ChainCounterPort	,
		"chaincounterport"
	)

◆ MAXON_ATTRIBUTE() [81/90]

maxon::nodes::MAXON_ATTRIBUTE	(	InternedId	,
		GlobalContext	,
		"globalcontext"
	)

This attribute can be set for ports which shall receive a global context value. Such a global context value can't be overridden in the node system. The value of this attribute identifies which global context value shall be set for the port.

◆ MAXON_ATTRIBUTE() [82/90]

maxon::nodes::MAXON_ATTRIBUTE	(	InternedId	,
		ScenePortMode	,
		"sceneportmode"	,
		MAXON_ATTRIBUTE_READONLY
	)

The ScenePortMode attribute is a derived attribute which can be queried at a port to get the NODE::ATTRIBUTE::SCENEPORTMODE attribute with the exception that for a variadic port the value of ScenePortMode is always SCENEPORTMODE_ENUM_NONE. This is useful because a variadic scene port has a scene port mode, but is no scene port itself (only its instances are).

◆ MAXON_ATTRIBUTE() [83/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		UseAttributeResources	,
		"useattributeresources"
	)

This attribute can be set to true for port bundles if the resources of member ports shall be obtained from attribute resources.

◆ MAXON_ATTRIBUTE() [84/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		AllowMultipleConnections	,
		"allowmultipleconnections"
	)

This attribute has to be set to true for ports which shall allow the creation of multiple incoming connections via the node editor.

◆ MAXON_ATTRIBUTE() [85/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		StreamPort	,
		"streamport"
	)

This flag can be set for streamed output ports of iteration nodes and streamed input port of aggregation nodes to enable extra indication in the node editor.

◆ MAXON_ATTRIBUTE() [86/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		ScopePort	,
		"scopeport"
	)

This flag can be set for scope ports to enable extra indication in the node editor.

◆ MAXON_ATTRIBUTE() [87/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		RerouterPort	,
		"rerouterport"
	)

This attribute is set to true for the input and output ports of a reroute node.

◆ MAXON_ATTRIBUTE() [88/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		FloatingPort	,
		"floatingport"
	)

This attribute is set to true for the input and output ports of a floating node.

◆ MAXON_REGISTRY() [9/10]

maxon::nodes::MAXON_REGISTRY	(	GraphAttribute	,
		Attributes	,
		"net.maxon.node.registry.attributes"
	)

This registry contains GraphAttributes which implement a special handling of the attribute for node systems, see NodeSystemClassInterface::GetGraphAttribute. You can use this to register your own attributes, for example to register an attribute which shall be transient (not saved during serialization):

MAXON_ATTRIBUTE(Bool, CheckUniqueNumber, "checkuniquenumber");
...
MAXON_DECLARATION_REGISTER(Attributes, )
{
  objectId = CheckUniqueNumber;
  return GraphLib::CreateAttribute(CheckUniqueNumber, GraphAttribute::FLAGS::DIRECT | GraphAttribute::FLAGS::TRANSIENT | GraphAttribute::FLAGS::META);
}

◆ MAXON_REGISTRY() [10/10]

maxon::nodes::MAXON_REGISTRY	(	NodeSpaceRef	,
		MaterialNodeSpaces	,
		"net.maxon.nodes.registry.materialnodespaces"
	)

The registry of all material node spaces. This registry is monitored for changes by Cinema4d. Add and remove operations are picked up by GUI components, offering the user to select among the registered spaces.

◆ MAXON_DECLARATION() [8/8]

maxon::nodes::MAXON_DECLARATION	(	Class< NodeSpaceRef >	,
		NodeSpaceBaseClass	,
		"net.maxon.class.nodespace.base"
	)

The base components implements the thread-safe paradigm for data change notification, including

GetData()
SetData()
AddDataChangedObserver() In addition, it implements a fallback initialization for incomplete data containers passed into Init():
maxon::nodes::NODESPACE::SPACEID is assigned to GetClass().GetId()
If maxon::nodes::NODESPACE::SPACENAME is missing, it's assigned with the stringified SPACEID
If maxon::nodes::NODESPACE::VIEWPORTMATERIALCLASS is missing, it's assigned with a constant gray dielectric viewport material.

It is encouraged to make use of the NodeSpaceBaseClass:

class MySpace : public maxon::Component<MySpace, maxon::nodes::NodeSpaceInterface>
{
  MAXON_COMPONENT(NORMAL, maxon::nodes::NodeSpaceBaseClass);
public:
  MAXON_METHOD maxon::Result<void> Init(maxon::DataDictionary spaceData)
    {
      iferr_scope;
 
      // Initialize spaceData attributes
 
      return super.Init(spaceData); // Make use of the fallback init.
    }
};

◆ MAXON_ENUM_LIST() [2/2]

enum maxon::nodes::UNDO_MODE maxon::nodes::MAXON_ENUM_LIST ( UNDO_MODE )

◆ MAXON_ATTRIBUTE() [89/90]

maxon::nodes::MAXON_ATTRIBUTE	(	UNDO_MODE	,
		UndoMode	,
		"net.maxon.nodes.undomode"
	)

UndoMode controls the automatic creation of an undo entry in the undo buffer. Usually an entry in the undo buffer of Cinema 4D is added whenever a transaction is started for the currently edited node graph. If you set this attribute to UNDO_MODE::NONE in the dictionary which is passed to GraphModelRef::BeginTransaction no undo entry is added.

◆ MAXON_ATTRIBUTE() [90/90]

maxon::nodes::MAXON_ATTRIBUTE	(	Bool	,
		NimbusUndoAttribute	,
		"net.maxon.nodes.nimbusundoattribute"
	)

◆ MAXON_DATATYPE() [5/6]

maxon::nodes::MAXON_DATATYPE	(	PackedMaterialParameter	,
		"net.maxon.nodes.datatype.packedmaterialparameter"
	)

◆ MAXON_DATATYPE() [6/6]

maxon::nodes::MAXON_DATATYPE	(	PreviewImageProviderOutputImage	,
		"net.maxon.nodes.datatype.previewimageprovideroutputimage"
	)

Variable Documentation

◆ IsGroup

const IsEditableGroup_PrivateHelper& IsGroup

static

◆ g_corePrefix

constexpr Char g_corePrefix[]

staticconstexpr

Id prefix used for filling the AssetId attribute on wrapped CoreNodes. The rest of the Id will be the CoreNode's real registered Id. Private.

◆ g_lifetimeNodePrefix

constexpr Char g_lifetimeNodePrefix

staticconstexpr

Lifetime node identifier prefix. The rest of the identifier is the identifier of the associated port. For instance: ".containerin". Private.

◆ g_userNodeIdSeparator

constexpr Char g_userNodeIdSeparator

staticconstexpr

Private.

◆ MAXON_ENUM_FLAGS

maxon::nodes::NodeSystemManagerInterface MAXON_ENUM_FLAGS

◆ MAXON_ENUM_LIST

class maxon::nodes::GraphSetUndoMode MAXON_ENUM_LIST

Detailed Description

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ComponentAccessDef

◆ ComponentAccessDefWithId

◆ LanguageDictionary

◆ PortDescriptionProvider

◆ PortEnumDescriptionProvider

◆ NodesDescriptionAssetApplyFinalizer

◆ ConstantOptimizer

◆ OriginalGraph

◆ NodesGraphHelper

◆ GNodeSelector

◆ PortListSelector

◆ PortSelector

◆ Connection

◆ MutableConnection

◆ ConnectionSelector

◆ NodeSelector

◆ PortFunctionsSuper

◆ NodePathArraySet

◆ NodePathArraySetRef

◆ SampleFloat32

◆ SamplesFloat32

◆ SamplesFloat32Ref

◆ SamplesFloat32ConstRef

◆ PreviewImageSubscriptionResultFunc

Enumeration Type Documentation

◆ PORT_FLAGS

◆ PORT_CONNECTION_STATE

◆ GNODE_FLAGS

◆ VALUEMODE

◆ UNDO_MODE

Function Documentation

◆ MAXON_DATATYPE() [1/6]

◆ MAXON_ATTRIBUTE() [1/90]

◆ MAXON_ATTRIBUTE() [2/90]

◆ MAXON_ATTRIBUTE() [3/90]

◆ MAXON_ATTRIBUTE() [4/90]

◆ MAXON_REGISTRY() [1/10]

◆ MAXON_REGISTRY() [2/10]

◆ MAXON_ATTRIBUTE() [5/90]

◆ MAXON_ATTRIBUTE() [6/90]

◆ MAXON_ATTRIBUTE() [7/90]

◆ MAXON_ATTRIBUTE() [8/90]

◆ MAXON_ATTRIBUTE() [9/90]

◆ MAXON_ATTRIBUTE() [10/90]

◆ MAXON_ATTRIBUTE() [11/90]

◆ MAXON_REGISTRY() [3/10]

◆ MAXON_REGISTRY() [4/10]

◆ MAXON_ATTRIBUTE() [12/90]

◆ MAXON_ATTRIBUTE() [13/90]

◆ MAXON_ATTRIBUTE() [14/90]

◆ MAXON_ENUM_FLAGS() [1/3]

◆ MAXON_ATTRIBUTE() [15/90]

◆ MAXON_ATTRIBUTE() [16/90]

◆ MAXON_ATTRIBUTE() [17/90]

◆ MAXON_ATTRIBUTE() [18/90]

◆ MAXON_DATATYPE() [2/6]

◆ MAXON_INTERNED_ID()

◆ MAXON_ATTRIBUTE() [19/90]

◆ MAXON_ATTRIBUTE() [20/90]

◆ MAXON_ATTRIBUTE() [21/90]

◆ MAXON_ATTRIBUTE() [22/90]

◆ MAXON_ATTRIBUTE() [23/90]

◆ MAXON_ATTRIBUTE() [24/90]

◆ MAXON_ATTRIBUTE() [25/90]

◆ MAXON_ATTRIBUTE() [26/90]

◆ MAXON_ATTRIBUTE() [27/90]

◆ MAXON_ATTRIBUTE() [28/90]

◆ MAXON_ATTRIBUTE() [29/90]

◆ MAXON_REGISTRY() [5/10]

◆ MAXON_DECLARATION() [1/8]

◆ MAXON_DECLARATION() [2/8]

◆ MAXON_DECLARATION() [3/8]