Public Member Functions
ICENodePort Class Reference

Detailed Description

ICENodePort is the base class for ICENode ports such as ICENodeInputPort and ICENodeOutputPort.

A ICENodePort is a connection point on a ICENode and connects to other ICENodePort objects. ICENodePort may be connected to something or not connected at all. Ports are organized in groups similar to the Softimage operator Port objects where groups are logical groupings of multiple port connections.

See also:
ICENodeInputPort, ICENodeOutputPort, ICENode
Since:
7.0
Example:
This example shows how to access the ports of ICENode objects 
        void CreateNodeGraph( );
        void TraverseNodeGraph( const ICENode& in_node );
        void LogICENodePort( const ICENodePort& in_nodeport );

        // Create the node graph first
        CreateNodeGraph( );

        // Get the ICETree off the cube primitive and start navigating the graph
        Application xsi;
        Selection sel = xsi.GetSelection();
        X3DObject cube = sel[0];

        ICETree cubeICETree = cube.GetActivePrimitive().GetICETrees()[0];

        TraverseNodeGraph( cubeICETree );

        // ICENodePort introspection
        void LogICENodePort( const ICENodePort& in_nodeport )
        {
            Application xsi;

            // Log info
            xsi.LogMessage( L"* * *" );

            xsi.LogMessage( L"node port: " + in_nodeport.GetFullName() );
            xsi.LogMessage( L"node port parent: " + SIObject(in_nodeport.GetParent()).GetFullName() );
            xsi.LogMessage( L"node port class: " + in_nodeport.GetClassIDName() );
            xsi.LogMessage( L"output node port: " + CString(in_nodeport.IsOutput()) );
            xsi.LogMessage( L"connected: " + CString(in_nodeport.IsConnected()) );
            xsi.LogMessage( L"group port index: " + CString(in_nodeport.GetIndex()) );
            xsi.LogMessage( L"group index: " + CString(in_nodeport.GetGroupIndex()) );
            xsi.LogMessage( L"group instance index: " + CString(in_nodeport.GetGroupInstanceIndex() ) );
            xsi.LogMessage( L"data type: " + CString(in_nodeport.GetDataType()) );
            xsi.LogMessage( L"structure type: " + CString(in_nodeport.GetStructureType()) );
            xsi.LogMessage( L"evaluation context type: " + CString(in_nodeport.GetContextType()) );

            CRefArray connectednodes = in_nodeport.GetConnectedNodes();
            LONG nCount = connectednodes.GetCount();
            xsi.LogMessage( L"connected nodes: " + CString(nCount) );
            for (LONG i=0; i<nCount; i++)
            {
                xsi.LogMessage( L"connected node: " + SIObject(connectednodes[i]).GetName() );
            }

            // Log port parameters
            CRefArray params = in_nodeport.GetParameters();
            for (LONG i=0; i<params.GetCount(); i++)
            {
                Parameter param = params[i];
                xsi.LogMessage( L"parameter: " + param.GetScriptName() + L":" + CString(param.GetValue()) );
            }
        }

        void TraverseNodeGraph( const ICENode& in_node )
        {
            Application xsi;

            // Log info on the visited node name
            xsi.LogMessage( L"* * * * * * * * * * " );
            xsi.LogMessage( L"node: " + in_node.GetFullName() );

            // Node input port info
            CRefArray inPorts = in_node.GetInputPorts();
            LONG nCount = inPorts.GetCount();
            xsi.LogMessage( L"node input ports: " + CString(nCount) );

            for (LONG i=0; i<nCount; i++)
            {
                LogICENodePort( inPorts[i] );
            }

            // Node output port info
            CRefArray outPorts = in_node.GetOutputPorts();
            nCount = outPorts.GetCount();
            xsi.LogMessage( L"node output ports: " + CString(nCount) );

            for (LONG i=0; i<nCount; i++)
            {
                LogICENodePort( outPorts[i] );
            }

            CRefArray nodes;
            if ( in_node.IsA( siICENodeContainerID ) )
            {
                //The input node might be a ICETree or ICECompoundNode, let's get their ICENodes
                ICENodeContainer container( in_node.GetRef() );
                nodes = container.GetNodes();
            }

            //  Recursively traverse the graph
            for (LONG i=0; i<nodes.GetCount(); i++)
            {
                TraverseNodeGraph( nodes[i] );
            }
        }

        CValue CreateICECompoundNode( const CValue&  in_inputobj, const CString& in_name );
        void CreatePrim( const CString& in_presetobj, const CString& in_geometrytype, const CString& in_name, const CString& in_parent );
        CValue SetValue( const CString& in_target, const CValue&  in_value, const CValue&  in_time = CValue() );
        CRefArray ApplyOp( const CString& in_presetobj, CString & io_connectionset, const siConstructionMode& in_constructionmode );
        CValue AddICENode( const CValue&  in_presetobj, const CValue&  in_container );
        void AddAttributeToSetDataICENode( const CValue&  in_setdatanode, const CString& in_attributename, siComponentDataType in_attributetype, siComponentDataContext in_attributecontext, siComponentDataStructure in_attributestructure );
        void ConnectICENodes( const CValue&  in_inputport, const CValue&  in_outputport );

        // Create a twist deformer graph on a cube
        void CreateNodeGraph( )
        {
            CreatePrim( L"Cube", L"MeshSurface", L"", L"" );
            SetValue( L"cube.polymsh.geom.subdivu", 15, 0 );
            SetValue( L"cube.polymsh.geom.subdivv", 14, 0 );

            CString strCube(L"cube");
            ApplyOp( L"ICETree", strCube, siConstructionModeModeling );

            AddICENode( L"GetDataNode", L"cube.polymsh.ICETree" );
            SetValue( L"cube.polymsh.ICETree.SceneReferenceNode.Reference", L"cube.polymsh.PointPosition" );
            AddICENode( L"RotateVectorNode", L"cube.polymsh.ICETree" );
            AddICENode( L"3DVectorToScalarNode", L"cube.polymsh.ICETree" );
            AddICENode( L"SetData", L"cube.polymsh.ICETree" );
            SetValue( L"cube.polymsh.ICETree.SetData.PredefinedAttributeName", L"PointPosition" );
            AddAttributeToSetDataICENode( L"cube.polymsh.ICETree.SetData", L"PointPosition", siComponentDataTypeVector3, siComponentDataContextComponent0D, siComponentDataStructureSingle );
            ConnectICENodes( L"cube.polymsh.ICETree.port1", L"cube.polymsh.ICETree.SetData.set" );
            ConnectICENodes( L"cube.polymsh.ICETree.RotateVectorNode.vector", L"cube.polymsh.ICETree.SceneReferenceNode.value" );
            ConnectICENodes( L"cube.polymsh.ICETree.SetData.pointposition", L"cube.polymsh.ICETree.RotateVectorNode.result" );
            ConnectICENodes( L"cube.polymsh.ICETree.3DVectorToScalarNode.vector", L"cube.polymsh.ICETree.SceneReferenceNode.value" );
            AddICENode( L"MultiplyNode", L"cube.polymsh.ICETree" );
            ConnectICENodes( L"cube.polymsh.ICETree.MultiplyNode.value1", L"cube.polymsh.ICETree.3DVectorToScalarNode.y" );
            AddICENode( L"ScalarToRotationNode", L"cube.polymsh.ICETree" );
            ConnectICENodes( L"cube.polymsh.ICETree.ScalarToRotationNode.angle", L"cube.polymsh.ICETree.MultiplyNode.result" );
            ConnectICENodes( L"cube.polymsh.ICETree.RotateVectorNode.rotation", L"cube.polymsh.ICETree.ScalarToRotationNode.rotation" );
            SetValue( L"cube.polymsh.ICETree.ScalarToRotationNode.y", 1 );
            SetValue( L"cube.polymsh.ICETree.ScalarToRotationNode.x", 0 );
            SetValue( L"cube.polymsh.ICETree.MultiplyNode.value2", 20 );
            CreateICECompoundNode( L"cube.polymsh.ICETree.3DVectorToScalarNode,cube.polymsh.ICETree.MultiplyNode,cube.polymsh.ICETree.ScalarToRotationNode", L"Compound1");
            CreateICECompoundNode( L"cube.polymsh.ICETree.Compound1.ScalarToRotationNode,cube.polymsh.ICETree.Compound1.MultiplyNode", L"Compound2");
        }

        // Command stubs used by CreateNodeGraph
        CValue CreateICECompoundNode( const CValue&  in_inputobj, const CString& in_name )
        {
            CValueArray args(2);
            CValue retval;

            args[0]= in_inputobj;
            args[1]= in_name;

            Application app;
            CStatus st = app.ExecuteCommand( L"CreateICECompoundNode", args, retval );

            return retval;
        }
        void CreatePrim( const CString& in_presetobj, const CString& in_geometrytype, const CString& in_name, const CString& in_parent )
        {
            CValueArray args(4);
            CValue retval;

            args[0]= in_presetobj;
            args[1]= in_geometrytype;
            args[2]= in_name;
            args[3]= in_parent;

            Application app;
            CStatus st = app.ExecuteCommand( L"CreatePrim", args, retval );

            return;
        }
        CValue SetValue( const CString& in_target, const CValue& in_value, const CValue&  in_time )
        {
            CValueArray args(3);
            CValue retval;

            args[0]= in_target;
            args[1]= in_value;
            args[2]= in_time;

            Application app;
            CStatus st = app.ExecuteCommand( L"SetValue", args, retval );

            return retval;
        }

        CRefArray ApplyOp( const CString& in_presetobj, CString & io_connectionset, const siConstructionMode& in_constructionmode )
        {
            CValueArray args(6);
            CValue retval;

            args[0]=in_presetobj;
            args[1]=io_connectionset;
            args[2]=(LONG)siUnspecified;
            args[3]=(LONG)siPersistentOperation;
            if ( in_constructionmode != siConstructionModeDefault )
            {
                args[5]=(LONG)in_constructionmode;
            }

            Application app;
            CStatus st = app.ExecuteCommand( L"ApplyOp", args, retval );
            io_connectionset=args[1];
            return retval;
        }

        CValue AddICENode( const CValue&  in_presetobj, const CValue&  in_container )
        {
            CValueArray args(2);
            CValue retval;

            args[0]= in_presetobj;
            args[1]= in_container;

            Application app;
            CStatus st = app.ExecuteCommand( L"AddICENode", args, retval );

            return retval;
        }
        void AddAttributeToSetDataICENode( const CValue&  in_setdatanode, const CString& in_attributename, siComponentDataType in_attributetype, siComponentDataContext in_attributecontext, siComponentDataStructure in_attributestructure )
        {
            CValueArray args(5);
            CValue retval;

            args[0]= in_setdatanode;
            args[1]= in_attributename;
            args[2]= (LONG)in_attributetype;
            args[3]= (LONG)in_attributecontext;
            args[4]= (LONG)in_attributestructure;

            Application app;
            CStatus st = app.ExecuteCommand( L"AddAttributeToSetDataICENode", args, retval );

            return;
        }
        void ConnectICENodes( const CValue&  in_inputport, const CValue&  in_outputport )
        {
            CValueArray args(2);
            CValue retval;

            args[0]= in_inputport;
            args[1]= in_outputport;

            Application app;
            CStatus st = app.ExecuteCommand( L"ConnectICENodes", args, retval );

            return;
        }

#include <xsi_icenodeport.h>

Inheritance diagram for ICENodePort:
Inheritance graph
[legend]

List of all members.

Public Member Functions

 ICENodePort ()
 ~ICENodePort ()
 ICENodePort (const CRef &in_ref)
 ICENodePort (const ICENodePort &in_obj)
bool IsA (siClassID in_ClassID) const
siClassID GetClassID () const
ICENodePort & operator= (const ICENodePort &in_obj)
ICENodePort & operator= (const CRef &in_ref)
bool IsConnected () const
bool IsOutput () const
LONG GetIndex () const
LONG GetGroupInstanceIndex () const
LONG GetGroupIndex () const
XSI::siICENodeDataType GetDataType () const
XSI::siICENodeStructureType GetStructureType () const
XSI::siICENodeContextType GetContextType () const
CRefArray GetConnectedPorts () const
CRefArray GetConnectedNodes () const
CRefArray GetParameters () const
CStringArray GetCustomDataTypes () const

Constructor & Destructor Documentation

ICENodePort ( )

Default constructor.

~ICENodePort ( )

Default destructor.

ICENodePort ( const CRef &  in_ref)

Constructor.

Parameters:
in_refconstant reference object.
ICENodePort ( const ICENodePort &  in_obj)

Copy constructor.

Parameters:
in_objconstant class object.

Member Function Documentation

bool IsA ( siClassID  in_ClassID) const [virtual]

Returns true if a given class type is compatible with this API class.

Parameters:
in_ClassIDclass type.
Returns:
true if the class is compatible, false otherwise.

Reimplemented from SIObject.

Reimplemented in ICENodeInputPort, and ICENodeOutputPort.

siClassID GetClassID ( ) const [virtual]

Returns the type of the API class.

Returns:
The class type.

Reimplemented from SIObject.

Reimplemented in ICENodeInputPort, and ICENodeOutputPort.

ICENodePort& operator= ( const ICENodePort &  in_obj)

Creates an object from another object. The newly created object is set to empty if the input object is not compatible.

Parameters:
in_objconstant class object.
Returns:
The new ICENodePort object.
ICENodePort& operator= ( const CRef &  in_ref)

Creates an object from a reference object. The newly created object is set to empty if the input reference object is not compatible.

Parameters:
in_refconstant class object.
Returns:
The new ICENodePort object.

Reimplemented from SIObject.

Reimplemented in ICENodeInputPort, and ICENodeOutputPort.

bool IsConnected ( ) const

Returns a boolean value indicating whether the port is connected (true) or not (false).

Returns:
True if port is connected.
See also:
ICENode::IsConnected
bool IsOutput ( ) const

Returns a boolean value indicating whether the port direction is output (true) or input (false).

Returns:
The port direction flag.
See also:
ICENodeOutputPort
LONG GetIndex ( ) const

Returns the index of this port within its port group.

Note:
This property refers to the index of the port within the ICENodePort group. It is different from the index used to access the array of ports returned by ICENode::GetInputPorts, ICENode::GetOutputPorts, and ICENodePort::GetConnectedPorts.
Returns:
The port index.
LONG GetGroupInstanceIndex ( ) const

Returns the node port group instance that this port belongs to. There may be many objects of the same type connected to the same port group. Each ICENode is connected to a port group instance, and within the port group instance there may be many ports.

Returns:
The port group instance index.
LONG GetGroupIndex ( ) const

Returns the node port group index to which this port belongs.

Returns:
The port group index.
XSI::siICENodeDataType GetDataType ( ) const

Returns the data type for this port as an siICENodeDataType value. The returned type identifies the data that can travel through this port.

Returns:
The port data type.
XSI::siICENodeStructureType GetStructureType ( ) const

Returns the data structure type for this port as an siICENodeStructureType value. The returned type identifies how the data is structured: data can be a single element or an array.

Returns:
The port data structure type.
XSI::siICENodeContextType GetContextType ( ) const

Returns the context type for this port as an siICENodeContextType value. The returned type identifies the element set associated with the data (cardinality), such as vertices, polygons, or newly created particles.

Returns:
The port evaluation context type.
CRefArray GetConnectedPorts ( ) const

Returns all the ICENodePort objects connected to this port. ICENodeInputPort objects can only have one connected port; on the other hand, ICENodeOutputPort objects can have multiple ports connected. The returned array is empty if the port is not connected.

Returns:
Array of references to the connected ports.
CRefArray GetConnectedNodes ( ) const

Returns all the ICENode objects connected to this port. ICENodeInputPort objects can only have one connected node; ICENodeOutputPort objects can have multiple nodes connected.

Returns:
Array of references to the connected ICENode objects.
CRefArray GetParameters ( ) const

Returns all the Parameter objects defined for this port. For instance, calling ICENodePort::GetParameters on a port which supports the ::siICENodeDataVector3 data type will return an array of 3 parameters: x, y, z. These parameters can then be used for setting keys for instance.

Returns:
Array of references to the parameters for this port.
CStringArray GetCustomDataTypes ( ) const

Returns an array of custom data types defined for this ICENodePort. Custom data types are defined by custom ICENodes and are used as data type for defining custom ICEPorts and ICEAttributes.

Returns:
Array of custom data type names. Returns an empty array if no custom types are defined on this port.
See also:
ICENodeDef::DefineCustomType
ICEAttribute::GetCustomDataTypes
Since:
8.0 (2010)
Example:
This example demonstrates how to access custom data types from ICENodePort objects. 
        Application app;

        // Loads the GridWalker custom node plug-in from the examples workgroup
        CString strWrkgrp = CUtils::BuildPath( app.GetInstallationPath(siFactoryPath ), "XSISDK", "examples", "workgroup" );
        app.AddWorkgroup( strWrkgrp  );

        // Opens the GridWalker scene containing custom data types
        CValueArray args(2);
        CValue retval;
        args[0] = CUtils::BuildPath( strWrkgrp, "Addons", "CustomICENodes", "Data", "Project", "Scenes", "GridWalker" ) + ".scn";
        args[2] = false;
        app.ExecuteCommand( "OpenScene", args, retval );

        // Logs ports with custom data types
        CStringArray strNoFamily;
        CString strNoType;
        ICETree tree = app.GetActiveSceneRoot().FindChild("grid", strNoType, strNoFamily).GetActivePrimitive().GetICETrees()[0];
        ICENode node = tree.GetNodes().GetItem("GridWalker");

        CRefArray inPorts = node.GetInputPorts();
        for ( ULONG i=0; i<inPorts.GetCount(); i++ )
        {
            ICENodePort p = inPorts[i];
            if ( p.GetDataType() == siICENodeDataCustomType )
            {
                app.LogMessage( CString("Custom data type for input port <") + p.GetName() + ">: " + p.GetCustomDataTypes()[0] );
            }
        }

        CRefArray outPorts = node.GetOutputPorts();
        for ( ULONG i=0; i<outPorts.GetCount(); i++ )
        {
            ICENodePort p = outPorts[i];
            if ( p.GetDataType() == siICENodeDataCustomType )
            {
                app.LogMessage( CString("Custom data type for output port <") + p.GetName() + ">: " + p.GetCustomDataTypes()[0] );
            }
        }

        // Output:
        // # INFO : Custom data type for input port <InState>: GridWalkState_v1
        // # INFO : Custom data type for output port <OutState>: GridWalkState_v1
The documentation for this class was generated from the following file:
Generated on Mon Jul 9 2012 13:43:09 by doxygen 1.7.4
Please send us your comment about this page