Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

_tXSI_RTS_Attribute_Size | The XSI_RTS_Attribute_Size structure
_XSI_RTS_Attribute | Defines the attributes to consider when rendering geometry data. These XSI_RTS_Attribute structs are returned in the GetAttributeList callback function
CDataArray2D< T >::Accessor | A class for accessing the sub-array data of CDataArray2D objects
CDataArray2D< bool >::Accessor | A class for accessing the sub-array data of CDataArray2D< bool > objects
CDataArray2DString::Accessor | Accessor gives access to the string data stored in a CDataArray2DString object
CDataArray2DCustomType::Accessor | Accessor gives access to the user data values stored in a CDataArray2DCustomType object
ActionDelta | The ActionDelta object tracks changes made on a parameter that is part of a reference model. Every ActionDelta contains one or more ActionDeltaItem objects, each of which represents a single change, or modification, to a referenced parameter. Each ActionDelta object has a specific type (see siModificationDeltaType) and each ActionDeltaItem it contains is of the same type
ActionDeltaItem | The ActionDeltaItem object tracks changes made on a parameter that is part of a reference model. Each ActionDeltaItem represents a single change, or modification, to a referenced parameter. So each time there a change to a static value, an FCurve, a Constraint, an Expression or a GroupRelation, a new ActionDeltaItem is generated
ActionSource | Specialization of the Source class, representing sources for action and shape animation clips
AnimationSource | The AnimationSource object represents a special kind of DataSource, for example, ActionSource, Constraint, FCurve, Expression, or StaticSource
AnimationSourceItem | An ActionSource contains a collection of animation source items, which you can get at using ActionSource::GetItems. The AnimationSourceItem class provides access to the animation DataSource (for example, an FCurve) and a target entity such as the Parameter or Cluster which the animation source drives
Annotation | Specialized X3DObject used for inserting text annotation in a scene
Application | The Application object represents the running instance of the Softimage application and it is the top most entity of the C++ API object hierarchy. Application contains properties that return other Softimage objects such as the active scene root
Argument | The Argument object represents an argument (or parameter) of a Softimage Command. For example, the DeleteObj command takes 1 argument (`InputObj`)
ArgumentArray |
ArgumentHandler | An argument handler is an object that helps determine the value that is passed to a Command
ArrayParameter | An ArrayParameter is a specialization of a Parameter
Camera | The Camera object represents a Softimage camera in a scene
CameraRig | The CameraRig object is a specialized Null object that represents a hierarchy composed of a Camera and its X3DObject interest object
CBase | CBase is the base class of all API classes and provides access to Softimage objects through generic CRef objects. The class defines a runtime type information sytem (RTTI) and CRef attachment support for API classes
CBaseICEAttributeDataArray | Base class CICEAttributeDataArray class for the CICEAttributeDataArray and CICEAttributeDataArray2D template classes
CBitArray | This class encapsulates an array of binary values represented as booleans, where true indicates a bit set to ON and false indicates a bit set to OFF
CBoolArray | The CBoolArray is an uni-dimensional array of bool values
CClusterElementArray | An array of cluster elements in a Cluster object
CClusterPropertyBuilder | Provides the services to accelerate the process of creating new cluster properties on a geometry
CClusterPropertyElementArray | An array of cluster property elements in a ClusterProperty object
CColor | This struct represents an RGBA color
CColor4f | A color class represented by single floating values. CColor4f supports the RGBA, HSVA and HLSA color models
CColorArray | The CColorArray is a one-dimensional, zero-based array of CColor objects
CComAPIHandler | Implements a C++ wrapper for calling automation objects (scripting objects) or objects implemented using the Softimage Object Model (formerly called the COM API)
CControlPointRefArray | An array of ControlPoint object references representing the NurbsCurve or NurbsSurface control points
CDataArray< T > | This template class encapsulates the 1D data arrays passed to custom node plug-ins during a graph evaluation. The underlying data arrays are zero-based, the following types are available:
CDataArray2D< T > | This template class encapsulates 2D data arrays that are passed to custom node plug-ins during a graph evaluation. The underlying data arrays are zero-based, the following types are available:
CDataArray2D< bool > | This class is a specialization of a CDataArray2D class of type `bool`
CDataArray2DCustomType | CDataArray2DCustomType is used for storing binary data in a 2D element array of type CDataArray2DCustomType::TData
CDataArray2DString | CDataArray2DString is used for storing strings in a 2D element array
CDataArray< bool > | This class is a specialization of a CDataArray class of type `bool`
CDataArrayCustomType | CDataArrayCustomType is used for storing binary data in a 1D element array of type CDataArrayCustomType::TData
CDataArrayString | CDataArrayString is used for storing wide character strings in a 1D element array
CDoubleArray | The CDoubleArray is an uni-dimensional array of doubles
CEdgeRefArray | Array of Edge objects
CMeshBuilder::CErrorDescriptor | This class reports the error status returned by CMeshBuilder::Build. If the mesh builder fails, the faulty indices are reported by this object
CFacetRefArray | An array of Facet objects representing all segments of the underlying Geometry object
CFCurveKeyRefArray | This class represents an array of keys on a function curve (FCurve). Duplicate keys are not allowed and a single array can only hold keys from the same fcurve
CFloatArray | The CFloatArray is an uni-dimensional array of floats
CGeometryAccessor | The mesh geometry accessor provides an optimized access to the data and cluster property values of a geometry mesh object. CGeometryAccessor is suitable for data export application as it allows access to geometry data more quickly and efficiently than the regular geometry API classes
CGraphicSequencer | The CGraphicSequencer object offers several services to enable custom rendering passes in the OpenGL viewport
ChainBone | The ChainBone object is part of a skeleton chain
ChainEffector | The ChainEffector object is part of a skeleton chain
ChainElement | The ChainElement object represents a component of a skeleton chain
ChainRoot | The ChainRoot object represents the root of a skeleton chain
CHardwareAttribute | Represents an attribute defined by hardware shaders a.k.a real-time shaders. CHardwareAttribute is typically used for defining standard vertex semantics (siHardwareInputSemantic) used in shader languages such as CgFX and HLSL. CHardwareAttribute can also be used for defining shader parameters of siShaderParameterType type
CHardwareAttributeArray | The CHardwareAttributeArray is an uni-dimensional array of CHardwareAttribute
CICEAttributeDataArray< T > | This template class encapsulates ICEAttribute data as a 1D array. CICEAttributeDataArray objects are read-only and can be filled with the methods supplied with the ICEAttribute class. CICEAttributeDataArray is zero-based and can be one of the following types:
CICEAttributeDataArray2D< T > | This template class encapsulates ICEAttribute data as a 2D array. CICEAttributeDataArray2D objects are read-only and can be filled with the methods supplied with the ICEAttribute class. CICEAttributeDataArray2D is zero-based and can be one of the following types:
CICEAttributeDataArray2DCustomType | This class is a specialization of CICEAttributeDataArray to give access to the ICEAttribute data as a 2D array of type siICENodeDataCustomType. CICEAttributeDataArray2DCustomType objects are read-only and can be filled with the methods supplied with the ICEAttribute class
CICEAttributeDataArray2DString | This class is a specialization of CICEAttributeDataArray2D which allows access to the ICEAttribute data as a 2D array of type siICENodeDataString. CICEAttributeDataArray2DString objects are read-only and can be filled with the methods supplied with the ICEAttribute class
CICEAttributeDataArray< bool > | This class is a specialization of a CICEAttributeDataArray class of type `bool`
CICEAttributeDataArrayCustomType | 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
CICEAttributeDataArrayString | This class is a specialization of CICEAttributeDataArray which allows access to the ICEAttribute data as a 1D array of type siICENodeDataString. CICEAttributeDataArrayString objects are read-only and can be filled with the methods supplied with the ICEAttribute class
CICEGeometry | Provides a read-only API for accessing the data of a geometry object connected to a custom ICE node
CICEPortState | CICEPortState is used for accessing the state of a custom ICENode input port from the cb_ICENode_BeginEvaluate BeginEvaluate callback
CIndexSet | CIndexSet encapsulates an index set for indexing CDataArray object types for the current evaluation
CKnotArray | An array of knot values representing the NURBS curve or surface knots
CLine | A parametric 3D line
Clip | Clips are instances of animation and shape actions (ActionSource), audio and image sources (Source) and compound clips (ClipContainer)
ClipContainer | A ClipContainer can represent either the Mixer or a compound Clip. Both can contain other Clips, Tracks and Transitions
ClipEffect | A ClipEffect represents the set of effects associated with a Clip. Each ClipEffect object contains one item corresponding to a MappedItem
ClipEffectItem | A ClipEffectItem is an expression which is bound to a MappedItem of a Clip
ClipRelation | Clip relations are logical entities used to create a bi-directional constraint between two clips, the master and slave clip
CLongArray | The CLongArray is an uni-dimensional array of LONG values
Cluster | A cluster represents a set of components on a Geometry
ClusterProperty | Represents a property of a cluster
CMatrix3 | This class represents a double precision floating point 3 by 3 matrix
CMatrix3f | A class to represent a single precision floating point 3 by 3 matrix. This class is typically used for implementing custom ICE nodes
CMatrix4 | This class represents a double precision floating point 4 by 4 matrix
CMatrix4f | A class to represent a single precision floating point 4 by 4 matrix. This class is typically used for implementing custom ICE nodes
CMeshBuilder | CMeshBuilder allows you to create polygon meshes from an ordered array of vertex coordinates and polygon connections (polygon to vertices). You can build the vertices and polygons by providing all the data at once or you can build them incrementally by providing the data in chunks
CNurbsCurveData | This structure represents a data description for a NurbsCurve
CNurbsCurveDataArray | The CNurbsCurveDataArray is an uni-dimensional array of CNurbsCurveData
CNurbsCurveRefArray | An array of NurbsCurve objects representing the curve in a curve list
CNurbsSampleRefArray | An array of NurbsSample objects representing the sample points on a NurbsSurface
CNurbsSurfaceData | This structure represents a data description for a NurbsSurface
CNurbsSurfaceDataArray | The CNurbsSurfaceDataArray is an uni-dimensional array of CNurbsSurfaceData objects
CNurbsSurfaceRefArray | An array of NurbsSurface objects representing the surface in a nurbs surface mesh
CObjectAddedNotification |
CObjectRemovedNotification |
Command | Represents a Softimage command (either built-in or custom). This object encapsulates information on a command such as the name, category, arguments, where it is implemented etc
CommandArray | This object represents a collection of commands
Constraint | The Constraint object represents a constraint in the scene graph
ConstructionHistory |
Context | This is a general, flexible Context object that is used for callbacks. Instances of this object are used to pass information to the C++ API callbacks that implement a PluginItem
ControlPoint | The ControlPoint of a NurbsSurface or a NurbsCurve
CParameterRefArray | An array of Parameters
CPlane | A parametric 3D plane
CPointRefArray | An array of Point objects that represent the points in the Geometry
CPolygonFaceRefArray | An array of PolygonFace objects representing the polygons in a polygon mesh
CPolygonNodeRefArray | An array of PolygonNode objects representing the edge junction in a polygon
CQuaternion | Implementation of a quaternion q=a+bi+cj+dk
CQuaternionf | Implementation of a float quaternion q=a+bi+cj+dk. This class is typically used for implementing custom ICE nodes
CRandom | A random number sequence generator class
CRef | This class is used to reference Softimage objects. Each instance of an CRef maintains a link with only one single object at a time, it cannot refer to multiple objects. CRef has no base or derived class hierarchy and only contains methods for accessing the type of the underlying Softimage object
CRefArray | Holds generic CRef objects and acts as a base class for other specialized CRef array classes (CEdgeRefArray, CFacetRefArray, etc...). Like CRef class, the CRefArray class also provides a runtime type information system to help determining the object type during execution time
CRenderHairAccessor | This class provides access to the render hair information exposed by the hair primitive. This information includes: the vertex positions of each generated render hair, the root/tip radius values, the UVW, weight map and vertex color values for each render hair root location
CRigidBodyAccessor | The rigid body accessor provides an optimized access to the data and property values of a rigid body dynamics object. CRigidBodyAccessor is suitable for data export applications as it allows access to rigid body data more quickly and efficiently than the regular API classes
CRigidConstraintAccessor | The rigid constraint accessor provides an optimized access to the data and property values of a rigid constraint object. CRigidConstraintAccessor is suitable for data export applications as it allows access to rigid body data more quickly and efficiently than the regular API classes
CRotation | Provides conversion facilities for various rotation representations including Euler angles, Quaternion, Axis angle and rotation matrix
CRotationf | Provides conversion facilities for various rotation representations including Euler angles, Quaternion, Axis angle and rotation matrix. CRotationf is typically used for implementing custom ICE nodes
CRTSState | The CRTSState object holds information about a state
CRTSStateList | Holds information about a list of shader states
CSampleRefArray | Array of Sample objects that represent the samples in the Geometry
CScriptErrorDescriptor | This class extends the CStatus object with additional error details if a Script Error has occured
CSegmentRefArray | An array of Segment objects that represents all the segment sub-components in the Geometry
CSelectionChangeNotification |
CShape | A class representing primitive types for particles rendering. Shape objects are read-only and can be accessed with ICEAttribute properties such as ICEAttribute::GetDataArray and ICEAttribute::GetDataArray2D
CSIObjectRefArray | An array of SIObjects
CStatus | Encapsulates status data types for error handling purpose. The class also exposes methods to query and set the error code
CString | Character strings in the Softimage SDK are represented with the CString class. CString consist of a variable-length sequence of characters. The CString class can store either wide characters (16-bit values) or ASCII ("char") characters (8-bit values)
CStringArray | The CStringArray is an uni-dimensional array of CString objects
CTime | Utility class for manipulating time
CTimeArray | The CTimeArray is an uni-dimensional array of CTime
CTimeChangeNotification | Holds information about a time change Event
CTransformation | This object represents a transformation which is the result of the combination of a Scaling, a Rotation and a Translation, in the S.R.T order
CTriangleRefArray | An array of Triangle objects that represents all the triangles in the Geometry
CTriangleVertexRefArray | An array of TriangleVertex objects that represents all points of a Triangle object
CTrimCurveData | This structure represents a data description for a TrimCurve
CTrimCurveDataArray | The CTrimCurveDataArray is an uni-dimensional array of CTrimCurveData
CUserDataArray | A CUserDataArray is an uni-dimensional array used to store binary values. CUserDataArray contains items of type CUserDataArray::Value which holds the data set on a user data map property
CustomOperator | The CustomOperator object represents a custom operator (ie., a scripted or compiled operator) in the scene graph
CustomPrimitive | Custom primitive object. A custom primitive object is an implicit primitive where the representation is fully defined by user. Defining the representation is done via the callbacks (_Define, _DefineLayout, _PPGEvent, _Draw, _BoundingBox, _ConvertToGeom) for Custom Primitive
CustomPrimitiveContext | This class is provided as the context object in the CustomPrimitive ConvertToGeom callback for a CustomPrimitive object (see PluginRegistrar::RegisterCustomPrimitive)
CustomProperty | Custom parameter set property object. A custom property holds a set of parameters which can be created by the user or via scripting/programming
CUtils | This is an intrinsic object that provides general utility methods
CUV | This structure represents a UV coordinate
CUVArray | The CUVArray is an uni-dimensional array of CUV
CValue | The CValue object provides the convenience of a loosely typed variable inside a strictly typed language like C++
CValueArray | The CValueArray is an uni-dimensional array of CValue
CValueChangeNotification |
CVector2f | A 2-element vector represented by single floating point x,y coordinates. This class is typically used for implementing custom ICE nodes
CVector3 | A 3-element vector that is represented by double precision floating point x,y,z coordinates
CVector3Array | The CVector3Array is an uni-dimensional array of CVector3
CVector3f | A 3-element vector that is represented by single floating point x,y,z coordinates. The class is used used for implementing custom ICE nodes
CVector4 | A 4-element vector that is represented by double precision floating point x,y,z,w coordinates
CVector4Array | The CVector4Array is an uni-dimensional array of CVector4
CVector4f | A 4-element vector that is represented by single floating point x,y,z coordinates. The class is used used for implementing custom ICE nodes
CVertexColor | This structure represents a vertex RGBA color. Unlike CColor, each component value of CVertexColor is a byte
CVertexColorArray | The CVertexColorArray is an uni-dimensional array of CVertexColor objects
CVertexRefArray | Represents an array of Vertex objects
CWindowNotification | Holds information about a change in window position
Delta | The Delta object represents a 'diff' or list of modifications to a reference model
Desktop | The Desktop provides the services for creating and accessing UI objects in Softimage
Dictionary |
Directed | An object representing the interest of a Camera or Light
Edge | The Edge object gives access to the geometry edges of an X3DObject's primitive
Envelope | An envelope is an object or hierarchy that is assigned as a skin to a set of deformers such as IK chains. Envelopes move and deform in response to the movement of their deformers. In this way, for example, a character moves as you animate its skeleton
EnvelopeWeight | An envelope weight is a specialized kind of ClusterProperty used to store the weights for each point on an envelope
EventInfo | Information on a particular event such as its mute value, event handler, etc
Expression | An expression string is a mathematical formula that controls any animatable parameter. It may include object and parameter names, mathematical operators, and tokens representing functions or constants
Facet | A facet is a generic concept used to describe a Geometry's PolygonFace, NurbsSurface or NurbsCurve
Factory | This class represents a Factory class and is used to create certain types of objects
FCurve | The FCurve (function curve) class provides access to a set of functions for getting and setting Softimage fcurve attributes, as well as creating, retrieving, modifying and deleting fcurve keys
FCurveKey | This class represents a key on a function curve (FCurve)
FileReference | The FileReference class represents a reference to a file on disk
Filter | The Filter object represents an instance of a Softimage filter. Filters are used by Softimage interactive tools and OM objects for validating the use of a set of objects in a given context. Softimage already defines a set of native filters available to users and can be extended with custom filter objects
Framebuffer | The Framebuffer object controls the file output of a RenderChannel object. It can be created using the Pass::CreateFramebuffer function
Geometry | Gives access to a X3DObject's geometry. Geometry is the base class for specific geometry classes such as PolygonMesh and NurbsSurfaceMesh
GraphicDriver | Encapsulates the graphic driver currently set for drawing hardware shaders
GraphicSequencerContext | This class represents the plug-in context for the Graphic Sequencer (CGraphicSequencer)
GridData | This object represents a 2-dimensional array of data. The word Grid refers to the visual presentation of 2-Dimensional data on a grid control (sometimes called a table or spreadsheet control). The word Cell refers to a single element of the array
GridWidget | The GridWidget object represents the user interface control that shows a GridData object inside a Property Page
Group | Collection of related objects
HairPrimitive | This class represents the primitive of an X3DObject used for simulating hair in Softimage and can be accessed with X3DObject::GetActivePrimitive
HardwareShaderContext | This object is provided as the context object in the execution callback of a hardware shader
HardwareSurface | HardwareSurface class used for encapsulating a 2D shader texture surface
ICEAttribute | The ICEAttribute object represents an attribute data set (a collection of information used in the ICE system, such as Age, PointPosition, NbrPolygons, etc.)
ICECompoundNode | The ICECompoundNode object represents a node sub-graph
ICEDataModifierNode | The ICEDataModifierNode object represents a SetData node in an ICE graph. See the Softimage programmer guide for details on SetData
ICEDataProviderNode | The ICEDataProviderNode object represents a GetDataNode in an ICE graph
ICENode | The ICENode object represents an effect node in the ICE graph
ICENodeContainer | The ICENodeContainer object represents the base class for containers in a node graph
ICENodeContext | ICENodeContext is used for accessing/handling custom node graph data. Instances of this object can pass information to the C++ API callbacks that implement the custom node plug-in item
ICENodeDef | ICENodeDef objects are used for describing a unique custom ICENode object. Instances of this object are used to register custom ICENode objects with PluginRegistrar::RegisterICENode
ICENodeInputPort | A ICENodeInputPort object represents the input port of an ICENode
ICENodeOutputPort | A ICENodeOutputPort object represents the output port of an ICENode
ICENodePort | ICENodePort is the base class for ICENode ports such as ICENodeInputPort and ICENodeOutputPort
ICETree | The ICETree object represents a node graph and holds all the effect nodes together
Image | This class provides read-access to the representation of an image in memory
ImageClip | As of v4.0, this class is obsolete and is replaced by ImageClip2
ImageClip2 | An ImageClip2 object is an instance of an image Source and is used as the container for applying composited image effects
InputPort | An InputPort object represents an input port of an Operator
IRTSExecutionState | The IRTSExecutionState object offers several methods to access various objects during a call to real-time shaders
CIndexSet::Iterator | A class for iterating over CDataArray objects during an evaluation. Iterator objects must always be created with CIndexSet::Begin()
Joint | The Joint object represents a Kinematic Joint property of a ChainBone or ChainEffector object
Kinematics | The Kinematics object represents the kinematics property of an X3DObject object
KinematicState | The KinematicState represents the current pose of an X3DObject object whereas the base pose of an object is represented by the StaticKinematicState
Layer | The Layer is a self-contained collection of SceneItem objects. It can be nested one level to provide Layer Group functionality
Layout | The Layout object represents an instance of a screen layout in Softimage and gives access to the views attached to that layout. The layout is read-only and cannot be edited or created with the SDK
Library | A library is a container of objects of the same type. For example, a material library contains a list of materials
Light | The Light object represents a Softimage light, such as a point light or a spot light
LightRig | The LightRig object is a specialized Rig object composed of a Light and a Null as its interest. Although a LightRig is typically defined with a spot light, it can be defined with any light preset
MappedItem | A mapped item specifies the value driven by a specific clip instance (for example, an object's parameter or its geometry)
Material | The Material object represents a material property of a SceneItem object
MaterialLibrary | The material library object is a specialized source library for storing and sharing materials
MemoCamera | Memo camera control in a view
Menu | Represents a custom menu in Softimage and provides the basic support for creating them
MenuItem | The MenuItem object represents an individual item on a custom menu
MetaShaderRendererDef | Represents a custom renderer definition
Mixer | This represents the Animation Mixer, which is nested directly under the Model. The Mixer object is a ClipContainer and so provides access to the standard elements of a mixer: its Track objects, Transition objects, Clip objects, and ClipRelation objects
Model | The Model object represents any Softimage model node, including referenced models, and even the Scene Root. Softimage models act as a container for objects (usually hierarchies of objects) and many of their properties. Models are a type of X3DObject and as such can be positioned in space. A model can contain objects, Groups, or other models
Null | The Null object is a specialized X3DObject object and represents a point in space with no dimensions. Nulls can be used to set constraints, organize objects into hierarchies, and so on
NurbsCurve | The NurbsCurve object gives access to the geometry curves of an X3DObject's primitive
NurbsCurveList | A NurbsCurveList is a kind of Geometry and is a collection of NurbsCurve objects
NurbsSample | The NurbsSample object gives access to the NurbsSurfaceMesh sample geometry
NurbsSurface | The NurbsSurface object gives access to the X3DObject's nurbs surface Geometry
NurbsSurfaceMesh | A NurbsSurfaceMesh is a kind of Geometry
OGLLight | The OGLLight object represents the OGL light properties of a Light object
OGLMaterial | This object represents the OpenGL properties of a material object
OGLTexture | The OGLTexture object represents the OGL texture properties of a material object
Operator | The Operator object represents an operator in the scene graph. Objects or Parameters are connected to the operator via InputPorts or OutputPorts. These ports are organized into port groups. The port groups contain all ports that will be connected to parts of the selected or picked object. For example, when the twistop Twist operator is applied to a selected object the operator has ports that read from the object's local KinematicState and Geometry and write to the result object's geometry
OperatorContext | This class is provided as the context object in the Operator update callback for a Self-Installed CustomOperator object (see PluginRegistrar::RegisterOperator)
HardwareSurface::Options | This class represents the options used for creating HardwareSurface objects
OutputPort | An OutputPort object represents an output port of an Operator
Override | This class represents an Override override property. An override contains the parameters that are used for replacing an object's parameter with another value or a shader without removing the original object parameter
Parameter | Represents a parameter value within the ProjectItem, for example, the angle parameter of the twist operator. It is possible to create custom defined parameters on the CustomProperty object
CShape::ParameterInstance | A struct to hold the parameters for a shape instance
CShape::ParameterReference | A struct to hold the parameters for a shape reference
Particle | Represents one particle in a particle cloud
ParticleAttribute | Represents a user-defined Particle attribute, which is a custom parameter for particles originating from a ParticleType
ParticleCloud | This class represents a Particle Cloud in a Softimage scene
ParticleCloudPrimitive | This class provides access to the collection of particles that make up a ParticleCloud
ParticleType | Represents a particle type. A particle type serves as a definition of the particles on the initial state of a particle simulation
Partition | A Partition is a division of a Pass, which behaves like a Group. Partitions are used to organize scene elements within a Pass. There are only two types of partitions: object and light. Light partitions can only contain lights, and object partitions can only contain geometric objects
Pass | A render pass creates a picture layer of a scene that can be composited with any other pass to create a complete image. Passes also allow you to quickly re-render a single layer without re-rendering the entire scene. Later you can composite the rendered passes using the Softimage FX Tree, the fully-integrated compositing and effects toolset, or another compositing tool of your choice
PassContainer | The PassContainer object represents the pass container object found in the scene. The pass container holds all the render passes in the scene, the global render options and individual render options for all installed rendering engines
PickBuffer | This class provides access to a picking buffer returned from ToolContent::GetPickBuffer
Plugin | A Plugin object holds read-only information on a particular plug-in file registered in Softimage
PluginItem | Information on each item of a plug-in
PluginRegistrar | This class provides functions for registering a PluginItem in Softimage
Point | A Point is a generic concept used to describe a Geometry's Vertex or ControlPoint
PointLocatorData | A PointLocatorData object represents a collection of point locators. A point locator is a geometric surface coordinate, and represents a precise location on a geometry
PolygonFace | The PolygonFace object gives access to the geometry polygons of an X3DObject's primitive
PolygonMesh | A PolygonMesh is a kind of Geometry
PolygonNode | The PolygonNode object gives access to the X3DObject's polygon node geometry. A polygon represents the edge junction of a polygon object
Port | A port is an input or output connection to another object
PortGroup | A portgroup is a group of Port objects on an Operator. The port group is a logical grouping of multiple port connections that are normally scoped by an X3DObject. A single portgroup can contain both InputPort and OutputPort objects
PPGEventContext | This object is provided as the context object in the PPGEvent callback for a Plugin-based CustomProperty object (see PluginRegistrar::RegisterProperty)
PPGItem | This object represents a component of the user interface of a Property Page
PPGLayout | The PPGLayout object represents the visual appearance of an object's state when it is inspected. (`PPG` is a common acronym for Property Page). The layout makes it possible to group objects together, use special controls, hide obsolete parameters, add Buttons and in general create a presentation of an object's state that is pleasing to the eye
Preferences | The Preferences object can be used to manage preferences in Softimage
Primitive | Represents the primitive object of a X3DObject, a primitive is the basic form that is the building block of modeling and animation
ProgressBar | A progress bar is a control that indicates the progress of a lengthy operation by displaying a colored bar inside a horizontal rectangle. The length of the bar, in relation to the length of the rectangle, corresponds to the percentage of the operation that is complete
Project | The Project object represents the active Softimage project. It exposes information like the current scene (see Project::GetActiveScene)
ProjectItem | Base content class in Softimage from which all other content objects derive. Its major feature is that it provides access to the parameters which represent the state of the object
Property | Property of the following entities:
ProxyParameter | A ProxyParameter is a kind of Parameter that can be created on a CustomProperty which is "linked" with the value of another Parameter somewhere else in the Scene
RenderChannel | A render channel is a container for rendered image data output. The channel describes what kind of data can be recorded into it
Renderer | This object is provided as the source object available from the RendererContext for a Plugin-based cus_render Custom Renderer object
RendererContext | This object is provided as the context object in the Renderer callbacks for a Plugin-based cus_render Custom Renderer object
RendererImageFragment | This abstract class needs to be implemented by the rendering engine to provide image fragments to Softimage. The fragment should be contained fully within the crop window given in the RenderContext object's attribute list
Rig | Base class for object with an interest i.e.: CameraRig and LightRig
Sample | A Sample is a generic concept used to describe a PolygonNode or NurbsSample
Scene | The Scene object represents a Softimage scene that is loaded in memory
SceneItem | The SceneItem object represents an object in the scene (that is, something with properties) in Softimage from which all other scene objects derive
SceneRenderProperty | This object represents a scene render property. The scene render property controls common render settings for all passes in the scene and the render region. The property allows to quickly change a common set of options, such as the rendering engine, field rendering, motion blur and resolution, that will apply to all rendering options that derive from it. The property is a singleton and is only found under "Passes.RenderOptions"
Schematic | Schematic UI view and gives access to SchematicNode objects
SchematicNode | UI node as displayed in a Schematic view
Segment | A Segment is a generic concept used to describe a PolygonMesh's Edge
Selection | The selection object represents the global selection for the application
Shader | The Shader object represents a node in the render tree of an object
ShaderArrayParamDef | Represents a definition for a shader parameter (an instance a ShaderArrayParameter object)
ShaderArrayParameter | Represents an array parameter for a Shader
ShaderballOptions | Represents the options for a shaderball view
ShaderDef | Represents a custom shader definition
ShaderParamDef | Represents the definition of a ShaderParameter object
ShaderParamDefContainer | Represents a set of ShaderParamDef, ShaderArrayParamDef, and/or ShaderStructParamDef objects
ShaderParamDefOptions | Represents the advanced options for a shader parameter definition (ShaderParamDef) object
ShaderParameter | Represents a shader parameter as a specialization of the Parameter interface on a Shader
ShaderStructParamDef | Represents the Structure specialization of a shader parameter definition
ShapeClip | A ShapeClip is an instance of a shape key (source) at a particular position along a shape track in the animation mixer
ShapeKey | A ShapeKey represents a special ClusterProperty which is used to store a specific geometry. ShapeKeys provide information about how the shape of a cluster changes by either storing its absolute value, an offset based on the object referential or values base on the local reference frame of vertices
SimulationEnvironment | The SimulationEnvironment object represents a construct which is used to define a simulation. For now SimulationEnvironment objects are used only for RigidBody simulations. A simulation environment is a set of connection containers, one for each kind of element in the simulation: the rigid body objects, the rigid body constraints and the forces
SIObject | SIObject derives from CBase and acts as the base class for the Softimage Object Model library. Unlike CBase, this class provides some high-level services such as object naming. It also provides accessors to the object parent and to the Application object
Source | Sources are references to data which are instantiated. For example, a shape source becomes a ShapeClip in the animation mixer when it is instantiated there
StaticKinematicState | The StaticKinematicState object represents the base pose of an object. Objects that have access to the StaticKinematicState object include:
StaticSource | The StaticSource object represents a constant value stored as an AnimationSourceItem. When instantiated, the parameter value takes on the value of the StaticSource. A static pose is a kind of a StaticSource
SubComponent | Provides access to the subelements of an object's Geometry
tagXGSExtensionsGL | GraphicSequencer GL extensions structure
tagXGSGLExtensionsFuncs | GraphicSequencer GL extensions functions
tagXSI_RTS_Camera | The XSI_RTS_Camera structure
tagXSI_RTS_ColorARGB |
tagXSI_RTS_ColorRGB |
tagXSI_RTS_ColorRGBA |
tagXSI_RTS_ColorRGBAf |
tagXSI_RTS_ColorRGBf |
tagXSI_RTS_Light | The XSI_RTS_Light structure
tagXSI_RTS_Primitive | The XSI_RTS_Primitive structure
tagXSI_RTS_SceneData | The XSI_RTS_SceneData structure
tagXSI_RTS_SystemParams | The XSI_RTS_SystemParams structure
tagXSI_RTS_Texture |
tagXSI_RTS_TriangleList | The XSI_RTS_TriangleList structure. Provided only for backward compatibility
tagXSI_RTS_Vector2 |
tagXSI_RTS_Vector3 |
tagXSI_RTS_Vector3d |
tagXSI_RTS_Vector4 |
Texture | Specific Shader object which is a member of the Texture Shaders family (siTextureShaderFamily)
TextureLayer | The TextureLayer is an object which simplifies layering of shader effects on top of shaders and materials. Each layer has a set of properties which describe its characteristics (such as color, mixing mode, scale factor) to specify how it will affect the shader ports it drives. The order that layers appear under a container indicates the order the layering is applied, similar to the way a "mix N colors" shader node works
TextureLayerPort | The TextureLayerPort is an object used to describe which specific shader and material parameters a TextureLayer affects. Like shader connections, they indicate what shader ports are being driven by the layer
TimeControl | The TimeControl object represents the clip's Time Control property, which is used to specify the time reference for a given Clip object
TimerEvent | A TimerEvent represents a system timer and allows you to specify the interval and the delay time at which a timer elapses. Timers in Softimage are independent of the timeline clock and can be used to produce recurrent work accurately. For example, you can implement an autosave mechanism with a TimerEvent
ToolContext | ToolContext is used for accessing/handling tool data. Instances of this object can pass information to the C++ API callbacks that implement the custom tool plug-in item
Track | A Track represents the container of clips used to sequence clips in the ClipContainer
Transition | This object represents a transition between two clips. A transition is an interpolation used to smooth passing from the end of one clip to the beginning of another
Triangle | Represents a triangle generated by a surface tesselation
TriangleVertex | A TriangleVertex represents a Point of a Triangle object
UIObject | The UIObject is the base class for Softimage UI objects such as UIPersistable and MenuItem. This class has no specific functions
UIPersistable | The UIPersistable object is the base class for Softimage UI persistable objects such as the View and Layout objects
UIToolkit | Provides access to Softimage user interface tools such as the ProgressBar object and the MsgBox function
UpdateContext | This object represents the operator update context. It gives access to the operator and the evaluation time. The UpdateContext is only valid within the context of the Update() function for operators that are based on a Preset and SPDL. Self-Installed CustomOperators use the OperatorContext object instead
UserDataBlob | The UserDataBlob is a Property that can be attached to many different parts of a scene, for example Cameras, Lights, other X3DObjects and Clusters. It allows a plug-in to read, write and persist binary user data as part of a scene
UserDataMap | The UserDataMap is a Property that can be attached to any cluster. It permits the storage of variable-length binary user data on the individual components of a geometry. The data is stored as part of the scene file and can be accessed via plug-ins using the C++ API
UVProperty | UVProperty is a kind of ClusterProperty object used for storing and accessing the UV information of a cluster
CValue::ValueField |
ValueMap | Represents a special container to hold key-value pairs, similar to an associative array
Vertex | The Vertex object gives access to the geometry vertices of an X3DObject's Primitive. A Vertex is the object PolygonMesh specifics of the Point object
View | The View object represents an instance of a view in Softimage
ViewContext | The ViewContext object serves 2 functions for Custom Displays:
X3DObject | The X3DObject object represents a basic 3D object of a scene in Softimage
XSI_RTS_Uniform | The XSI_RTS_Uniform object defines a special parameter for a Realtime Shader chain
xsimrAttributeData | A structure containing the information for a single attribute
xsimrAttributeImageTimeMap | List of range to frame mapping values
xsimrLightData | Stores information about whether the diffuse and specular are applied
xsimrLightIllumData | If set by a shader, will be filled in by Softimage's light shaders to contain a separated light and shadow information. Also contains the amount of contribution this light gives to the diffuse and specular components of the shading model
xsimrMesh | A user data applied on meshes
xsimrMeshAttribute | A structure representing an ICE attribute on a mesh
xsimrParticleBlob | Particle data blob structure
xsimrParticleShape | Particle shape structure
xsimrPointCloudData | The main particle data header
xsimrPointCloudIndex | Stores the PointCloud index
xsimrProfileCurveData | A profile curve data sampled into linear segments
xsimrTimeMapValue | A single range to frame mapping entry