About the Structure of Softimage’s APIs

The C++ API and the Softimage Object Model (OM) are both implemented using an object-oriented approach. This means that classes that are children inherit the functions of the parent class and then extend that class by implementing more specific functions. Hierarchical representations of both APIs are available:

• Object Model: Object Hierarchy

• C++ API: Class Hierarchy

You can also use the SDK Explorer in Softimage, which is a relational view that displays SDK information about a selected object. The SDK Explorer is available from Softimage's main menu via the View > Scripting > SDK Explorer entry.

The SDK Explorer displays information from the scripting object model, and provides links to the scripting reference pages. The C# and Scripting Reference pages include links to the corresponding C++ reference pages, so you can quickly get to the mirrored C++ information.

The following sections provide a very high-level view of the scripting object model and the C++ class libraries.

Base Class

The basic building block for the Softimage scene in both APIs is SIObject, which implements basic information like Name and FullName, Type, Origin and OriginPath, etc. Most objects inherit from SIObject.

Application

Application provides hooks into Softimage for scripted and compiled plug-ins using the following syntax:

• For writing scripted plug-ins running outside of Softimage (for example, NetView pages) you can hook into Softimage using the Application object:

    // JScript
    var xsi_app = new ActiveXObject( XSI.Application );
    var app = xsi_app.Application;
    app.LogMessage( "Initiating NetView session" );

• For writing plug-ins with the C++ API, use the following:

    Application app;
    app.LogMessage( L"Welcome to Softimage!" );

• For writing C# plug-ins with the object model, use this:

    CXSIApplicationClass app = new CXSIApplicationClass();
    app.LogMessage( "Custom Plug-in started", siSeverity.siInfo );

The Application class also provides many essential services, including command creation and execution, add-on installation, access to basic Softimage utilities such as the dictionary, the selection, the desktop, etc.

Utility Classes

There are two classes that are primarily used as base classes for project-level items and scene-level items:

• ProjectItem—base class for most content objects in the project; for example, objects that inherit from the ProjectItem potentially have parameters. Some of the objects that inherit from the ProjectItem are: Clip, Source, Operator, Shader, Scene, etc.

• SceneItem—base class for most scene objects; for example, most objects that inherit from the SceneItem potentially have properties. Some of the objects that inherit from the SceneItem are: Cluster, Group, Model, X3DObject , etc.

3D Scene Objects

The main class that manages 3D scene objects is X3DObject , which implements functions to create child objects, allows access to the geometry and provides navigation through its children.

These are some of the more typical functions you could use to access the data on a scene object:

• (Get)Properties—inherited from the SceneItem class, this provides access to the object’s property sets. From here you can access the individual parameters with .

• (Get)ActivePrimitive—this provides access to the object’s geometry through the Primitive. The Geometry object gives you low-level access to the object’s subcomponents.

• (Get)Kinematics —this provides access to a special kind of property containing data controling position, scaling, rotation, etc.

• AddXXX—there are several functions that add specific types of elements as children under the scene object (including the Scene_Root, which is a kind of X3DObject ). The most common of these is the AddGeometry function, which allows you to add new cubes, spheres, etc.

• FindChild, FindChildren, (Get)Children—these provide navigational tools that allow you to find specific objects (or kinds of objects) under the scene object (again, including the Scene_Root).

Content Classes

There are many classes implemented in the object model that represent specific Softimage items, such as Shader, Camera, Vertex, ImageClip, Port, etc.

Global and Utility Classes

There are several global (intrinsic) and utility classes that provide extra value. These include:

• Application class—hooks into Softimage and essential services.

• Math features—these are implemented through the XSIMath object in the object model and the XSI::MATH namespace in the C++ API. They provide convenience methods and interfaces for math.

• UI Toolkit—this provides access to tools that you can use to help build a user interface, such as the ProgressBar and the MsgBox functionality.

• XSIUtils object—this is only available in the object model. It provides access to general utilities such as the DataRepository and Linktab.

Autodesk Softimage v7.5