Thanks a lot for your answers.

About point #3, yeah, it’’s lot of fun. In fact it’’s rather easy because I write the XML to my taste and thus writing a XML “interpreter” for XSI is easy for most things. The only culpritt though is handling the case of trying to “map” the XML text to existing XSI objects.

Here are such a functions (Python):
(Note: I mentioned that I was using ElementTree, but that was because of a bug with BeautifulSoup, another Python XML parser. However that bug was corrected yesterday and thus I have reimplemented it in my code.)

def processSceneObject( oXSIObject, oXMLObject ):

“”"
ARGUMENTS:
- oXSIObject (object): an XSI 3D object
- oXMLObject (BeautifulSoup object): an XML ElementTree object that is a tag

…

“”"

# Parameters
transferParameters( oXSIObject, oXMLObject )

# ActivePrimitive
processActivePrimitive( oXSIObject, oXMLObject )

# LocalProperties
processProperties( oXSIObject, oXMLObject, ”localproperties” )

# Kinematics
processKinematics( oXSIObject, oXMLObject )

def processKinematics( oXSIObject, oXMLObject ):

“”"
ARGUMENTS:
- oXSIObject (object): the XSI object (must have a Kinematics object
- oXMLObject (BeautifulSoup object): the XML scene object that has a tag under

…

Note: We don”t transfer global kinematics, it’’s useless.
“”"

oXMLConstraints = oXMLObject.localproperties.constraints.fetch( ”constraint” )
oXMLLocalKine = oXMLObject.first( ”kinematicstate”, attrs = { ”name” : ”Local Transform” } )

oXSIConstraints = oXSIObject.Kinematics.Constraints
oXSILocalKine = oXSIObject.Kinematics.Local

# Constraints
for oXMLConstraint in oXMLConstraints:

oXSIConstraint = None

if oXSIConstraints.count :: No matching constraint could be established with %s.” % ( oXMLConstaint[ ''fullname'' ] ), c.siError )
else:
transferParameters( oXSIConstraint, oXMLConstraint )

# Local KinematicState
transferParameters( oXSILocalKine, oXMLLocalKine )

def transferParameters( oXSIInput, oXMLInput ):

“”"
ARGUMENTS:
- oXSIInput (XSI object): the XSI object that has parameters
- oXMLInput (BeautifulSoup object): the BeautifulSoup tag object under wich there is a tag

…

“”"

oXSIParameters = oXSIInput.parameters
oXMLParameters = oXMLInput.parameters.fetch( ”parameter” )

for oXMLParameter in oXMLParameters:

if oXMLParameter.contents[0] != ”None”:

# Get the XSI parameter object
oXSIParameter = oXSIParameters( oXMLParameter[ ''scriptname'' ] )

# Check if parameter has a source
if oXMLParameter[ ''sourceclassname'' ] != ”nosource”:
# Has a source

# Dispatch appropriate action to handle source
if oXMLParameter[ ''sourceclassname'' ] == ”FCurve”: transferFcurve( oXSIParameter, oXMLParameter )
elif oXMLParameter[ ''sourceclassname'' ] == ”Constraint”: pass
elif oXMLParameter[ ''sourceclassname'' ] == ”Expression”: transferExpression( oXSIParameter, oXMLParameter )
elif oXMLParameter[ ''sourceclassname'' ] == ”CustomOperator”: pass
elif oXMLParameter[ ''sourceclassname'' ] == ”Shader”: pass
elif oXMLParameter[ ''sourceclassname'' ] == ”ImageClip”: pass
else: xsi.logmessage( ” :: Unsupported type of source “%s”, parameter “%s” skipped.” % ( oXMLParameter[ ''sourceclassname'' ], oXSIParameter.scriptname ), c.siWarning )

else:
# No source
oXSIParameter.value = oXMLParameter.contents[0]

I will definitely check the XSL transformation stuff. All this is very new to me.

Thanks again
Bernard

Thanks for the feedback, I”m glad you found the article useful. To address your questions:

1) You said that I talked of two methods for exporting XML. I only intended one; that of outputting some form of XML that represented the basic data contained within the scene. I”d favour a scene format that would represent the data in its purest form to preserve scalability. I”d worry that if you try to add any structure or data that is specific to a particular application or usage, then it”ll just get in the way later on when you need to use the same XML data in a different way to that originally intended.

The application specific part comes in the form of the XSL transform. Different XSL transforms can do completely different things with the same XML data. I”d recommend letting the XSL document do the work for you, it’’s much more flexible and is much easier to alter later. Plus, you can store the XSL document as it’’s own asset, which neatly separates its functionality from any other pipeline scripts.

2) I use a script class to generate my XML, it handles things like indents nicely (to make it a little more easy to read) and also provides functionality for me to come back to insert nodes later on. The script class basically wraps the MSXML DOMDocument object. I”ve pasted it in below in case you”re interested:

Class XMLDocument

Public Sub Create(rootNodeName)
Set xmlDoc = CreateObject("Msxml2.DOMDocument.4.0")
xmlDoc.LoadXML("<?xml version="&Chr(34)&"1.0"&Chr(34)&" encoding="&Chr(34)&"utf-8"&Chr(34)&" ?>"&vbCrLf&"<"&rootNodeName&"/>")
xmlDoc.preserveWhiteSpace=True
Set xmlRoot = xmlDoc.documentElement
indentLevel=1
End Sub

Public Function AddElement(parentNode, elementName, elementContent)
If(typename(parentNode)<>"IXMLDOMElement") Then Set parentNode=xmlRoot

”Formatting
parentNode.appendChild xmlDoc.CreateTextNode(vbCrLf & String(indentLevel,Chr(9)))

Dim newNode
Set newNode = xmlDoc.CreateElement(elementName)
if(elementContent<>"") Then newNode.Text = elementContent
parentNode.appendChild newNode

Set lastElementParent=parentNode
Set AddElement=newNode
End Function

Public Sub AddAttribute(node, attributeName, attributeValue)
Dim att, namedNodeMap
Set att = xmlDoc.CreateAttribute(attributeName)
Set namedNodeMap = node.Attributes
namedNodeMap.setNamedItem att
node.setAttribute attributeName, attributeValue
End Sub

Public Sub StartInsertAt(parentNode, levelToindent)
indentLevel=levelToindent
Set lastElementParent=parentNode
End Sub

Public Property Get IndentSpacing()
IndentSpacing = indentLevel
End Property

Public Function Indent()
indentLevel=indentLevel+1
Indent=indentLevel
End Function

Public Function Outdent()
indentLevel=indentLevel-1
If not (lastElementParent Is nothing) Then
lastElementParent.appendChild xmlDoc.CreateTextNode(vbCrLf & String(indentLevel,Chr(9)))
Set lastElementParent=lastElementParent.parentNode
End If
Outdent=indentLevel
End Function

Public Function Save(filename)
”Add carriage return for closing node
If(xmlRoot.lastChild.nodeTypeString<>"text") Then
xmlRoot.appendChild xmlDoc.CreateTextNode(vbCrLf)
End If
Save = xmlDoc.Save(filename)
End Function

Private xmlDoc
Private xmlRoot
Private indentLevel
Private lastElementParent

End Class

I use it like this:

Function Export_Animation(xmlDoc, parentNode, exportData)
Dim animNode
Set animNode = xmlDoc.AddElement(parentNode,"animation","")
xmlDoc.AddAttribute animNode,"version",exportData.version

xmlDoc.Indent

xmlDoc.AddElement animNode,"name",exportData.animName
xmlDoc.AddElement animNode,"numframes",1+exportData.endFrame-exportData.startFrame
xmlDoc.AddElement animNode,"fps",exportData.fps

exportData.success=Export_Skeleton(xmlDoc, animNode, exportData)

xmlDoc.Outdent

Export_Animation=exportData.success
End Function

Your example of a 50Mb file is quite large for XML, but I think that the flexibility that it offers, far outweighs the disadvantage of processing such a large file. XML usually compresses pretty well, so that can help, although that does add processing time.

Another strategy would be to split the XML up into numerous smaller XML files, and simply link between them. For example, you could use a node like this:

<include filename="c:\scenedata\robotmodel.xml" />.

When your script loads the XML document, it can search for any <include> nodes and where desired, it can replace the <include> node with the tree fragment from the relevant file. This means that you can then run the XSL transform on smaller trees that only contain the appropriate information. Managing the extra files and all the different versions of them could be a headache though.

Incidentally, most popular databases are adding good support for XML now. For example, SQL can return query data as pure XML, formatted in a variety of different ways. So maybe another alternative would be to push all your data into a database and then generate your XML on the fly with queries.

3) I”ve not tackled that problem. I”ve been mainly using XML to export animation data. I”ve read it back in to a Custom Display Host, but I”ve not needed to apply it directly to a rig in the scene. What you”re doing sounds like fun though ;-)

Regards

Andy

Very interesting article, especially considering that this is exactly what I”m doing right now. I”m doing this with Python, wich also happens to have an ElementTree package, that provides simple and nice XML parsing capabilities.

I have a few questions…

1- You have presented two ways of exporting XSI data to XML, one being like tree-based scene file, the other being writing programming objects with attributes that can be used to set or reconstruct XSI objects. What are the pros and cons of both approach?

2- You didn”t talk much about the actual process of outputting the XML. I”d be very interested in knowing how other do that, and why.

For the tools I”m working on, the user can select any object in the scene (including objects “above” or “next to” the scene root in the Application scope, like a material library, or the list of action sources, etc), and it will export it as well as everything that is below. To accomplish this, I have wrote a myriad of functions that deal specifically with most of these objects in their own way, and there is this central dispatcher that can determine wich object is being tested and call the appropriate function to handle it. Obviously this resulted in a huge amount of code (around 1700 lines as of this writing), and an important part of this amount is dedicated to handling “cases” (for examples, the local kinematics shorts under an X3DObject).
Also it runs fast on a small amount of objects, but if you export a single action source that is the result of a plot of an entire character over 100 frames, then it takes 10 minutes and results in a 50 Mb file.

So I”m interested in where is exporting XML relevant and not, and how do people takle the task of writing the XML.

3- Now about the import/interpretation/analysis. Once you have parsed the XML data, how do you translate its content to XSI? For instance, let say you wrote out a camera with all its parameters and animation to an XML file. Getting a parser to parse the file is easy, but then how would you deal with the XML camera and get it to XSI?

The approach I have been taking so far is, as I did with the export of XML, have functions for each specific XML object or so. So for example, I have a camera importer that looks for a camera object in the XML tree. If finds one, now let’’s check if this camera exists in the XSI scene. If not, create it, if so, go directly to transfer parameter. Oh, I see the XSI camera no longer has its direction constraint, but the XML one does. So add a constraint, and set it like in the XML camera….. and so on and so on. This will also lead to huge amounts of code and the need for many many functions.

Once again I”m interested in how you people tackle the task of applying the XML information to XSI.

Thanks and great article!
Bernard