Detailed Description

This class is a specialization of CICEAttributeDataArray to give access to the ICEAttribute data as a 1D array of type siICENodeDataCustomType. CICEAttributeDataArrayCustomType objects are read-only and can be filled with the methods supplied with the ICEAttribute class.

Note:: Data of type siICENodeDataCustomType can be created with custom ICENodes.

See also:: ICEAttribute::GetDataArray, ICEAttribute::GetDataArrayChunk, CICEAttributeDataArray2DCustomType, Type Definitions for CICEAttributeDataArray

Since:: 8.0 (2010)

Example:

This example demonstrates how to iterate over the siICENodeDataCustomType attributes on a geometry. Check out the SDK InspectICEAttributes sample for a more detailed example.

        using namespace XSI;

        Application app;
        X3DObject x3dObj = app.GetSelection().GetItem(0);
        ICEAttribute attr = x3dObj.GetActivePrimitive().GetGeometry().GetICEAttributeFromName( L"SomeCustomDataTypeAttribute" );

        // Log the data pointer address and size of data.
        CICEAttributeDataArrayCustomType customData;
        attr.GetDataArray( customData );

        for( ULONG i=0; i<customData.GetCount( ); i++ )
        {
            ULONG nSize;
            const CICEAttributeDataArrayCustomType::TData* pBuffer;
            customData.GetData( i, &pBuffer, nSize );

            app.LogMessage( CString( (void*)pBuffer ) + L":" + CString( nSize ) );
        }

#include <xsi_iceattributedataarray.h>

Inheritance diagram for CICEAttributeDataArrayCustomType:

[legend]

List of all members.

Public Member Functions
SICPPSDK_INLINE	CICEAttributeDataArrayCustomType ()
SICPPSDK_INLINE	~CICEAttributeDataArrayCustomType ()
SICPPSDK_INLINE CStatus	GetData (ULONG in_index, const TData **out_ppData, ULONG &out_nSize) const
CStatus	SetArray (const TData **in_ppData, ULONG in_count, ULONG in_fixedElemSize)
CStatus	SetArray (const TData *in_ppData, ULONG in_count, ULONG in_pElementSizes)

Constructor & Destructor Documentation

SICPPSDK_INLINE CICEAttributeDataArrayCustomType ( ) [inline]

Default Constructor.

SICPPSDK_INLINE ~CICEAttributeDataArrayCustomType ( ) [inline]

Destructor.

Member Function Documentation

CStatus GetData	(	ULONG	in_index,
		const TData **	out_ppData,
		ULONG &	out_nSize
	)		const

Returns a pointer to the user data stored at a specific index. The data is read-only and cannot be modified.

Note:: The memory allocated for the data returned by CICEAttributeDataArrayCustomType::GetData is only available within the scope of this CICEAttributeDataArrayCustomType instance. Make sure to make a copy of the data if you need to access it outside the scope of CICEAttributeDataArrayCustomType.

Parameters:

in_index Array index of the user data to retrieve. The size is 0 if no data is stored at this index.

Return values:

out_ppData	Read-only pointer to the data.
out_nSize	Size in bytes of the user data.

Returns:: Success/failure

CStatus SetArray	(	const TData **	in_ppData,
		ULONG	in_count,
		ULONG	in_fixedElemSize
	)

Set the values in the custom-typed data array

Parameters:

in_ppData	The input custom-typed array. All elements must have the same size.
in_count	Number of elements in the input array
in_fixedElemSize	The fixed size of all elements

Returns:: CStatus::OK Success.; CStatus::Fail Operation failed.

Since:: 12.0 (2014)

Example:

This example demonstrates how to set the whole CustomType array

        // Data structure holding the states for each particule
        struct GridWalkerState
        {
            ULONG m_nRandomSequencePosition;
            ULONG m_nCurrentStep;

            LONG m_nCurrentPositionX, m_nCurrentPositionY;
            LONG m_nDirectionX, m_nDirectionY;

            GridWalkerState()
            {
                m_nRandomSequencePosition = 0;
                m_nCurrentStep = 0;

                m_nCurrentPositionX = 0;
                m_nCurrentPositionY = 0;
                m_nDirectionX = 0;
                m_nDirectionY = 0;
            }

            GridWalkerState(    ULONG in_nRandomSequencePosition,
                                        ULONG in_nCurrentStep,

                                        ULONG in_nCurrentPositionX,
                                        ULONG in_nCurrentPositionY,
                                        ULONG in_nDirectionX,
                                        ULONG in_nDirectionY)
            {
                m_nRandomSequencePosition = in_nRandomSequencePosition;
                m_nCurrentStep =            in_nCurrentStep;

                m_nCurrentPositionX =   in_nCurrentPositionX;
                m_nCurrentPositionY =   in_nCurrentPositionY;
                m_nDirectionX =         in_nDirectionX;
                m_nDirectionY =         in_nDirectionY;
            }

            const GridWalkerState& operator=(const GridWalkerState& other)
            {
                m_nRandomSequencePosition = other.m_nRandomSequencePosition;
                m_nCurrentStep =            other.m_nCurrentStep;

                m_nCurrentPositionX =   other.m_nCurrentPositionX;
                m_nCurrentPositionY =   other.m_nCurrentPositionY;
                m_nDirectionX =         other.m_nDirectionX;
                m_nDirectionY =         other.m_nDirectionY;

                return *this;
            }

            operator CString() const
            {
                CString result;
                result = L"[";
                result += L"Random Sequence Pos:";
                result += CString(m_nRandomSequencePosition) + CString(L", ");
            
                result += L"Step:";
                result += CString(m_nCurrentStep) + L", ";

                result += L"X:";
                result += CString(m_nCurrentPositionX) + L", ";

                result += L"Y:";
                result += CString(m_nCurrentPositionY) + L", ";

                result += L"Dir X:";
                result += CString(m_nDirectionX) + L", ";

                result += L"Dir Y:";
                result += CString(m_nDirectionY);

                result += L"]";
                return result;
            }
        };

        template < class CustomType >
        class CICEAttributeDataLoggerCustomType
        {
        public:
            static void Log( ICEAttribute& attr )
            {
                CICEAttributeDataArrayCustomType data;
                attr.GetDataArray( data );

                Application xsi;
                for( ULONG i=0; i<data.GetCount( ); i++ )
                {
                    CustomType val;
                    const CICEAttributeDataArrayCustomType::TData* addr = NULL;
                    ULONG size=0;
                    data.GetData(i, &addr, size);

                    if (addr != NULL && size>0)
                    {
                        val = *(CustomType*)addr;
                        xsi.LogMessage( CString(val) );
                    }
                }
            }
        };

        Application app;

        // Loads the GridWalker custom node plug-in from the examples workgroup 
        CString strWrkgrp = CUtils::BuildPath( app.GetInstallationPath(siFactoryPath ), "..", "..", "Rayflex", "Sdk", "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[1] = false;
        app.ExecuteCommand( "OpenScene", args, retval );

        // Logs custom data type
        CStringArray strNoFamily;
        CString strNoType;
        Geometry geom( app.GetActiveSceneRoot().FindChild("grid", strNoType, strNoFamily).GetActivePrimitive().GetGeometry() );
        ICEAttribute attr = geom.GetICEAttributeFromName( "GridWalkerState" );

        {
            typedef GridWalkerState* CustomTypePtr;

            CICEAttributeDataArrayCustomType data;
            attr.GetDataArray( data );

            CICEAttributeDataLoggerCustomType<GridWalkerState>::Log( attr );

            ULONG l_nbElem = attr.GetElementCount();

            {
                CustomTypePtr* l_Values = new CustomTypePtr[l_nbElem];

                for (ULONG i=0; i<l_nbElem; i++)
                {
                    if (i%2==0)
                        l_Values[i] = new GridWalkerState(0, 0, 0, 0, 0, 0);
                    else
                        l_Values[i] = new GridWalkerState(1, 1, 1, 1, 1, 1);
                }

                data.SetArray((const unsigned char**)l_Values, l_nbElem, sizeof(GridWalkerState));
            
                CICEAttributeDataLoggerCustomType<GridWalkerState>::Log( attr );

                for (ULONG i=0; i<l_nbElem; i++)
                {
                    delete l_Values[i];
                }

                delete[] l_Values;
            }

            {
                const ULONG CHUNK_SIZE = 10;
                CustomTypePtr* l_Values = new CustomTypePtr[CHUNK_SIZE];

                for (ULONG i=0; i<CHUNK_SIZE; i++)
                {
                    l_Values[i] = new GridWalkerState(i + 2, i + 2, i + 2, i + 2, i + 2, i + 2);
                }

                CICEAttributeDataArrayCustomType dataChunk;
                attr.GetDataArrayChunk(2, CHUNK_SIZE, dataChunk);

                data.SetArray((const unsigned char**)l_Values, CHUNK_SIZE, sizeof(GridWalkerState));

                CICEAttributeDataLoggerCustomType<GridWalkerState>::Log( attr );

                for (ULONG i=0; i<CHUNK_SIZE; i++)
                {
                    delete l_Values[i];
                }

                delete[] l_Values;
            }

        }

CStatus SetArray	(	const TData **	in_ppData,
		ULONG	in_count,
		ULONG *	in_pElementSizes
	)

Set the values in the custom-typed data array

Parameters:

in_ppData	Input custom-typed array. The element sizes can vary.
in_count	Number of elements in the input array
in_pElementSizes	Array specifying the sizes of the elements.

Returns:: CStatus::OK Success.; CStatus::Fail Operation failed.

Since:: 12.0 (2014)

The documentation for this class was generated from the following file:

xsi_iceattributedataarray.h

Detailed Description

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation