Eon Intro to Sdk

Copyright EON Reality, Inc. 2002 1

Introduction to EON SDKJan 2002

Table of Contents

EON SDK 2.53.02

Table of Contents

User Guide

Table of Contents 2

Introduction 3

Installation 4

EON SDK Basics 6

Wizards 20

Techniques 30

Introduction 37

Nodes 38

Classes in EON SDK 39

Modules 41

Interfaces 42

Macros 60

Index 61

Users GuideIntroduction

2.5 3

Introduction

About this Guide

This guide is your companion in exploring EON SDK and in implementingyour own modules and nodes. Because EON SDK incorporates C++programming extensively, a working knowledge of the C++ language isrequired.

This guide actually combines two guides in onethe User Guide and theReference Guide. The User Guide describes basic features of EON SDK,as well as information on system requirements and installation.Furthermore, instructions are provided for the two EON SDK wizards.

The Reference Guide describes the classes and functions used by EONSDK.

Introduction to EON SDK

EON SDK is a software development kit for constructing custom EONnodes and modules. This is the same tool used by EON Reality to createstandard nodes and modules. EON SDK is used from within MicrosoftVisual C++.

EON SDK adds two wizards to Visual C++, a few base classes thatconnect your code to the EON framework, and a number of libraries.

Certain EON nodes are referred to as agents, indicating that thesenodes are related to actions. EON agents may initiate operations suchas motion control and on/off functionality. (From a purely technicalperspective, a node is considered an agent if it implements the IAgentinterface.) However, with the present widespread use of event-passing,the distinction between agents and other nodes has become ratherinsignificant. From now on we will use the general term node, if notagent is more precise.

EON nodes can be grouped in modules. An EON module is an independentprogram component that expands basic EON Studio functionality. Amodule may add new menu items, toolbars and views. It may alsocommunicate with the nodes that make up an EON simulation or withother modules. The nodes of a custom module are handled by EON Studioin exactly the same way as EON Studio's basic nodes. Modulesand evenindividual nodescan be license-protected with EON SDK, permittingthird-party developers to create specialized EON Studio plug-ins.

User GuideInstallation

EON SDK 2.53.04

Installation

Installing EON SDK

This section describes installation of EON SDK from the CD-ROM.

System RequirementsProcessor Memory Disk space Operating systemIntel Pentium 75(minimum)

Pentium 166 MHz(recommended)

16 Mb

32 Mb

7 Mb (minimum)

10 Mb (with examples)

Windows 95/98

Or

Windows NT 4.0 with Service Pack 3 orlater

The system requirements for EON SDK are the same as for EON Studio.Microsoft Visual C++ version 6.0 or later must be installed on yourcomputer.

Because new nodes are created with Visual C++ (using wizards), it isstrongly recommended that the user has programming experience in C++and is familiar with the Visual C++ integrated developmentenvironment.

Program Installation1. Insert the EON SDK CD-ROM. If the installation program does not

start automatically, continue with Steps 2 through 4.

2. Choose Run by clicking on the Start button of the Windows taskbar.

3. Enter d:\setup in the dialog box (d: being your CD-ROM drive).

4. Click the OK button.

5. The installation program will now guide you through theinstallation process.

Installing DirectX SDK

To work with nodes that employ graphicssuch as 3D objects (meshes)youwill need Microsofts DirectX SDK. DirectX is an API that gives theuser access to system hardware. It consists of six differentcomponents: DirectPlay, DirectInput, Direct3DSound, DirectSound,Direct3D and DirectDraw. Each is capable of emulating low-levelfunctions not supported by underlayer hardware.

Note that the DirectX runtime components included on the EON Studio2.5 CD are not intended for development purposes. If you want toinstall the DirectX SDK on your development system, you will find thelatest version at:

http://www.microsoft.com/directx/default.asp

Setting up the Visual Studio Environment

When you work with EON SDK, it is always from within Microsoft VisualStudio. You use EON wizards to create skeleton code for new nodes and

User GuideInstallation

2.5 5

modules. By changing and making additions to the generated code, youcan modify the behavior of the nodes and modules.

Before you start building new nodes or modules, you must set up yourdevelopment environment correctly. To do this, choose Options fromVisual Studios Tool menu. Click the Directories tab.

Figure 1. The Directories tab, Options dialog box

This is where you add the path to the development directory, locatedin your EON SDK folder, and its subfolders (one for each file type).

NOTE: During the EON SDK installation you could choose to set thepaths automatically. If you did there should be a path to the EON SDKfor each file type. Then there is no need for you to perform thefollowing steps. The added paths are not removed when uninstalling EONSDK.

Figure 2. The Choose Directory dialog box

Select Include files from the Show directories for listbox and add theentry "Development Files\include" to the list of directories. Thencontinue to add "Development Files\lib" to Library files, "DevelopmentFiles\source" to Source files and "Development Files\executeable" toExecutable files. Furthermore, move each one of these directories tothe top of its list. You thereby force Visual Studio to always searchthose specific Development directories before the others.

Note that all four-file types must be added.

User GuideTechniques

EON SDK 2.53.06

EON SDK Basics

EON

EON is a VR development tool that is built on an architecture that ishighly modular, extensible and versatile. Using the EON Studioapplication you can create fully interactive 3D worlds that areexecuted and rendered in real-time by the run-time viewer EON/X. Theviewer can be embedded in various host applications such as Webbrowsers, RAD and multimedia authoring tools.

3rd PartyEON Modules

EON Studio View Modules(Scengraph, Butterfly, etc)

EON Studio Application Object Model(IAutApp, IAutDoc, IAutSettings, etc)

EON Studio(windowing, inter-module messaging, license management, etc)

EON Simulation

Design ModeDesign ModeDesign ModeDesign Mode

Run-time ModeRun-time ModeRun-time ModeRun-time Mode

NodeBag API(INodeBag)

NodeBag API(INodeBag)

EON/X(ActiveX control)

EON Studio(Simulation

Window)

EON Viewer Other ActiveX control Container(Internet Explorer, MS Word, VisualBasic, etc)

Embedded in...

CustomViewer

(Currently notsupported by the

SDK)

Legend:

= SDK creatable component

= EON pre-defined component

...

Simulation Node

Scen Node

Frame Node

Custom Node 1

Custom Node 2

Mesh Node

Figure 3. The EON architecture

As you can see the EON system is split into two distinct modes, andusing the SDK you can extend both parts of the system.

By creating EON Modules, you can extend the design mode functionality,inside EON Studio. You can also create custom nodes to supply or

User GuideWizards

2.5 7

enhance functionality in run-time mode. To let the user configurethese nodes in design mode, you have essentially three choices:provide custom properties dialog for each node (most common), create acustom module or let EON Studio takes care of it (you will get astandard properties list similar to Visual Basic).

EON uses Microsoft COM extensively to interface against both internaland SDK-created components. Therefore, most components in EON are COMobjects, including nodes, modules, the run-time viewer (EON/X), etc.

Inside EON

As a plug-in developer, you must understand the EON architecture in adeeper way and need to have working knowledge of C++. On the otherhand, you will be able to utilize the power of EON in full strengthsince you will have access to the same interface and functionalitythat are used by internal components as well.

The kernel of an EON simulation is the Scenegraph. This is the placewhere all nodes are located. EON Studio can be seen as a tool toconfigure and insert nodes into this graph (and to make connectionsbetween nodes so that events can be transferred from node to node).

To access this collection of nodes, the Nodebag component is used.This COM object exposes an interface named INodebag, to encapsulatethe inner structure of the collection and to let the rest of thesystem access it in a controlled way. In most cases, the plug-indeveloper would not need to deal with the Nodebag component directly,unless you would like to develop your own viewer or similar.

The real-time 3D graphics is handled by the simulation node, which isthe root node of the scenegraph. This is where the main execution looplies, to traverse and activate the rest of the nodes in the scenegraphto form a complete simulation. This node also handles mouse andkeyboard input, in addition to route management. A route is aconnection between two nodes, which will permit a node to send anevent to another one.

Other additional input channels (trackers, etc) and visual elements(shapes, lights, sounds, videos, etc) are handled by specializednodes, which are added when needed. This means the run-time system canbe very lightweight and flexible but also powerful and versatile atthe same time.

Using this SDK you can further enhance this system by creating andadding your own nodes to the system. These nodes can provide totallynew functionality or just enhance or replace the standard ones. Thesenodes are deployed and used in the same way as the standard nodes thatare shipped with EON. Hence, these plug-in components are trulyintegrated with the system.


EON SDK 2.53.08

However, the power does not come without a price. Since each node isactually a COM object, there is a lot of housekeeping surrounding thecomponent that is required by the COM specification. To minimize theinconvenience, the SDK provides wizards to generate the project filesand a code skeleton/framework, from where you can further build upyour node/module. The framework utilizes class sub-classing and macrosto hide implementation details, in a way very similar to MFC (theframework works closely and is compatible with ATL and MFC). There isalso a library of commonly used functions to speed up the SDKdevelopment.

If you are not worried about the additional work outlined above or youare using another C++ development tool than Visual C++, you are leftalone to implement them yourself. However, since COM is binarycompatible across programming language/compiler, you should be able tointegrate your custom nodes or modules with EON this way (although itis not recommended).

Nodes

What is a node/agent?

A node is an EON Studio object with functions and data. Nodes are ofdifferent types and thereby contribute varying effects to asimulation. Certain EON nodes are referred to as agents, indicatingthat these nodes are related to actions. EON agents may performoperations such as motion control and on/off functionality. A Framenode, on the other hand, is an example of a non-agent nodeits fieldsare only used to store values. Most nodes store data and manage mostexternal communication using so-called "fields". Data is sent betweennodes by connecting their respective fields with one another.

Note that the technical definition says that an agent is a node thatimplements the IAgent COM interface. Nowadays a node can manipulateother nodes not only through COM interfaces but also by sending eventsbetween fields. Hence, the exact meaning of the term "agent" hasbecome slightly blurred. We therefore prefer to use the more generalword "node", although we will continue to write "agent" where it isfound appropriate according to the definition mentioned above.

Fields

Fields used by EON nodes are of four different types:

eventIn fields for receiving data.

eventOut fields for sending data.

exposedField fields that can both receive and send data.

field fields used to store the nodes internal data.

A field of one of the four types listed above can contain either oneor several values of a particular data type. There is a limited numberof data types to choose from, and they are grouped into single-valued

User GuideWizards

2.5 9

or multiple-valued types. An example of a single-valued data type isthe SFString, which contains a single string. Its multiple-valuedcounterpart, which is called MFString, holds an array with anarbitrary number of elements, all of which must be strings.

Events

The message sent between two fields is called an event. An event sentfrom a field is called an out-event and an event received by a field,an in-event.

Nodes receive data:

When the user enters or changes data in a nodes properties window.

When data is sent from a connected node in the Route Window (fordetails about how to create routes between nodes, see the EONStudio 2.5 User Guide).

From parent nodes in the simulation tree.

From child nodes in the simulation tree.

From any connected I/O devices. (Those nodes are called sensors andmust implement the ISensor COM interface.)

The event model used in EON provides several benefits:

A node that sends events need not be aware of the receiversidentity.

Conversely, a node that receives events need not be aware of thesenders identity.

Fan-out (one sender, several receivers) and fan-in (severalsenders, one receiver) are supported automaticallynew nodes may beadded as senders or receivers with no special code required toimplement the additional communication connections.

Routes, which define how events are sent and received, aremanipulated in the Route View and hence they are independent ofnodes' positions in the simulation tree.

Events are passed quickly (though not as fast as functioninvocation from within the receiving node).

Creating a sensor node (a node that can generate events at anytime, independent of received events) is as easy as creating astandard node.

Execution model

The execution cycle of an EON simulations real-time loop has severalsteps.

First of all, the OnPreUpdate() function in theISimulationUpdateEvents interface is invoked, followed by calls to allsimulation nodes Update() functions. The call chain is initiated at


EON SDK 2.53.010

root level, with the Simulation node calling its child nodes. Allcalled nodes update their children recursively.

After that, all pending events are processed. The Route Managercollects pending out-events from sensor nodes and queues theminternally. It then dispatches all queued events and creates theappropriate in-events. New events (if any) are once again collectedand dispatched sequentially. This procedure continues until no eventsremain.

If two or more nodes form a cyclic graph, they may enter an infiniteloop of event-passing. Note that such a loop will generally beregarded as being a mistake on the part of the user. The Route Managerallows loops, but will prevent more than one event from being sentalong each route during the same collection round. If a route hasalready been "used" by an event, then the subsequent event will bequeued until the collection round of the next simulation frame.

Next, the OnPostUpdate() function is invoked. Each node can implementEventsProcessed(), a function that is called when all events have beenprocessed. The function is called only if the node has received anevent during the previous cycle. A final event collection is madebefore the simulated scene is rendered. All nodes are executed in asingle process. Accordingly, they share memory with each other as wellas with the rest of the EON system. This makes it possible to usestandard function calls between nodes. EON calls functions in eachsimulation time frame. When a simulation starts, a nodesOnInitialize() is called. The code in the nodes Update() function isexecuted in each time frame. When an event has been received, theFieldChanged() function is called. If any node fields have beenchanged, the FieldChanged() function takes appropriate action. Whenthe simulation stops, EON calls OnReset().

Another method for communication between nodes involves connectionpoints. Communication is faster but the procedure is more complex.

Why use C++?

Standard EON nodes are written in C++, using Microsofts Visual C++(version 5.0 and 6.0). To obtain satisfactory results, you should usethis development environment too. Because EON Studio already providesthe capability to create customized nodes by writing scripts in theScript node, you may wonder why you should bother working with C++.While Script nodes have the advantage of being easy to use (you cancreate and edit them within EON Studio's Script Editor), they tend tobe slow. This is due to the interpretive nature of the scriptinglanguage. Nodes created with EON SDK are written in C++ andsubsequently compiled into machine code. The additional effortinvolved in using C++ is rewarded with higher performance.

EON SDK gives you access to the graphics API used by EON throughDirect3D interfaces. Additionally, you can use other interfaces toaccess hardware devices such as mice and keyboards. A node created in

User GuideWizards

2.5 11

EON SDK can also call all standard operating system functions, forexample, functions that create dialog boxes, change fonts and makeInternet connections.

Modules

What is a module?

Seen from a purely technical point of view, any COM object thatimplements the dual interface IEonModule is an EON module.

In order to locate its modules, EON Studio investigates the Windowsregistry database. All EON modules must be able to identify themselvesthrough the registry. This is automatically taken care of in the codeskeleton generated by the Module Wizard.

Why use modules?

By creating modules, it is possible to extend the user interface ofEON Studio. An EON module can add the following functionality and GUIfeatures to EON Studio:

command handling

menu items

toolbar buttons

views (even so-called split views may be created)

nodes

license handling

custom message passing

A registered module is loaded automatically into EON Studio when EONStudio starts. In the process of loading a module, EON Studio calls anumber of module interface functions. This allows the module to checkand report the license status, and to inform EON Studio of thefeatures it implementsfeatures such as the above mentioned commands,menu items and toolbars.

Module commands can be bound to menu items and toolbar buttons. Whenthe user selects the menu item or toolbar button registered by amodule, EON Studio will call a function in the module so that themodule can handle the command. Some default commands, such as Copy andPaste, will be routed to the module automatically by EON Studioprovided that the currently active view belongs to the module.

A module can add an almost unlimited number of views to EON Studio.These views appear in the EON Studio user interface. Module views lookand behave the same as standard EON Studio views. They remember theirposition between sessions, and they can be configured as docked orfloating. Modules are, however, responsible for the contents of itsviews. Modules accomplish this by subclassing a window handle,supplied by EON Studio, when a module registers a view. Furthermore,


EON SDK 2.53.012

split views may be used intstead of the standard views. Split viewsincorporate splitter bars that divide a view into several panes. Asplit view can be configured to hold both multiple rows and columns ofpanes.

A module can communicate with the EON Studio simulation. It can alsodetermine which node in the simulation tree that is currentlyselected. Furthermore, it can fully exploit the interfaces provided bythe nodes of the simulation.

The modules will be notified when events that could possibly affecttheir behavior occur in EON Studio. Examples of such events are thosethat occur before a simulation is closed, after a simulation isopened, when the simulation tree has changed and when views need toupdate themselves. It is also possible for a module to change thecontent of the simulation tree, to add and delete nodes, to changenode properties, etc.

A module can also be used to group a number of nodes into a license-protected package. The source code for license handling is provided bythe Module Wizard when your new module is generated (though the codemay be enclosed by comments).

How to create a module

Use the EON Module Wizard from within Visual C++ to create newmodules. The wizard provides you with ready-made code skeletons. Toadd features to a new module, just add code to the skeleton or modifythe code that is already written.

Loading and unloading modules

Open the Options>Modules configuration dialog and mark the modulesyou would like to load initially at the start of an EON Studiosession.

To start EON Studio without modules, either hold down one of the shiftkeys as EON Studio starts, or use the command line argument -C whenstarting EON Studio from a DOS command prompt or the Start>Rundialog.

EON licensing

General

EON 2.5 uses the FLEXlm license managing system produced byGlobetrotter Software Inc. to manage licensing of features. A featureis a single program or program object, subject to licensing. Thelicensing system in EON 2.5 is based on modules, where a module is thesmallest unit that may be protected by the license system. This meansthat an EON module is a FLEXlm feature.

User GuideWizards

2.5 13

Although not features themselves, nodes may be license-protected byusing the INodeLicense interface. This interface lets your nodes checkif a certain module is properly checked-out. For example, EON Showroomnodes check to see if the EON Showroom module (feature) is checked-out. If it is, you can make use of all EON Showroom nodes as youdesign your simulation in EON Studio. However, if there is any problemwith the licensing, you may not fully exploit the Showroom nodes.

Design-time licensing applies to EON Studio and the modules, i.e., tothe files named ModuleName.DLL, but not NodeLibrary.DLL andPPNodeLibrary.DLL. This means that licenses will only be requiredduring the EON Studio simulation design phase, and that the finalsimulation may be run on any system that has registered the modulesused in the simulation.

Run-time licensing using Microsofts COM licensing may be implementedin later EON versions. To make this possible, run-time and design-timelicensing information is included in the license keys initiallycreated.

If one or more of its modules are loaded in so-called demo mode, EONStudio will also run in demo mode. When EON Studio is in demo mode,the Save and Save As commands are disabled. Although all installedmodules are available, it is not possible to save the new simulationsyou create.

To prevent a checked-out license from being checked-out indefinitely,heartbeat messages will be exchanged between the module and thelicense server. Heartbeat messages also prevent tampering byrestarting the license server. When a pre-defined time-out has beenreached and the module still hasn't answered the license server calls,the license is automatically checked-in.

If for same reason, the license server is not accessible from yourcomputer for a longer period, EON Studio will notify you of theproblem and ask you if you wish to save your current work before EONStudio makes a transition into demo mode.

For more information on different modules and EON license handling,see the EON Studio manual.

Module licensing

As long as a module implements the license-handling interface ofIEonModule, it is up to the user to choose an appropriate licensingsystem. Though naturally, it is strongly recommended that FLEXlm beused; this avoids the problem of having two separate licensing systemsto support one application program. The FLEXlm SDK may be downloadedfrom:

http://www.globetrotter.com/flexlm.htm


EON SDK 2.53.014

FLEXlm licensing

The FLEXlm feature name must be the same as the module identifier inthe registry; this is automatically the case with an EON Module Wizardgenerated module. A module (feature) name must be unique,alphanumerical phrase. If you plan to use a licensing system otherthan FLEXlm, the same requirements apply.

If FLEXlm is used, the IAutApp interface (see the reference guide) maybe used to gain access to the license server through EON Studio byusing the CheckOutFeature() function, for example.

A license or feature always has a version number. It is important toknow that the license version number is not the same as the programversion number. Changing the license version number will cause allolder license keys to expire. The recommended procedure is to keep thesame license version number between major EON upgrades. In otherwords, EON 2.1, 2.2 and 2.5 would all use the same license versionnumber, but when EON 3.0 arrives, the license version number should beincremented.

Note: the version number of any feature may not exceed 10 digits(floating point format) due to restrictions in the current version ofFLEXlm.

EON Studio and modules

In order for EON Studio to find a module and its nodes, uniquemodule/node identifiers must be placed in the registry.

EON modules are registered as follows (note that the version key, 2.0,is correct, since it indicates which major version EON has reached):

HKEY_LOCAL_MACHINE \ SOFTWARE \ Prosolvia Clarus \ Clarus EON \2.0 \Modules \

The entry in the registry shall contain the following information:

The name of the module should be placed as the default value. Whether the module is loaded or not. 0 means not loaded, 1

means loaded. The registry name is LOADED. Whether the module is distributable or not. 0 means not

distributable, 1 means distributable. Use the registry nameDISTRIBUTABLE. To protect against tampering, this information isdouble-checked against the registry.

Nodes that are part of a module register themselves as follows:

HKEY_LOCAL_MACHINE \ SOFTWARE \ Prosolvia Clarus \ Clarus EON \2.0 \Modules \ \ \

The entry for the node shall contain:

The CLSID for the node. Use the registry key name CLSID.

User GuideWizards

2.5 15

The name of the DLL containing the icon for the node. Use theregistry key name IconDLL.

The resource ID of the Icon. Use the registry key name IconID.

Module registration functionality is already implemented in the codeskeleton generated by the EON Module Wizard, but if the modulecontains nodes, macros for their registration must be added to themodule skeleton: insert OBJECT_ENTRY(, )lines between the BEGIN_OBJECT_MAP() and END_OBJECT_MAP() macros inthe .cpp file.

The macro DECLARE_MODULE_CLSID() will use as itslicensing unit and should be inserted in the public area of the node'sclass declaration.

All modules must support the IEonModule interface foramong severalother purposeslicense protection. EON Studio needs to call theIEonModule functions CheckOutLicense(), OnConnect(), OnDisconnect()and CheckInLicense() during license handling.

How to disable licensing on your module

If you do not wish to use license protection on your module, alwaysreturn LICENSE_OK from your CheckOutLicense() function and a non-zerovalue from your OnConnect() function.

The relation between EON Studio and its modules

EON Studio consists of several components that interact with oneanother to provide the user with a working application. Thesecomponents are often implemented as separate modules that are loadedautomaticallyand unconditionallywhen you start EON Studio (forexample, some of those modules are the ones that display theButterfly, Scene graph and Component views).

The EON Studio application follows Windows so called documentviewobject model that splits the responsibilities between a number ofcomponents, namely:

the document, which is the object that encapsulates the actual data(the document corresponds to a complete EON simulation), and

a number of views that present the data in different ways (forexample the Routes window or the Simulation Tree window).

When the user modifies the application's data, these modifications aredirected towards the document. If the data has changed, some of theviews might need to be updated. The views only display subsets of allthe information contained in a documentthe views would otherwise becompletely cluttered with facts and figures, and thus they would bemore or less worthless to the user. An application could host severaldocumentsthat is, several sets of databut EON Studio currentlysupports only one document (simulation) at a time. (However, thismight change in later versions of EON Studio.)


EON SDK 2.53.016

Communication inside EON

The different parts of the EON Studio application must be able tocommunicate with each other. For example, you may want to passimportant information between two or more modules, or perhaps a nodeneeds to call certain functions of its parent node. This section isaimed to clarify the communication issue, and to help you choosebetween different options when there are several possible ways toperform a given communication task.

Communication between nodes

The preferred way to send information between two nodes, or to let onenode control another one, is to use events as described under one ofthe previous sections, What is a node/agent?

Some older nodes still use a more direct COM solution. Such a nodefirst acquires an interface to the node it wishes to affect, and thenit calls the appropriate function of that node. However, this methodis more or less regarded as obsolete, and consequently you should tryto avoid it. Instead, expose useful eventIn/-Out and exposedFieldfields and let the user implement a normal event-passing scheme in EONStudio's Routes window.

There is actually another way of changing the values of a node; youcould write scripts in e.g. VBScript that finds a node in thesimulation and then reads or sets the node's field values. Refer tothe Script node in the EON Studio Reference Guide for a thoroughdescription.

Commands

Used to invoke command handlers in modules when user has selected amenu item or a toolbar button bound to a particular command previouslyregistered by a module. Standard commands (such as Cut, Copy, Pasteand Delete) will be sent to the module in this way, plus ModuleMessages. However, this doubled information provision might becomesubject of change in future releases of EON Studio.

Module Messages

There is an obvious need for modules to communicate with each otherand with EON Studio. This is carried out using a concept called modulemessaging. It is based on a broadcast-subscribe strategy, where an EONStudio application object acts as the intermediatormodules that wishto inform its peers about something, make IAutApp::SendMessage() callsto EON Studio. A module interested in messages of a specific typeshould subscribe to those messages through an IAutApp::ListenTo()call. EON Studio will then add the module to its list of listeners.After subscribing, EON Studio will forward each received message ofthe requested type to the subscribing modules. Hence, EON Studio isemploying a kind of point-to-point multicast technique, with send-

User GuideWizards

2.5 17

lists based on the message types registered by the subscribingmodules.

1. Register message (IAutApp::GetToken )

2. Subscribe to message (IAutApp::ListenTo )

3. Send message (IAutApp::SendMessage )

4. Broadcast message tosubscribed module(s), using the

Win32 API SendMessage

Other EON Module(s)Logical messagingpath

Actual messaging procedure

EON Module 1

EON Studio

Figure 4. Schematic view of module messaging

The following messages types are predefined and used by EON Studio:

AA_GUID_CUT*: Sent by EON Studio when the user has selected the Cutcommand on the menu or the toolbar.

AA_GUID_COPY*: As above, but corresponding to the Copy command. AA_GUID_PASTE*: As above, but corresponding to the Paste command. AA_GUID_DELETE*: As above, but corresponding to the Delete command. AA_GUID_NODEBAGCHANGE: Sent when a nodebag has changed due to user

activities. AA_GUID_VIEWACTIVE: Sent whenever a new view has been activated in

EON Studio. AA_GUID_ICONCHANGED: Sent when the icon of a prototype (or node)

has been changed. AA_GUID_SETNODE: Sent by a module when a new node should receive

the focus in one of the EON Studio-specific windows, such as theRoutes window or the Butterfly window.

AA_GUID_NODEFOCUS: This message is sent by EON Studio when the userhas activated a new node.

AA_GUID_SHOWPROTO_PROP: Sent when the user requests the propertiespage of a specific prototype instance (mainly intended for internaluse).

However, some message types are defined but not yet used by EONStudio. They should be sent when the user selects the specific commandeither from one of the menus or on the toolbar :

AA_GUID_PRINT* AA_GUID_PRINTPREVIEW* AA_GUID_CLEAR* AA_GUID_CLEARALL* AA_GUID_UNDO* AA_GUID_REDO* AA_GUID_SELECTALL*

Each message above is briefly commented on in the file Commands.H inthe EON SDK Development Files folder.

A module is only allowed to listen to the so-called menu commandmessages (denoted by asterisks in the lists above), but can both


EON SDK 2.53.018

listen to and send messages of other types. A module may also freelydefine new message types that it could use when communicating withother modules.

Following is a brief description of how you should work with modulemessages.

1. To begin with, you perform module initialization. CallIAutApp::GetToken() once for each message type you want the moduleto recognize. Store all tokens for future useyou will need them todetermine the type of module message when Windows messages finallystart to arrive.

2. Then call IAutApp::ListenTo() for all the message types you'd likeEON Studio to forward to the module. As an argument, pass a handlerto the window you want to be the target for the specific messagetype. The module (or rather, one of the module's windows) is nowready to start receiving messages. It is important to note that youshould skip this step completely if you want to subscribe to menucommand messagesthose messages are received without callingIAutApp::ListenTo().

3. A WindowProc() message handler placed in the target window shouldfirst decide whether the received Windows message is a modulemessage. If so, the handler must decide which type the message hasyou should compare the message token with the ones you havepreviously stored (see Step 1).

4. If the message belongs to the set of module messages you'reinterested in, then let the WindowProc() handler process itaccordingly. Note that you should never change the contents of themessage structure. There might be other modules that listen to thesame message type. If you modify the information, those moduleswill receive corrupt messages.

Note that you should always work on copies of the original modulemessages if you wish to modify the contents of the messages.

5. If necessary, make your handler call the parent message handlerCWnd::WindowsProc() and return.

No snippets of code are included in this section. However, it isadvisable to inspect the source code of the Sample Module, or readthrough the ModuleView.CPP file created by the EON Module Wizard.

View handling

One of the most exciting features of creating an EON module is theability to seamlessly add custom views inside EON Studio. These viewsare treated in the same way as any standard views. In fact, some ofthe complex views (Scenegraph, Butterfly, ScriptEditor, etc) in EON

User GuideWizards

2.5 19

Studio are actually implemented as EON modules and using the sameinterface as described in this SDK.

Persistent views

A view in EON Studio can be in docked, floating or MDI state.Furthermore, the user can freely configure where to dock it or controlits size and position. When the user exits EON Studio, he usuallywould like to retain the view configuration so that next time he usesEON Studio, he would get back the same configuration. Therefore,before adding a custom view to EON Studio using the SDK, you shouldconsider whether the view should be persistent or not. A persistentview requires slightly more job but will maintain its windowinformation between sessions. In EON Studio, Scenegraph and Butterflyare persistent views while the ScriptEditor is not.

Implementing persistent views is accomplished by providing appropriatedata at certain callbacks. The following figure shows the sequence ofcallbacks when EON Studio is started. It also shows what the moduleshould do in each callback related to persistent views.


EON SDK 2.53.020

Wizards

The wizards delivered with EON SDK are accessed from the Projects tab of the File>Newdialog box in Visual Studio.

EON Node Wizard

Figure 5. EON Node Wizard in New Project Dialog

1. Select EON Node Wizard.

2. Enter a project name. Note that the project name must not includespaces or special characters.

3. Select the physical location for the project.4. Select Create new workspace to create a new node package. Use Add

to current workspace to add nodes to an existing node package. Todo this enter a temporary project name (for example, Added), selectthe Add to current workspace option and click OK. If Visual Studiowas properly configured, this project will be deleted automaticallyfrom the workspace. If the project is not automatically deleted,Visual Studio will ask you to locate the project file (calledAdded.dsp, if we use the above example) when you reopen yourworkspace. If this happens, select Cancel and delete the missingproject from your workspace.

6. Click OK.

Figure 6. EON Node Wizard dialog box

7. After opening a new node project, the EON Node Wizard dialog boxwill appear.

8. Enter the new node name. E.g. MyNode.

User GuideWizards

2.5 21

9. Select which node group the node should belong to. New node groupsmay be created.

10. Enter your nodes property page name. If you leave this field emptythe property page name will be the same name you gave the node withPP as a prefix. E.g. PPMyNode. This to avoid identical classnames.

11. Select the number of properties page tabs. If multiple tabs anumber will be added to the class name. E.g. PPMyNode,PPMyNode_2 and PPMyNode_3

12. Selected or deselect methods depending on the features you want toadd to your node.

Node methods

Serialize

If the node should be able to store data types other than thosedefined by the EON standard, the Store non-field data option should beselected. The generated C++ skeleton code will include a Serialize()function, where calls to the standard CArchive() functions (Read() /Write()) should be specified. See the MFC documentation for moreinformation.

Update

If the node should perform tasks once per frame, select this option.The generated C++ skeleton code will include an Update() function thatwill be called before each frame is drawn. This is where update codeshould be placed.

NOTE: Use this option sparingly to avoid burdening your system. Mostnodes need not be updated at every frame. These can be set to respondonly when they receive events.

EventsProcessed

If this option is selected, an EventsProcessed() function will beadded to the nodes C++ skeleton code. This function will be calledonce per frame if an event has been received since the previous framewas drawn. This is useful if data arrives at a higher rate than theframe rate, but when just the computed results (based on the incomingdata) of the complex calculations are needed.

IsSensor

Override this function to prevent the baseclass implementation thatreturns FALSE. If your implementation returns TRUE your node is asensor, i.e. it can generate out-events without first getting an in-event.

13. Visual Studio will confirm your actions in the New ProjectInformation window. Click OK to continue.

14. Visual Studio will ask you to close and reopen your workspace.Click OK to continue, and go to the File menu to close and reopen


EON SDK 2.53.022

the workspace. When the workspace is reopened, include the PPproject in the created workspace. The PP project is in a nodeproject sub-directory.

Wizard-generated files

As the wizard creates the new nodes code skeleton, it will generateseveral new files.

EON Node Wizard generated files:

Directory: ...\ProjectName

ProjectName.DSP

Visual Studio project file. Contains project settings, e.g. linkerdirectives.

STDAFX.H

Include file for standard system include files and the projectspecific include files that are used frequently but changedinfrequently. This file is included by STDAFX.CPP.

STDAFX.CPP

Source file used to create the project's precompiled header file(.pch).

RESOURCE.H

Header file containing resource symbol definitions, e.g., thedefault icon bitmap resource. This file is included by the resourcescript.

ProjectName.RC

Project resource script containing version information, stringtable, dialogs, icons and bitmaps, compiled into a binary resourcethat is linked to the project output file. (ProjectName.DLL).

ProjectName.DEF

Module-definition file is a text file that contains statements fordefining ProjectName.DLL and its exports.

ProjectName.IDL

The interface specification file consists of an interface headerfollowed by an interface body. The interface header includes anattribute list describing characteristics that apply to theinterface as a whole. The interface body contains the remote datatypes and function prototypes. This file is compiled by MIDL beforethe C++ compiler is activated. The MIDL output is ProjectName.H,which is included in ProjectName.CPP.

ProjectName.CPP

Implementation of ProjectName.DLL exports.

NodeName.H

User GuideWizards

2.5 23

Node class definition. The inheritance and COM map specifies whichinterfaces the node supports. For example, if the IAgent interfaceis supported, the node should implement the Update method.

The header file is more or less the same for all nodes. The maindifferences are in the class names and in the FID_ enumerationthat supplies field identifiers.

NodeName.CPP

Node implementation. Construction, destruction, initialization andprocessing field data.

Directory: ...\ProjectName\Res

DEFAULTI.BMP

Default icon linked to all created nodes.

Directory: ...\ProjectName\PPProjectName

PPProjectName.DSP

See description in previous section.

STDAFX.H


STDAFX.CPP


RESOURCE.H

Header file containing resource symbol definitions, e.g., dialogresources. This file is included by the resource script.

PPProjectName.RC

Project resource script containing version information, stringtable, dialogs, icons and bitmaps, compiled into a binary resourcethat is linked to the project output file. (PPProjectName.DLL).

PPProjectName.DEF


PPProjectName.CPP

Implementation of PPProjectName.DLL exports.

EONPE.H

Uses the DECLARE_PPCLASS macro on the first properties page of eachnode. This macro defines a class for each node that contains allthe properties pages used by the node.

EONPE.CPP

Implements one class for each node that has an array membercontaining all the properties page objects used by the node.

PPNodeName.H


EON SDK 2.53.024

Definition of a class derived from MFC's CpropertyPage.

PPNodetName.CPP

Implements the EON properties page and the DataTransfer function.This function transfers data of those fields handled by theproperties page to the appropriate node.

Node C++ source file

The wizard creates one source file for each node and one for theproject, i.e., the DLL.

Project IDL file

The IDL file contains interface definitions and CoClass definitions.There is only one IDL file per DLL. All interfaces and classesimplemented in a specific DLL are defined in the IDL file.

Writing nodes in C++

Manipulating in- and out-fields by using logic operations andalgorithms requires a minimum of programming experience. Use standardC++ programming to implement the desired functionality in any of thefollowing functions: FieldChanged(), OnPreUpdate(), Update() orOnPostUpdate (), depending on when your code should execute. Rememberthat the execution model traverses all the way through the simulationtree when calling these functions; a child node is always called afterits parent.

When designing a new node, one has to decide how it shall interactwith its surroundings. E.g., the EON Rotate node rotates its parent,while the KeyboardSensor uses eventOut fields and routes.

With standard Windows programming, it is possible to incorporatehardware such as mice, printers or mass storage devices. If you needaccess to the graphics core of EON, you must use DirectX.

Defining fieldsDefine fields in the InitClass() function. The base class constructor calls thisfunction the first time an instance of your node is created.

Accessing field values

Processing eventIn

Generating events

Loading and Saving (Serializing)

Using DirectX

The DirectX component that is useful when working with graphics isDirect3D. For example, you can get and set individual vertex positionsby using the included mesh interface. This DirectX component also hasseveral other interfaces for frames, viewports and textures.

User GuideWizards

2.5 25

If you use Direct3D functions within your node, you must obtain a COM(Component Object Model) interface using either QueryInterface() orCComQIPtr().

QueryInterface() requires you to release the interface when it is notneeded. If you acquired an interface in the OnInitialize() function,release it in the OnReset() function.

CComQIPtr() is used primarily when you will only use the interfacetemporarily, e.g., as in the OnInitialize() function below. An objectof this class performs automatic reference counting through calls toAddRef and Release.

Although all available DirectX functions are fully documented in theDirectX SDK, it might be worthwhile to obtain one of the many books onthe topic.

Interfaces

The recommended procedure for accessing other nodes in EON Studio isby modifying their fields. However, some older nodes are stillaccessible via the interfaces they implement. See the Reference Guidefor more information on how to query for a COM interface and to see alist of useful interfaces. A more complete description of interfacesis beyond the scope of this guide.

Connection points in EON

A connection point is a COM standard feature for sending outgoingevents. Each connection point is exposed by an outgoing interface. Anyclient object may connect to an object exposing one or more connectionpoints to receive events from that object. A client object implementsthe outgoing interface, a notify sink.

Implementing connection points improves simulation performance. InEON, a node implements a subset of all defined interfaces.

If you use connection points with EON, use them with ATL and a help classCConnectionPointAdvisor; the procedure is otherwise quite complicated.

Using the EON log

EONs log handling features provide the developer with improvedfunctions for filtering out log messages that are irrelevant to thedevelopment process. Log messages can be sent from nodes (in the C++code) and from Script nodes. Each log message has input arguments:LogType, Source, Description and Message.

Adding an icon to a node

You can easily add a specially designed icon to a new node created inVisual Studio. Choose Insert>Resource to add a new bitmap to your EONnode project. In the resource editor, resize the drawing area to a16x16 square. Visual Studio will give your bitmap a default name. Ifyou want to rename it, click the icon name to view its properties.Open your node source file and replace IDB_DEFAULT_ICON inside theGetIconID() function with a new bitmap name, for example, IDB_NODE.


EON SDK 2.53.026

EON Module Wizard

The EON Module Wizard is used to create a code skeleton for a newmodule.

Figure 7. EON Module Wizard

1. Select EON SDK Module Wizard.

2. Enter a project name. Note that the project name must not includespaces or special characters.

3. Select the physical location for the project.4. Decide whether the project should be created in a new workspace or

added to the current workspace.

5. When you click OK the following dialog box will appear.

Figure 8. EON Module Wizard dialog

6. In the Module Wizard's first step, you fill in the Module name,Version, Program ID (version-independent ProgID) and Descriptionfields. Then click on the Next button.

7. In the second step, decide whether your module should supportviews. If so, do you need a standard view or perhaps split views?Enter the number of rows and columns if you choose split views.

8. If you selected a view, you may specify standard and proprietarymodule messages to be handled by the module's view class.

9. Furthermore, you could choose to make the new module includecommand handlers for default and custom commands. (Commands areexposed to the user as menu items or via toolbar buttons.) Nowclick Next.

10. As the third and last step, you can select whether to includelogging of errors, and support for verbose logging. Here, youshould also select the licensing option (providing that you alreadyhave a functioning license feature). Otherwise, keep it as it to

User GuideWizards

2.5 27

disable licensing (the licensing source code will just be commentedoutnot deleted).

11. Always leave the EonBase2.h option as it (checked)this selectionis only intended for internal use, by the development team at EONReality.

12. Click Finish. The New Project information window will appear. Thefiles the wizard will create are listed, along with otherinformation.

Figure 9. New Project Information window

13. Click OK to continue. The wizard will now generate the codeskeleton for the module. Note that you must close the project andreopen it before compiling the project. This is due to limitationsin Visual Studio.

Wizard generated files

The EON SDK Module Wizard generates the following files:

Directory: ...\ProjectName

ProjectName.DSPThis is the normal Visual Studio project file. It keeps track ofwhich files are currently included in the project, stores projectsettings, etc

STDAFX.H

Include file for standard system include files and the project-specific include files that are used frequently but changedinfrequently. This file is included by STDAFX.CPP.

STDAFX.CPP

This C++ source file is used to create the project's precompiledheader file (.pch).

RESOURCE.H

This header file contains resource symbol definitions, e.g., thedefault icon bitmap resource. Visual C++ reads and updates theResource.H. It is included by the resource script, ProjectName.RC.

ProjectName.RCProject resource script containing, for example, version


EON SDK 2.53.028

information, string tables and bitmaps. It is compiled into abinary resource that is linked to the project output file.

Toolbar.BMPThis bitmap exists only if you choose the Add custom command totoolbar option in the Module Wizard. The bitmap file contains justthree toolbar buttons, but you can easily extend it to include asmany buttons you'd like.

ProjectName.DEFWindows definition file. It contains the exposed entry points ofthe ProjectName.DLL.

ProjectName.IDLThe IDL file of our project. You will add interface and methoddefinitions here. Microsoft's MIDL compiler will process this fileto produce the type library (.tlb) file, in addition toProjectName.h, which is included in ProjectName.CPP.

ProjectName.HThis file contains interface declarations for the COM object, i.e.,EON module. The MIDL compiler produces the ProjectName.h file basedon the project's IDL file.

ProjectName.CPPThis is the main implementation file for the COM object housing. Itcontains source code for the DLL exports, and offers both ATL andMFC support. (Note the presence of the_Module and theApp globalvariables that are there to support the use of ATL and MFCclasses.)

EONMODULE.H

This header file contains the class declaration of your EON Studiomodule's class CEonModule, which is the class you have to modify toinclude module-specific functionality.

EONMODULE.CPP

The CEonModule class is implemented in this file. It may providefunctions for licensing, connecting new views to the EON StudioGUI, adding toolbars, etc.

MODULEVIEW.H

This file holds the declarations of the sub-classed window used asthe module's view.

MODULEVIEW.CPP

This file contains the source code for the implementation of thesub-classed window that your module uses as its view (or as splitviews). This is where all displaying of GUI objects for variousdata exposure should be placed. Here, you should also add code tosupport different kinds of module messages (that is, if you havedecided to include module message handling in your module).

README.TXT

This file contains some brief information about each file insertedinto the new project.

User GuideWizards

2.5 29

Writing modules in C++

To add features, changes to the module are made in the followingfiles:

EonModule.CPP

EonModule.H

ModuleView.H

ModuleView.CPP

The resource file may also need to be changed if you want to add ormodify toolbars, dialog boxes, etc.

For code samples, see the Sample Module on the EON SDK CD.


EON SDK 2.53.030

Techniques

Smart pointers

All COM objects encapsulate an integer value that keeps track ofobject usage. Each time a client creates a COM object the AddReffunction of that object is called. This increment the objectsreference counter by one and prevents the destruction of that objectwhen it goes out of scope. This way separate parts of the client oreven different clients may use the same object that will persist aslong as its reference counter is larger than zero. When an objectsRelease function is called its reference counter is decrement by one,if this result in a zero value the object deletes it self.

Each time a new pointer is introduced AddRef should be called,otherwise the pointer may become invalid. And before the pointer goesout of scope the programmer has to call Release otherwise there willbe a memory leak. Trouble occurs when a programmer has severalpointers to several different COM objects, e.g.:

#include #include "shlobj.h" // Shell COM components#include "objbase.h"

int main(void){

HRESULT hr = CoInitialize(NULL);if (FAILED(hr)){

CoUninitialize();return -1;

}

IUnknown* pUnk1;// CoCreateInstance calls AddRefhr = CoCreateInstance

(CLSID_ShellLink,NULL,CLSCTX_INPROC_SERVER,IID_IUnknown,(void **) &pUnk1

);

if (FAILED(hr)){


}

IUnknown* pUnk2 = pUnk1;ULONG lRef = pUnk2->AddRef();printf("Reference counter = %d\n", lRef);

lRef = pUnk2->Release();printf("Reference counter = %d\n", lRef);

lRef = pUnk1->Release();printf("Reference counter = %d\n", lRef);

CoUninitialize();return 0;

}

Obviously it is quite easy to forget ether AddRef and Release on pUnk2or Release on pUnk1 since CoCreateInstance did AddRef for us. To avoidthis behavior we could encapsulate all COM pointers in a templateclass that calls AddRef when it is assigned to an object and Release


2.5 31

when it goes out of scope. Below you will see an example of such agarbage collecting class, this to make it easier to understand the ATLsmart pointers later.

// Unknown.h

class CUnknown{

int m_ReferenceCount;

public:

CUnknown();~CUnknown();void AddReference(void);void ReleaseReference(void);

};

/***********************************************************/

// Unknown.cpp

#include #include "Unknown.h"

CUnknown::CUnknown(){

m_ReferenceCount = 0;}

CUnknown::~CUnknown(){

printf("CUnknown object destroyed!\n");}

void CUnknown::AddReference(void){

m_ReferenceCount = m_ReferenceCount + 1;printf("AddReference: ");printf("Reference count = %d\n", m_ReferenceCount);

}

void CUnknown::ReleaseReference(void){

m_ReferenceCount = m_ReferenceCount - 1;if (m_ReferenceCount == 0){

printf("ReleaseReference: ");printf("Reference count = 0\n");delete this;

}else{

printf("ReleaseReference: ");printf("Reference count = %d\n", m_ReferenceCount);

}}

/***********************************************************/

// SmartPtr.h

template class CSmartPtr{

T* p;

public:

CSmartPtr(T* p_){

p = p_;p->AddReference();

}

~CSmartPtr(void){

p->ReleaseReference();}

// Type cast operator// from SmartPtr to Toperator T*(void){

return p;}

// Indirection operator// return a reference to a T objectT& operator*(void){

return *p;


EON SDK 2.53.032

}

// Member-selection operator// return a pointer to a T objectT* operator->(void){

return p;}

// Assignment operator// for CSmartPtr = CSmartPtrCSmartPtr& operator=(CSmartPtr &q_){

return operator=((T *) q_);}

// Assignment operator// for CSmartPtr = T*CSmartPtr& operator=(T* p_){

p->ReleaseReference();p = p_;p->AddReference();return *this;

}};

/***********************************************************/

// main.cpp

#include #include "Unknown.h"#include "SmartPtr.h"

class CMyClass : public CUnknown{// This is my fake "COM-object".// It inherits AddReference and ReleaseReference// from CUnknown. The SmartPtr knows that all fake// "COM-objects" has these methods.

public:CMyClass() {};~CMyClass() {};int MyMethod(void) {return 42;}

};

int main(void){

int a, b;

printf("Creating pointers:\n");CSmartPtr pSmart1 = new CMyClass;CSmartPtr pSmart2 = new CMyClass;

CMyClass* pSilly = new CMyClass;pSilly->AddReference();

printf("\nTesting pointers:\n");a = pSilly->MyMethod();b = pSmart1->MyMethod();

printf("Silly = %d, Smart1 = %d\n", a, b);

printf("\nAssigning pointers:\n");pSmart2 = pSmart1;pSmart1 = pSilly;

printf("\nRelease pSilly\n");pSilly->ReleaseReference(); // Not delete

printf("\nOut of scope!\n");

return 0;}

In this example the CUnknown class imitates the behavior of theIUnknown interface that all COM objects have, this is the interfacethat allow reference counting. CMyClass is the fake COM object thatinherits its reference counting abilities from CUnknown. We must callAddReference and ReleaseReference on the pSilly pointer exactly aswith the real COM pointers (pUnk) in the previous example. To getaround that we use the SmartPtr template class. This classencapsulates any fake COM object and calls AddReference andReleaseReference on that object in situations that requires such acall, e.g. when the SmartPtr object goes out of scope. It overrides


2.5 33

the * and -> operators to expose the contained object instead of theSmartPtr object it self. The program output should be something likethis:

00: Creating pointers:01: AddReference: Reference count = 102: AddReference: Reference count = 103: AddReference: Reference count = 104:05: Testing pointers:06: Silly = 42, Smart1 = 4207:08: Assigning pointers:09: ReleaseReference: Reference count = 010: CUnknown object destroyed!11: AddReference: Reference count = 212: ReleaseReference: Reference count = 113: AddReference: Reference count = 214:15: Release pSilly16: ReleaseReference: Reference count = 117:18: Out of scope!19: ReleaseReference: Reference count = 020: CUnknown object destroyed!21: ReleaseReference: Reference count = 022: CUnknown object destroyed!

Here line 1-2 shows that the SmartPtr class calls the CMyClassAddReference function for us, while we have to make that call our selfon line 3 for the pSilly standard pointer. Next, we test that itreally is the CMyClass object that we reach with the -> operator. Whenassigning pSmart1 to pSmart2 the original object that pSmart2 pointsto is released and destroyed on line 10. Then the object that pSmart1points to get one more reference on line 11 when pSmart2 also isassigned to point towards it. Then in line 12 pSmart1 is set to pointto the same object as pSilly. That is why the reference counter on theobject previously pointed to by pSmart1 is decrement by one. On thenext line the object pointed at by pSilly increments its referencecounter when pSmart1 is assigned to it as well. On line 16 the pSillypointer is released, but since pSmart1 also points to that object thereference count will not become zero and therefor the object will notbe deleted. Now both SmartPtr has one object each. Both objectreference counts are one and therefor they will be deleted whenpSmart1 and pSmart2 goes out of scope. Since the automatic destructionof the SmartPtr template class objects will decrement those referencecounts to zero.

CComPtr and CComQIPtr

Active Template Library (ATL) provides programmers with CComPtr andCComQIPtr smart pointer template classes specialized for COM-objects.In comparison our SmartPtr class is not really that smart. Similar toour class they support automatic reference counting through calls tothe COM-objects AddRef and Release functions. Unlike our templateclass CComPtr and CComQIPtr overloads several more operators, handling


EON SDK 2.53.034

every pointer operation in a safe manner. E.g. the address operator(&) will return the address of the encapsulated COM-object.

Both ATL smart pointer classes support the following operators:

T*Type cast from CComPtr or CComQIPtr to T*

* Accesses the encapsulated object

& Address of the encapsulated object

->Member access through a pointer to the encapsulated object

= Assignment between two smart pointers or one smart pointer and oneT object

! Check if valid pointer. Returns TRUE if there is not anencapsulated COM object, otherwise FALSE

CComPtr and CComQIPtr both has a public member p, that is the actualstandard pointer to an object of the class T. They also implement aRelease method so that direct calls to p->Release() may be avoided.The difference between CComPtr and CComQIPtr is that the latter canmake QueryInterface calls for you as shown below.

#include #include "shlobj.h"#include "objbase.h"#include "atlbase.h"

int main(void){

HRESULT hr = CoInitialize(NULL);if (FAILED(hr)){


}

// Start code block{

CComPtr pSLink;//IShellLink* pShellLink;// CoCreateInstance calls AddRefhr = CoCreateInstance

(CLSID_ShellLink,NULL,CLSCTX_INPROC_SERVER,IID_IShellLink,(void **) &pSLink

);

if (FAILED(hr)){


}

CComPtr pPF1;hr = pSLink->QueryInterface

(IID_IPersistFile,(void **) &pPF1


2.5 35

);

if (FAILED(hr)){

printf("Query for IPersistFile failed!\n");CoUninitialize();return -1;

}

CComQIPtr pPF2(pSLink);if (!pPF2){

printf("Query for IPersistFile failed!\n");CoUninitialize();return -1;

}

printf("Out of scope.\n");printf("Smart pointers calls Release on ");printf("encapsulated objects before\n");printf("pSLink, pPF1 and ");printf("pPF2 are destroyed.\n");

}// End code block

CoUninitialize();

return 0;}

The code block in this example is used to make the variables to go outof scope before the CoUninitialize call, otherwise the DLL containingthe ShellLink object will unload and our poiners become invalid.

For more information on these two template classes see theredefinition in ATLBASE.h or Microsoft Developers Network.

User GuideTutorials

EON SDK 2.53.036

Summary:

Use the Module Wizard to lay down the ground (skeleton code).

Remove stuff you dont need.

Add or modify implementation to get the job done.

Most frequently, you will need to modify/add more command handlersand adapt the OnUpdate handler.

Reference GuideIntroduction

2.5 37

Introduction

About the Reference Guide

In this reference guide, you will find information on the functionsused in EON SDK. The guide is divided into two sectionsone sectioncovers functions that are used when creating nodes, the other containsinformation needed to build modules

In the first section, the functions are listed alphabetically. Thelistings provide function descriptions and information on parametersand return values. There are also short examples illustrating how thefunctions are used.

The module section contains a list of COM interfaces used in EON SDK.

General

Data types

The data types used in EON SDK are listed in the following table withinformation on the corresponding event types, a brief description foreach data type, in addition to its valid range.

You should be familiar with the standard data types used by EON.Single-value fields and events have names that begin with SF (forSingle Field). Multiple-valued fields and events have names that beginwith MF (Multiple Field).Type Event type name Description RangeInteger SFInt32 An integer value [2,147,483,648; 2,147,483,647]

Float SFFloat A floating-point value [-3.4E-38; 3.4E 38]

Double SFDouble A double precision float [-1.7E 308; 1.7E 308]

String SFString A string N/A

2D float vector SFVec2f A two-dimensional float vector Same as Float for both components

3D float vector SFVec3f A three-dimensional float vector Same as Float for each component

Boolean SFBool Boolean value TRUE/FALSE

Node SFNode Reference to a node N/A

Color SFColor Three floats, one for each of the Red,Green an Blue color components

[0.0; 1.0] each

Time SFTime A double precision float representingseconds

Same as Double

Rotation SFRotation Four floats: rotation around an axis,measured in radians; the axis isdefined in (x,y,z) coordinates

Same as Float for each component

Image SFImage Placeholder for an arbitrary bytevector

N/A

All SF data types have an array counterpart carrying the prefix MF.These MF data types can hold several SF data values. For example,several SFNode values can be stored in a single MFNode field.

Reference GuideClasses in EON SDK

EON SDK 2.53.038

Nodes

Default node fields

There is a well-defined set of fields that every node alwaysimplements by default. One such field is the Children MFNode field,where all the children of a the node are listed. The TreeChildrenfield is the placeholder for the same nodes as listed in the Childrenfield, but also stores node references. These references are links tochildren that actually belong to other nodes. (See the Script nodedescription in the EON Studio Reference Guide for more information onhow to manipulate MFNode fields using VBScript.)

All nodes may be started or stopped with events, and they send eventsto reflect changes in their running status. If a node is to be startedor stopped, the SetRun or SetRun_ in-events should be used. These in-events use Boolean data: a SetRun value of TRUE will start a node andvalue of FALSE will stop it. SetRun_ is the inverse of SetRun (FALSEis used for start and TRUE for stop).

Some nodes do not need start/stop capabilities. Implementation ofthese nodes requires neither the SetRun and SetRun_ in-events, nor theOnStart() and OnStop() functions. Nevertheless, the SetRun and SetRun_fields will still be exposed.

Name Field type Data type Description RangeTreeChildren field MFNode Holds both child nodes and node references N/A

Children field MFNode Holds the node's child nodes. N/A

SetRun eventIn SFBool Starts the node if it is stopped TRUE/FALSE

SetRun_ eventIn SFBool Stops the node if it is running TRUE/FALSE

OnRunFALSE eventOut SFBool Sent when the node is stopped Always TRUE

OnRunTRUE eventOut SFBool Sent when the node is started Always TRUE

OnRunChanged eventOut SFBool Sent when the node changes state from running tostopped or vice versa

TRUE/FALSE


2.5 39

Classes in EON SDK

CAgent

CEonBase

EventsProcessed

FieldChanged

ValidateField

EventGenerated

FinalConstruct

FinalRelease

InternalGetField

GetPropertyEditorCLSID

InitClass

Serialize

CEonObject

OnInitialize

OnReset

OnStart

OnStop

CExternalReference

OnGetReference

OnGetReferenceCount

OnSetReference

CNode

MoveChild

SwapChildren

CConnectionPointAdvisor

Advise

Unadvise

EonUtil

EonFindNode


EON SDK 2.53.040

EonFindNodePath

EonFindNodeWithInterface

EonGetName

EonGetParentFrame

EonGetParentRMFrame

EonGetPath

EonGetRoot

EonGetSimulationInstance

EonHasInterface

EonLoadFileToDisk

EonReleaseSimulationInstance

EonReportError

GetCameraDistance

GetCameraPosition

GetCameraSQRDistance

Reference GuideModules

2.5 41

Modules

Interfaces for EON Modules

There are several COM interfaces that will interact with the modularsystem.

Reference GuideInterfaces

EON SDK 2.53.042

Interfaces

There are a large number of COM interfaces for the various softwarecomponents in the EON environment. The following section is intendedto provide you with a thorough overview of useful interfaces. You willmost certainly need to access several of the interface functions whenworking as an EON SDK application developer. Note that if you find aninterface not included in the list below, you should try to avoidusing it.


2.5 43

IAgent

Update

IAgentFrame

RenderRef

RenderRef_

TransformToFrame

TransformToWorld

IAgentFrame2

GetLocalTransform

SetLocalTransform

GetWorldTransform

SetWorldTransform

IAgentSimulation

GetDescription

SetDescription

GetNoTreeNodes

GetNoIniTreeNodes

IncIniCounter

GetStatisticsOn

SetStatisticsOn

LockRender

UnlockRender

IAgentViewport

SetFront

GetFront

SetBack

GetBack

SetViewport

GetViewport

GetFieldOfView

SetFieldOfView

IsClicked

IAutApp


EON SDK 2.53.044

ActivateView

AddCommandTarget

AddMenuItem

AddModuleWindow

AddToolbarButton

CheckInFeature

CheckOutFeature

ConnectSplitView

ForceDemoMode

GetConfig

GetDocument

GetHostID

GetLicenseKey

GetLicenseStatus

GetNextModule

GetNodeInfo

GetNodeInfoCount

GetPositionFirstModule

GetSettings

GetToken

GetUserList

GetUserName

GetViewPosition

HideView

IsDemoMode

IsModuleLoaded

ListenTo

LogMessage

RegisterCommand

RegisterToolbar

RegisterSplitView

RegisterView

RegisterView2

RemoveView

SendMessage


2.5 45

SetDefaultWindowPosition

SetViewName

ShowView

IAutDoc

GetSelectedNode

GetSimulation

GetSimulationRoot

SetDirty

UpdateAllViews

IAutNodeInfo

GetCategory

GetCLSID

GetIconDLL

GetIconID

GetModuleCLSID

GetNodeName

IAutPrototype

GetRootNode

GetSubPrototypes

IAutPrototypes

GetCount

GetPrototype

IAutSettings

CreateSubKey

EnumKeys

FindSubKey

GetApplication

GetRegInt

GetRegString

GetStandardKey

RemoveSubKey

SetRegInt

SetRegString


EON SDK 2.53.046

CurrentRegKey

CurrentBaseKey

IAutSimulation

GetPrototypes

GetRootNode

Run

Stop

ICEonConfig

DoEditModal

IChainSimulation

SetNewSimulation

GetNewSimulation

IDegreeOfFreedom

IDeviceKeyboard

GetKey

SetKey

IEnumNodes

Next

Skip

Reset

Clone

IEonDual

GetField

GetFieldByName

GetFieldCount

GetFieldInfo


2.5 47

GetIdOfName

GetParentNode

IEonEvent

GetField

GetFieldByName

GetFieldCount

GetFieldInfo

GetIdOfName

IsSensor

CollectEvent

InternalEventsProcessed

SetDirty

DeliverEvent

IEonField

GetMFCount

GetMFElement

GetMFSpan

GetSFBool

GetSFColor

GetSFFloat

GetSFImage

GetSFInt32

GetSFNode

GetSFRotation

GetSFString

GetSFTime

GetSFVec2f

GetSFVec3f

SetMFElement

SetMFSpan

SetSFBool

SetSFColor

SetSFFloat

SetSFImage


EON SDK 2.53.048

SetSFInt32

SetSFNode

SetSFRotation

SetSFString

SetSFTime

SetSFVec2f

SetSFVec3f

SetValueFromField

AddMFElement

_RemoveMFElement

_SetMFCount

SetVariant

GetVariant

GetOwner

GetStringValue

SetStringValue

TouchField

ValidateField

GetFieldInfo

IEonField2

GetLastInput

IEonField3

Load

Save

GetFieldID

IEonFieldDual

SetValue

GetValue

SetMFElement

AddMFElement

RemoveMFElement

GetMFElement

GetMFCount

SetMFCount


2.5 49

SetStringValue

GetStringValue

GetFieldType

GetFieldName

IEonInsertable

IEonModule

CheckInLicenseSynopsis

CheckOutLicense

GetCLSID

GetDistributionRight

GetSplitPaneReinitInfo

GetViewReinitInfo

OnCommand

OnConnect

OnCreateView

OnDeleteContents

OnDisconnect

OnModuleListChanged

OnNewDocument

OnOpenDocument

OnQueryDefWinPos

OnSave

OnSimulationRun

OnSimulationStop

OnUpdate

OnUpdateCommandUI

IEonObject

GetIcon

OnNewParent

OnNewChild

OnEdit

Initialize

Reset

Clone


EON SDK 2.53.050

Start

Stop

IsRunning

IsInitialized

IEonObject2

SetSimulation

GetCLSID

Save

Load

IsDirty

LoadLegacy

OnRemoveChild

OnAddChild

OnSetParent

ValidateNewChild

SetDirty

LoadIcon

IEonPropertyEditor

DoModal

IEonPrototype

CreatePrototypeFromSubtree

HasNonExportableExternalLinks

SetPrototypeName

GetPrototypeName

SetIcon

GetIcons

GetIconsDib

CreateSubBagIterator

GetSubBag

RemoveSubBag

AddSubBag

GetParentBag

GetGUID

FindSubBag


2.5 51

GetInstanceCount

SetShortDescription

GetShortDescription

SetLongDescription

GetLongDescription

GetExportedFieldCount

AddExportedField

GetExportedField

GetExportedFieldIDByName

SetExportedField

RemoveExportedField

CreatePrototypeInstance

SetUserData

GetUserData

ExpandAllProtoypes

UnexpandAllProtoypes

GetBagID

IEonSingleton

SetSimulation

IEonSingletonFactory

GetSimulationInstance

ReleaseSimulationInstance

IExternalEvents

SendEvent

AddEventInField

AddEventOutField

DeleteEvent

DeleteAllEvents

SendOutEvent

IExternalEventsNotifySink

OnEvent

IExternalReference

GetReference


EON SDK 2.53.052

SetReference

GetReferenceCount

IFileLoader

SetSimFile

GetSIMDIR

SetPath

GetPath

GetAbsPath

MergePath

LoadFile

LoadFileToDisk

IFileLoader2

GetSimFileName

GetSimFileNameLenght

IFileLoader3

SetSimFile

GetSIMDIR

SetPath

GetPath

GetAbsPath

MergePath

LoadFile

LoadFileToDisk

GetSimFileName

SimFileNameLength

Close

IGUIMotionModel

MotionNotify

RequestMotionModelImages

IJoystick

GetNoJoysticks

GetJoystickCapabilities

GetJoystickData


2.5 53

GetJoystickProperties

SetJoystickProperties

IJoystickState

OnJoystickChange

OnJoystickButtonChange

OnJoystickPositionChange

IKeyboard

GetVKey

GetVKeyPresses

SetVKey

SetVKeyPresses

IKeyboardState

OnKeyboardChange

ILinkIterator

Reset

Next

IsValid

Current

IMakePersistant

SaveAll

IMouse

GetMouse

SetMouse

IMouseState

OnMouseButtonChange

OnMouseChange

OnMousePositionChange

INode

SetParent

GetParent

AddChild


EON SDK 2.53.054

RemoveChild

GetChild

GetChildren

GetChildrenCount

SetName

GetName

SetBag

GetBag

SetID

GetID

INodeBag

DeleteContents

CreateNode

AttachNode

Save

Load

CopyNode

CopyLink

MoveSubtree

MoveLink

Paste

CanPaste

GetParentID

GetParentPtr

GetINode

GetRefCount

GetRefTarget

InsertRef

CanInsertRef

DeleteRef

AddRoute

GetLink

DeleteLink

DeleteSubtree

SeverLink


2.5 55

GetReference

GetNodeCount

CreateNodeIterator

CreateLinkIterator

AddField

DeleteField

SwapChildren

MoveChild

GetAtomFromString

GetStringFromAtom

IsPersistentSave

Dump

INodeBagAge

GetRoutesAge

INodeBagFiles

GetFileLoader

INodeBagIterator

Reset

Next

IsValid

Current

INodeBagIteratorFactory

CreateNodeIterator

CreateLinkIterator

CreateSubBagIterator

INodeIterator

Reset

Next

IsValid

Current

INodeLicense

GetLicenseOptions


EON SDK 2.53.056

GetModuleCLSID

IPCLogQueue

Log

GetLogEvent


2.5 57

UseLogType

IsLogTypeUsed

IPrototypeDefinitionHolder

GetPrototypeDefinition

GetSearchPath

IReference

GetLink

SetLink

UpdateLink

IRouteManager

AddRoute

RemoveRoute

EnableNode

DisableNode

AddNode

DeleteNode

PendingEvent

EventDelivered

IRouteManager2

SetEventProcessing

GetEventProcessing

RegisterCallback

UnRegisterCallback

IRunControl

SetBreakFlag

GetBreakFlag

ISettingsServer

Edit

SetSubKey

IsRestartNeeded

ISettingsServer2

UseCurrentSubKey


EON SDK 2.53.058

ISimulation

GetHwnd

SetHwnd

Update

HandleActivate

HandlePaint

HandleResize

HandleMove

ISimulation2

GetSimulationState

GetActiveCamera

GetActiveCameraPos

ConvertLegacySimulation

ISimulation3

IncrementVisualAgeCounter

ISimulationEONXEvent

OnSetMotionModelImages

ISimulationExternalEvents

GetExternalEventsNode

ISimulationMotionModel

MotionNotify

SetMotionModelImages

InactivateGUIMotionModel

ActivateGUIMotionModel

ISimulationRenderEvents

OnPreRenderViewport

OnPostRenderViewport

ISimulationRenderEvents2

OnRenderSync

OnRender

OnFlip


2.5 59

ISimulationRenderEvents3

OnRenderTransparent

ISimulationStateEvents

OnStateChange

ISimulationUpdateEvents

OnPreUpdate

OnPostUpdate

ISimulationWindowEvents

OnWindowSizeChanged

ITraversal

GetState

IVersionInfo

GetDependencies

EON SDK 2.53.060

Macros

Add field macros

Version information macros


2.5 61

Index

Accessing field values, 25ActivateGUIMotionModel, 60ActivateView, 45Add field macros, 62AddChild, 56AddCommandTarget, 45AddEventInField, 54AddEventOutField, 54AddExportedField, 53AddField, 57AddMenuItem, 45AddMFElement, 50AddModuleWindow, 45AddNode, 59AddRoute, 57, 59AddSubBag, 53AddToolbarButton, 45Advise, 40Agent Wizard generatedfiles, 23Agents, 9, 39AttachNode, 56CAgent, 40CanInsertRef, 57CanPaste, 57CConnectionPointAdvisor, 40CEonBase, 40CEonObject, 40CExternalReference, 40CheckInFeature, 45CheckInLicenseSynopsis, 51CheckOutFeature, 45CheckOutLicense, 51Classes in EON SDK, 40Clone, 47, 52Close, 55CNode, 40CollectEvent, 49Connection points, 26ConnectSplitView, 45ConvertLegacySimulation, 60CopyLink, 56CopyNode, 56CreateLinkIterator, 57, 58CreateNode, 56CreateNodeIterator, 57, 58CreatePrototypeFromSubtree,52CreatePrototypeInstance, 53CreateSubBagIterator, 53,58CreateSubKey, 46Current, 55, 58CurrentBaseKey, 47CurrentRegKey, 47Data types, 38Default node fields, 39Defining fields, 25DeleteAllEvents, 54

DeleteContents, 56DeleteEvent, 54DeleteField, 57DeleteLink, 57DeleteNode, 59DeleteRef, 57DeleteSubtree, 57DeliverEvent, 49DisableNode, 59DoEditModal, 47DoModal, 52Dump, 57Edit, 59EnableNode, 59EnumKeys, 46EON Agent Wizard, 21EON licensing, 13EON log, 26EonFindNode, 41EonFindNodePath, 41EonFindNodeWithInterface,41EonGetName, 41EonGetParentFrame, 41EonGetParentRMFrame, 41EonGetPath, 41EonGetRoot, 41EonGetSimulationInstance,41EonHasInterface, 41EonLoadFileToDisk, 41EonReleaseSimulationInstance, 41EonReportError, 41EonUtil, 41EventDelivered, 59EventGenerated, 40Events, 10EventsProcessed, 40Execution model, 10ExpandAllProtoypes, 53Field Changed, 40Fields, 9FinalConstruct, 40FinalRelease, 40FindSubBag, 53FindSubKey, 46FLEXlm licensing, 15ForceDemoMode, 45Generating eventOut, 25GetAbsPath, 54GetActiveCamera, 60GetActiveCameraPos, 60GetApplication, 46GetAtomFromString, 57GetBack, 44GetBag, 56GetBagID, 53GetBreakFlag, 59

GetCameraDistance, 41GetCameraPosition, 41GetCameraSQRDistance, 41GetCategory, 46GetChild, 56GetChildren, 56GetChildrenCount, 56GetCLSID, 46, 51, 52GetConfig, 45GetCount, 46GetDescription, 44GetDistributionRight, 51GetDocument, 45GetEventProcessing, 59GetExportedField, 53GetExportedFieldCount, 53GetExportedFieldIDByName,53GetExternalEventsNode, 60GetField, 47, 49GetFieldByName, 47, 49GetFieldCount, 48, 49GetFieldID, 50GetFieldInfo, 48, 49, 50GetFieldName, 51GetFieldOfView, 44GetFieldType, 51GetFileLoader, 57GetFront, 44GetGUID, 53GetHostID, 45GetHwnd, 60GetIcon, 51GetIconDLL, 46GetIconID, 46GetIcons, 52GetIconsDib, 53GetID, 56GetIdOfName, 49GetINode, 57GetInstanceCount, 53GetJoystickCapabilities, 55GetJoystickData, 55GetJoystickProperties, 55GetKey, 47GetLastInput, 50GetLicenseKey, 45GetLicenseOptions, 58GetLicenseStatus, 45GetLink, 57, 59GetLocalTransform, 44GetLogEvent, 58GetLongDescription, 53GetMFCount, 49, 51GetMFElement, 49, 51GetMFSpan, 49GetModuleCLSID, 46, 58GetMouse, 56GetName, 56

EON SDK 2.53.062

GetNewSimulation, 47GetNextModule, 45GetNodeCount, 57GetNodeInfo, 45GetNodeInfoCount, 45GetNodeName, 46GetNoIniTreeNodes, 44GetNoJoysticks, 55GetNoTreeNodes, 44GetOwner, 50GetParent, 56GetParentBag, 53GetParentID, 57GetParentNode, 49GetParentPtr, 57GetPath, 54GetPositionFirstModule, 45GetPropertyEditorCLSID, 40GetPrototype, 46GetPrototypeDefinition, 59GetPrototypeName, 52GetPrototypes, 47GetRefCount, 57GetReference, 54, 57GetReferenceCount, 54GetRefTarget, 57GetRegInt, 47GetRegString, 47GetRootNode, 46, 47GetRoutesAge, 57GetSearchPath, 59GetSelectedNode, 46GetSettings, 45GetSFBool, 49GetSFColor, 49GetSFFloat, 49GetSFImage, 49GetSFInt32, 49GetSFNode, 49GetSFRotation, 49GetSFString, 49GetSFTime, 49GetSFVec2f, 49GetSFVec3f, 49GetShortDescription, 53GetSIMDIR, 54GetSimFileName, 54, 55GetSimFileNameLenght, 54GetSimulation, 46GetSimulationInstance, 53GetSimulationRoot, 46GetSimulationState, 60GetSplitPaneReinitInfo, 51GetStandardKey, 47GetState, 61GetStatisticsOn, 44GetStringFromAtom, 57GetStringValue, 50, 51GetSubBag, 53GetSubPrototypes, 46GetToken, 45GetUserData, 53GetUserList, 45GetUserName, 45

GetValue, 50GetVariant, 50GetViewport, 44GetViewPosition, 45GetViewReinitInfo, 51GetVKey, 55GetVKeyPresses, 55GetWorldTransform, 44HandleActivate, 60HandleMove, 60HandlePaint, 60HandleResize, 60HasNonExportableExternalLinks, 52HideView, 45IAgent, 44IAgentFrame, 44IAgentFrame2, 44IAgentSimulation, 44IAgentViewport, 44IAutApp, 45IAutDoc, 46IAutNodeInfo, 46IAutPrototype, 46IAutPrototypes, 46IAutSettings, 46IAutSimulation, 47ICEonConfig, 47IChainSimulation, 47icon, 26IDegreeOfFreedom, 47IDeviceKeyboard, 47IEnumNodes, 47IEonDual, 47IEonEvent, 49IEonField, 49IEonField2, 50IEonField3, 50IEonFieldDual, 50IEonInsertable, 51IEonModule, 51IEonObject, 51IEonObject2, 52IEonPropertyEditor, 52IEonPrototype, 52IEonSingleton, 53IEonSingletonFactory, 53IExternalEvents, 53IExternalEventsNotifySink,54IExternalReference, 54IFileLoader, 54IFileLoader2, 54IFileLoader3, 54IGUIMotionModel, 55IJoystick, 55IJoystickState, 55IKeyboard, 55IKeyboardState, 55ILinkIterator, 55IMakePersistant, 55IMouse, 56IMouseState, 56

InactivateGUIMotionModel,60IncIniCounter, 44IncrementVisualAgeCounter,60InitClass, 40Initialize, 52INode, 56INodeBag, 56INodeBagAge, 57INodeBagFiles, 57INodeBagIterator, 58INodeBagIteratorFactory, 58INodeIterator, 58INodeLicense, 58InsertRef, 57Installation, 4Interfaces, 26InternalEventsProcessed, 49InternalGetField, 40IPCLogQueue, 58IPrototypeDefinitionHolder,59IReference, 59IRouteManager, 59IRouteManager2, 59IRunControl, 59IsClicked, 45IsDemoMode, 45IsDirty, 52ISettingsServer, 59ISettingsServer2, 60ISimulation, 60ISimulation2, 60ISimulation3, 60ISimulationEONXEvent, 60ISimulationExternalEvents,60ISimulationMotionModel, 60ISimulationRenderEvents, 60ISimulationRenderEvents2,61ISimulationRenderEvents3,61ISimulationStateEvents, 61ISimulationUpdateEvents, 61ISimulationWindowEvents, 61IsInitialized, 52IsLogTypeUsed, 59IsModuleLoaded, 45IsPersistentSave, 57IsRestartNeeded, 59IsRunning, 52IsSensor, 49IsVali

Date post:	15-Nov-2015
Category:	Documents
Upload:	sebastyan1314
View:	29 times
Download:	0 times

Eon Intro to Sdk

Documents