Master Model Format Specification

Overview

The Master Model format is used to convey a rich set of information about the 3D representation of a physical object. In addition to traditional scene graph content (materials, object hierarchy, tesselated meshes, and lights), the Master Model includes data about the way the product behaves, metadata such as authors or copyrights, and binary texture and geometry files. At the outermost level, the Master Model format is identical to ZIP/JAR archive format, except that it uses the .XMM file extension. The key file in the XMM archive is a file called MASTER.XML. The schema of this XML file is the primary content of this specification document.

With the exception of textures, which must be included in the XMM using a standard format (JPEG, PNG, GIF), the entire content of a model can be written into the XML format file. However, for efficiency and accuracy, the vertex and texture coordinates, and the triangle topology, can be written in a simple binary format. Thus, a typical XMM file is a ZIP containing MASTER.XML, several .PNG and .JPG texture files, and many .BIN files with mesh information.

Master Model XML

This section fully specifies the content of the MASTER.XML file in the Master Model. It starts with stylistic conventions and guiding principles for the creation of XMM files, and a simple example to convey general structure. Each element is then documented, in depth-first order, to make this specification readable in a top-to-bottom manner. Extensive cross references appear within each element section, to facilitate browsing the specification in any order.

Style Guide

When writing an exporter to the XMM format, it may be impossible to enforce some of these stylistic rules. However, every effort should be taken to meet these requirements where possible, and exporter documentation should encourage the user to follow these guidlines where possible.

The Master Model format is, first and foremost, an interchange format. The goal of this format is to allow complete, lossless, exchange of all the product information represented in a CAD, industrial design, or other 3D modeling environment, which is useful for the range of applications relevant to users outside the engineering department. In support of this, extensible standards have been used, and the inclusion of "out-of-spec" information is encouraged. It is perfectly valid to include extra files in an XMM archive, or to add more elements to the MASTER.XML file. As the range of applications supported by this format grows, some of these may be added to the specification, or even required in future XMM format verisons.

There is no size limitation in the XMM format, except the underlying ZIP size limitation of 2GB. Since the ZIP format supports using LZ compression on each archived file, and because the XML, texture image, and floating point data tends to compress very well, this limit is unlikely to be breached any time soon. If it is eventually exceeded, support for 64-bit file lengths using ZIP extensions will be added to this format.

In some key sections of the specification, multiple ways of conveying the same data are supported. For example, meshes can be written directly in the XML, or they can be conveyed in binary files. Both mechanisms are equally valid, and the export-writer is encouraged to use whichever is more natural in the given export application. In general, writing mesh data into the XML will be slower for both export and import, and the resulting files will not compress quite as well as if the data had been written into binary files. Also, the conversion of 32-bit floating point data into decimal ASCII, and back into floating point, is often error inducing, so the most precise results will be achieved with binary transfers. However, these points are minor, and the simplicity of including mesh data in the XML generally wins out.

One of the possible applications of an XMM model is to deliver it in an interactive web version. This requires compressing the model, so the XMM format includes several elements which guide and control this compression. It is not necessary to include these optimization-related elements in most XMM files. They can be added in subsequent steps when a web application is clearly defined. They are included in this specification for completeness only.

The goal of the XMM format is to make 3D data useable to non-experts, and reusable across a wide range of visualization and other applications. This leads to a novel requirement - that elements have sensible descriptions. Very few 3D model formats even support the inclusion of plain language descriptions, much less require it, and many 3D modeling tools are very weak in their ability to include this information. However, for a non-expert to get maximum value from a 3D model, seeing parts with names like "NURB-01" moving through a range-of-motion called "ANIM5" between waypoints "0" and "1" is next to useless. Rather, they need to see that "LCD Panel" is using a range-of-motion called "LCD Panel" between waypoints "Close" and "Open". The following guidelines support this goal:

  • desc attributes should contain plain-language descriptions, and should be written in title case: "Battery Compartment", "LCD Panel", "Memory Door", etc. Underscore characters, obscure abbreviations, and 3D modeling jargon should not be used in desc elements.
  • In contrast, id elements are guaranteed to never be shown to an end user, and thus may use any approach to ensure uniqueness within the model. Note that IDs may use any characters (none of the common rules like starting with a letter, or excluding spaces, apply).
  • When only one animation sequence applies to an object, it should be given the same name as the object. For example, if an LCD Panel opens and closes, then its animation sequence should have desc="LCD Panel", not the unnecessarily verbose desc="Open LCD Panel".
  • Objects which are too minor to be relevant to users should be marked private='true'. These objects will never be shown to the user, but rather are treated as part of their parent object. In particular, private objects cannot be rendered differently by the end users: they fade with their parent, and if illustration mode is being used, they get all illustration properties from their parent. Thus, it is important to balance the need to give end users enough freedom in the hierarchy, without overwhelming them with unnecessary details.
  • Every public object should have a Fade sequence. By convention, fade sequences have two waypoints: "Show" and "Hide". Only objects which make sense alone should be top-level fades. For example, the Keyboard and LCD sections of a laptop computer should fade together, not separately. However, a removable battery should fade independently.
  • Waypoints in animation sequences should have short, clear names. Common waypoint names include: Open Close In Out On Off Show Hide Normal Reversed Extended Insert Remove
  • When there are multiple similar parts, functional adjectives are better than positional adjectives ("Toner Access Panel" is better than "Top Panel"), and positional adjectives are preferable to cardinal ones ("Top Panel" is better than "Panel 3").
  • Sequences should be given in a natural order. Often, grouping the sequences based on the positions of the parts they manipulate is a good approach.
  • When including standard views such as "Front", "Left", etc., use "audience" rather than "object" perspective. In particular, the "Left" view should show the left side of the object, as viewed from the front. If the object modeled is a person, the "Left" view puts the person's right arm closest to the viewer.
  • There must be an initialization script, and it must set the state of every sequence.
  • When a script manipulates the camera, the first camera view should be placed at time=0, and should start from the view which will show the animation, not from a standard view like "init". Starting scripts from a common starting view leads to many unnecessary camera moves, which the end-user will have to delete.

Simple Example

The following example of a green rectangle demonstrates the overall structure of a MASTER.XML file.

<?xml version='1.0' encoding='UTF-8'?>
<master xmlns='http://strata.com/master/1.0/'>

  <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
           xmlns:dc='http://purl.org/dc/elements/1.1/'>
    <rdf:Description >
      <dc:title>Green Rectangle</dc:title>
      <dc:date>2004-04-22T16:45+04:00</dc:date>
    </rdf:Description>

  </rdf:RDF>
  <materials>
    <material id='mat1' color='00ff00' backface='true' />
  </materials>
  <objects>
    <object id='RECT1' desc='Rectangle'>

      <mesh>
        <verts>
          <v x='-0.5' y='0.0' z='-0.5' />
          <v x='0.5' y='0.0' z='0.5' />
          <v x='0.5' y='0.0' z='-0.5' />
          <v x='-0.5' y='0.0' z='0.5' />

        </verts>
        <faces>
          <group material='mat1'>
            <f v1='0' v2='1' v3='2' />
            <f v1='0' v2='3' v3='1' />
          </group>

        </faces>
      </mesh>
    </object>
  </objects>
  <views>
    <view id='init' desc='Initial' phi='-15'/>

  </views>
  <scripts init='init'>
    <script id='init' desc='Initial'>
      <at t='0' view='init'/>
    </script>
  </scripts>

</master>

The first line of the file is a standard XML declaration. Note that for character codes less than 128, UTF-8 is identical to ASCII. As with any XML file, strings can be quoted with either ' or ". Also note that certain characters, such as <, >, and & must be written using a special syntax. A good tutorial on the XML format can be found at http://www.w3schools.com/xml/xml_syntax.asp.

The next line opens the root element master in its namespace. This will be the default namespace for all remaining elements in the file. The remaining elements in the file can appear in any order, but by convention metadata is given first.

The metadata appears in standard RDF format. In this example, just a title and date are given. Other metadata which is typically included are creator (name of the person or company who authored the content), rights (copyright and license information), source (name of the original 3D data model file), and description (descriptive text about the product represented). Any elements may be used here, including ones that were invented specifically for this purpose. However, to ensure that other applications which support RDF metadata (such as all Adobe products) can understand the elements used, it is best to stick with established vocabularies of elements, such as the Dublin Core.

Just one material is used in this example. It is an unlit, solid saturated green, with backfaces turned on. In the Master Model format, triangular meshes ordinarily are one-sided, and only those faces which are oriented toward the camera are shown. This can be overridden for any material, as is done here. Note that if a model appears "inside out," the solution is generally to correct the winding order of triangles, not to just turn on backfacing.

A single object is used in this example. It is given both an id, for internal cross-referencing within the model, and a description for presentation to users of the tools which will exploit this model. It is imperative that all desc attributes in a Master Model are clear text names, not obscure modeling artifacts. These names are shown to users who do not necessarily understand 3D modeling techniques, nor are they familiar with the way the model was assembled. Where possible, the names used should correspond to the physical object represented, not the modelilng tecnique used ("LCD Panel" is good, "NURB-01" is not). This object has a mesh of triangles, which is given as a vertex table, and a set of faces (triangles) which connect those vertices together. The faces are grouped by material. The coordinate system used is left-handed Y-up, as described in the objects element.

One camera view is defined, and one script is included which sets the camera to this view. Note that in this example, the ID init is used for multiple classes of elements (a view and a script). This is fine. IDs must be unique only within the scope needed to differentiate things. For example, all objects must have relatively unique IDs, but waypoints within a sequence only need to have unique IDs relative to other waypoints in that sequence.

Master Model Element

Element: master

This is the root element in the XML file. It contains all the other elements. It should establish the global namespace, using the form <master xmlns="http://strata.com/master/1.0/"> .

 RDF
Metadata about the master.
CountZero or One
 files
Ancillary data files, in base 64 format.
CountZero or One
 materials
A list of material definitions used by meshes in this master.
CountZero or One
 objects
The scene graph.
CountZero or One
 views
Named camera configurations.
CountZero or One
 sequences
Parameterized state change definitions for objects in the scene graph and materials.
CountZero or One
 scripts
Time-based animations which control one or more sequences, and optionally the camera.
CountZero or One
 triggers
3D locations on the object which may be used in interactive applications to trigger behaviors or highlight parts.
CountZero or One
 bookmarks
Named scene configurations.
CountZero or One
 images
Image compression information used in the creation of web-resolution models.
CountZero or One

Metadata Elements

Element: RDF

Appears in:  master

Metadata about this model is described in the standard RDF syntax. A good summary appears here: http://www.w3.org/TR/rdf-primer/. The Dublin Core standard is typically used for the element definitions: http://dublincore.org/documents/dcmi-terms/. The following example shows a simple RDF element as it might appear in a Master Model.

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:dc="http://purl.org/dc/elements/1.1/">
  <rdf:Description>
    <dc:title>Widget A-331</dc:title>
    <dc:date>2004-04-06T13:11+04:00</dc:date>

  </rdf:Description>
</rdf:RDF> 

While the use of Dublin Core is encouraged, it is not mandatory. Any valid RDF element may appear in the master model.

Embedded Files

Ordinarily, the Master XML file appears within an XMM archive. This archive would contain all the ancillary files, such as texture images, which are referenced by the Master Model. However, when writing an exporter, it is often convenient to write all data, including ancillary files, directly in the XML. This is done using the files and file elements.

Element: files

Appears in:  master

This element is a container for file elements. Note that this must appear in the XML file prior to any references to these files.

 file
All embedded files.
CountZero or More

Element: file

Appears in:  files

This describes a single ancillary file to include with the master. The content of this file must be base-64 encoded, as explained in IETF RFC 1521, section 5.2.

<file name="dot.gif">
R0lGODlhCAAIAKIAAP///wAAACoqKn9/f+Xl5QAAAAAAAAAAACH5BAAAAAAALAAAAAAIAAgA
AAMXCLpLI2IQNYINQ4kbhOYeUF0Z4EASoyYAOw==

</file> 
 name
Name of the file. Note that this should not include any path information.
Typestring
RestrictionsRequired

Material Elements

Materials convey surface properties. They always use either a solid color, or a texture. Beyond that, they include lighting and other apperance control mechanisms. Every material used in the scene graph is listed in the materials element, and referenced by ID from within the scene graph. In cases where a material needs to change appearance (for example, to represent a phone available in a variety of colors), the material element includes a set of alternative material elements (different appearances for the material) which can be swapped in by sequences.

Element: materials

Appears in:  master

 material
All top-level materials referenced by meshes in the scene hierarchy.
CountZero or More

Element: material

Appears in:  materials  material

 id
Unique identifier which meshes in the scene graph use to reference this material.
TypeID
RestrictionsRequired
 color
Hex color value as used on the web, but omitting the traditional # character. For example, red is ff0000, green is 00ff00, and blue is 0000ff. This is ignored if the image attribute is used.
Typestring
 image
Name of the image file to use as texture. This image file must be included in the XMM archive, and use exactly the same text case as the filename which appears there. Currently JPEG, GIF, and PNG formats are supported.
Typestring
 backface
Indicates whether back-facing triangles which use this material should be rendered.
Typeboolean
Defaultfalse
 wrap-u
Indicates whether texture U coorindates outside the range of 0 to 1 should wrap around (true) or clamp to the 0 to 1 range (false).
Typeboolean
Defaulttrue
 wrap-v
Indicates whether texture V coorindates outside the range of 0 to 1 should wrap around (true) or clamp to the 0 to 1 range (false).
Typeboolean
Defaulttrue
 composite
Manner in which the colors of the materials should be blended with the background. The default mode of "=" writes over the background (possibly with an alpha blend, if there is an alpha element, or an alpha channel in the texture image). Additive blend "+" adds this material color to the underlying color, as would be used for fire or lens-flare effects. Multiplicative blend "*" multiplies this material color with the underlying color, as would be used for shadow effects.
Typeenum =, *, +
Default"="
 light
With a lighting value of none, the color or texture is reproduced exactly. With a value of phong, the brightness of the color and texture is reduced based on contributions from the ambient and directional lights, and if the specular level is non-zero, a specular whiteness is folded in as well.
Typeenum 
none, phong
Default"none"
 ambient
The global ambient light level is multiplied by this value to compute the color/texture baseline brightness value.
Typefloat
Default1
 diffuse
Direct light levels are multiplied by this value to compute their contribution to the color/texture brightness value.
Typefloat
Default1
 specular
Specular highlights are multiplied by this value to compute their contribution to the whiteness of the material.
Typefloat
Default0
 glossiness
Sharpness of specular highlights. A value of 0 is completely diffuse, a value of 1 produces a point so sharp it cannot be seen. Shiny objects typically use values in the range 0.7 to 0.995.
Typefloat
Default0
 chrome
Strength of the chrome simulation effect. Chrome is simulated with a low-specular-power negative light. Note that this effect adds too the specular level, so the specular level will need to be increased to compensate.
Typefloat
Default0
 alpha
Apply an overall transparency to faces using this material. Note that per-texel alpha is supported when using a 32 bit alpha-bearing PNG texture image, or a GIF with transparency.
CountZero or One
 curve
Apply this color curve to texture values prior to rendering.
CountZero or One
 material
Alternate material definitions which can be swapped in place of this top-level material. Note that only sub-materials may be swapped, and deep nesting of materials is not allowed. That is, only a top-level material element may contain other material elements.
CountZero or More
 swap-material
Indicates a child material which should be used as the initial version of this material.
CountZero or One

Element: curve

Appears in:  material  filter-material

Defines a set of curves to be applied in the red, green, and blue color channels.

 curve-channel
Curves to apply to one or more color channels.
CountOne or More

Element: curve-channel

Appears in:  curve

 apply-to-red
Whether to run the red channel through this curve.
Typeboolean
Defaultfalse
 apply-to-green
Whether to run the green channel through this curve.
Typeboolean
Defaultfalse
 apply-to-blue
Whether to run the blue channel through this curve.
Typeboolean
Defaultfalse
 point
Collection of curve control points. These control points are just like the points in a Photoshop color curve editing control. The X coordinate of the point is the input intensity (range 0 to 255) and the Y coordinate is the output intensity (range 0 to 255).
CountZero or More

Scene Graph Elements

Element: objects

Appears in:  master

This is the root of the scene graph. In addition to some global parameters relevant to web compression, this contains all the top-level objects. Note that the root of the scene graph (this object) does not have a local transform, so if the scene being exported to the XMM format has a transform at the scene root level, that root should be placed into a single element which is a child of this element. (Technically a local transform can be set, but this capability is reserved for the end user of the model to manipulate through scripts, so it is not allowed in the static scene graph definition given in this file.)

The coordinate system used in the Master Model format is a typical graphics coordinate system. X goes to the right, Y goes up, and Z goes forward. It is therefore left-handed. All triangles should be wound left-handed as well. The following table shows the relationship between the Master Model coordinate system and some other common systems:

SystemMaster XMaster YMaster ZTriangle Winding
VRMLxy-zReverse
PLYxy-zReverse
STLxzyReverse
OBJx-z-yReverse
3DSxzyReverse
Direct3DxyzUnchanged
 millimeter
Translation from native modeling units to millimeters. The default of 25.4 is appropriate for models which are in inches.
Typefloat
Default25.4
 uv-quant
When compressing this model for use in Web applications, the number of bits of precision (quantization) to use for texture coordinates.
Typeint
Default11
 weld-thresh
When compressing this model for use in Web applications, the positional difference to consider insignificant (vertices which are this close together in 3D may become a single vertex).
Typefloat
Default0.0005
 xyz-quant
When compressing this model for use in Web applications, the number of bits of precision (quantization) to use for positional coordinates.
Typeint
Default11
 ambient-light
Ambient lights in the scene.
CountZero or More
 directional-light
Directional lights in the scene.
CountZero or More
 object
Object hierarchies which make up the scene.
CountZero or More

Element: ambient-light

Appears in:  objects  at

Ambient lights contributed a uniform brightness level to all lit materials.

 id
Lights only need identifiers if they are going to be animated during scripts. If none is provided, one will be generated automatically by the consumer of the XMM format data.
TypeID
Defaultauto-generated
 intensity
Intensity of light is ordinarily in the range 0 (completely off) to 1 (completely on). However, negative values are also supported (so-called "dark lights") and values in excess of 1 (oversaturating lights).
Typefloat
Default0

Element: directional-light

Appears in:  objects  at

Directional lights contribute both diffuse brightness to materials, based on a standard incident cosine rule, and specular highlights, based on a Blinn-style half-angle reflection rule. Directional lights only illuminate surface normals which are in the opposite direction (that is, those which have a negative dot product). Note that a Phong (that is, normal interpolation) shader is used which supports normals that face toward a light even when the face normal faces away from the light. The direction of the light is expressed with a vector which faces in the same direction as the light. This vector need not be a unit vector - its length is not used. If a zero-length vector is given, a straight down (y=-1) vector is used.

 id
Lights only need identifiers if they are going to be animated during scripts. If none is provided, one will be generated automatically by the consumer of the XMM format data.
TypeID
Defaultauto-generated
 intensity
Intensity of light is ordinarily in the range 0 (completely off) to 1 (completely on). However, negative values are also supported (so-called "dark lights") and values in excess of 1 (oversaturating lights).
Typefloat
Default0
 x
X component of the light direction vector.
Typefloat
Default0
 y
Y component of the light direction vector.
Typefloat
Default0
 z
Z component of the light direction vector.
Typefloat
Default0

Element: object

Appears in:  objects  object  lod

Each object in the scene graph can contain up to one mesh of faces (triangles), and an arbitrary number of child objects. When using level-of-detail, the mesh must be omitted, and an lod element is used in its place. That is, an object may contain a mesh (or an elliptical-hermite-loft), or a lod, or neither, but never both.

 id
Unique identifier for this object, referenced by sequences which act on this object.
TypeID
Defaultauto-generated
 desc
User-facing description of the object. Keep in mind that the user of a Master Model is typically not a 3D expert, nor are they necessarily familiar with the object hierarchy of the original object. Therefore, it is critical that all object descriptions are clear, textual descriptions of what the object is. For example, "LCD Panel" is a good description, while "NURB-01" is not.
Typestring
RestrictionsRequired
 private
A private object is one that is present only as a modeling artifact, not for any user-significant reason. While private objects may be animated, they do not have their own alpha property - they get transparency from their closest public ancestor.
Typeboolean
Defaultfalse
 concealed
Indicates that the object is ordinarily hidden by other objects, and should only be included in compressed models when sequences indicate that it will become visible.
Typeboolean
Defaultfalse
 billboard
If specified, indicates that the object should use spherical billboard rules, meaning always face the camera in all 3 degrees of freedom.
Typeenum sphere
 alpha
Transparency of the mesh of this object, and of any private child objects. Note that unlike transforms, alpha does not propagate through the scene graph. Every public object has an independent alpha level. When it is important for various objects to fade as though they were a single object, a compound sequence can be used.
CountZero or One
 lod
Level-of-detail representation of the mesh of this object.
CountZero or One
 mesh
Direct triangular representation of the mesh of this object.
CountZero or One
 elliptical-hermite-loft
Instructions for algorithmically generating the mesh of this object.
CountZero or One
 object
Objects which are attached to this object in the scene graph (sub-hierarchies of objects).
CountZero or More
 orientation
Parent-relative orientation of the mesh of this object, and parent coordinate orientation for children of this object.
CountZero or One
 position
Parent-relative position of the mesh of this object, and parent coordinate position for children of this object.
CountZero or One
 pivot
Local-coordinate pivot point (center of rotation). Note that after transformation, the local coordinate 0,0,0 will be at the given position if no pivot is given, or if no orientation is given, but not if both are given.
CountZero or One

Element: lod

Appears in:  object

Level of Detail elements allow the same physical item to be represented at a variety of resolutions. The lowest levels of details are always represented with meshes. When necessary, the highest level of detail can be represented by an object heirarchy. The objects at the highest level of detail can be animated by sequences, and web-optimization software will choose detail level based upon which animations are used and other criteria such as polygon budget. For example, a circuit board could be modeled as:

  • A rectangle with a photograph mapped on it
  • A detailed mesh with many textures
  • A full hierarchy of textured objects with chips that can be removed from their sockets, etc.

 mesh
Various explicit representations of the geometry of this object.
CountZero or More
 elliptical-hermite-loft
Various algorithmic representations of the geometry of this object.
CountZero or More
 object
An optional object hierarchy representing this same object. This object would contain a mesh for the base geometry, but then would include children which represent other parts of this same object.
CountZero or One

Element: mesh

Appears in:  object  lod

Triangulated mesh of (optionally textured) geometry. The location and mapping coordinates, and face topology, can be placed directly in this XML file using v, m, f, and mf elements. Or they can be encoded as binary files which appear in the XMM.

 verts
Table of vertex 3D coordinates.
CountOne or More
 maps
Table of texture mapping coordinates.
CountZero or One
 faces
Face topology and material mapping.
CountOne or More

Element: verts

Appears in:  mesh

This element holds the vertex table used by this mesh. The vertex data can appear as a list of child v elements, or a source file containing binary data can be referenced. When using a file, put the src file in the XMM archive, and store the vertex data in big-endian IEEE single-precision floating point format: x0, y0, z0, x1, y1, z1, etc. Note that identical meshes may reference the same file.

 src
Name of the file holding a binary vertex table.
Typestring
 v
Directly specified vertex locations.
CountZero or More

Element: v

Appears in:  verts

One vertex in the vertex table.

 x
X coordinate.
Typefloat
Default0
 y
Y coordinate.
Typefloat
Default0
 z
Z coordinate.
Typefloat
Default0

Element: maps

Appears in:  mesh

For textured meshes, this element holds the UV mapping coordinates table used by this mesh. The mapping data can appear as a list of child m elements, or a source file can be referenced. When using a file, put the src file in the XMM archive, and store the vertex data in big-endian IEEE single-precision floating point format: u0, v0, u1, v1, etc. Note that identical meshes may reference the same file.

 src
Name of the file holding a binary mapping coordinate table.
Typestring
 m
Directly specified mapping coordinates.
CountZero or More

Element: m

Appears in:  maps

 u
U mapping coordinate.
Typefloat
Default0
 v
V mapping coordinate.
Typefloat
Default0

Element: faces

Appears in:  mesh

This element holds the topology information about the triangles. The topology data can appear inside the groups directly using f and optionally fm elements, or a source file can be referenced. When using a file, put the src file in the XMM archive, and store the data in big-endian 4-byte integer format. A variety of cases are supported, and these are distinguished by the ord attribute. In the simplest case (ord=3), three vertex index values are written for each triangle. These index values will be used for both the vertex coordinates and the mapping coordinates of those vertices (if the material has a texture, and therefore mapping coordinates are needed). That is, when ord=3, the verts and maps tables are exactly parallel to one another. In this case, smoothing group information comes from the group elements. To specify smoothing group information at the triangle level, include 4 numbers for each triangle (ord=4): v1, v2, v3, smoothing. When the texture coordinate table does not parallel the vertex coordinate table, separate index values can be given for each triangle. Either without smoothing group per triangle (ord=6): v1, v2, v3, m1, m2, m3; or with smoothing group per triangle (ord=7) v1, v2, v3, m1, m2, m3, smoothing. In general there will be (4 bytes) x (ord) x (number of triangles) bytes in the file.

 src
Name of the file holding binary toplogy information.
Typestring
 ord
Number of 4-byte data items in the file, per triangle.
Typeint
Default7
 group
Groups of triangles which use the same material.
CountZero or More

Element: group

Appears in:  faces

Each face is associated with three kinds of data: material properties, smoothing groups (for normal generation), and topology (connectivity). A group element enumerates a set of faces which share the same material property. It can, optionally, also give the smoothing groups for this set of faces. In the case where faces are listed in the XML file directly, they appear as a set of f elements within the group. When the face topology comes from a file, the group only controls the manner in which the file is read. Each group element, in order, gives the material attribute to use for some number of triangles in the file, as specified by the count attribute. In either case, the smoothing group code s is only a default for when the smoothing groups are not given for each triangle directly.

Smoothing groups are encoded using a 32 bit number. The high order 8 bits define 256 different collections of smoothing groups. Faces with different values in their top 8 bits are treated as completely separate objects during normal generation. The low order 24 bits are treated as a mask. Any two faces with a bit in common in this mask will share their normal, resulting in smooth shading across their boundary. The special smoothing group 0 is used to indicate that a faceted appearance is desired, and can also be used when normals are irrelevant because the material mapped to the surface uses light='none'. Note that smoothing groups are applied at the mesh level - two separate meshes will never share normals.

 count
Number of faces (triangles) in this group.
Typeint
Default0
 material
ID of the material to use for this group. This must be a top-level material within the materials element.
TypeID
RestrictionsRequired
 s
Smoothing group code to use for this group.
Typeint
Default1
 f
List of face elements, when faces are given directly in the XML. This should not be used if the enclosing faces element has a src attribute.
CountZero or More

Element: f

Appears in:  group

A single face is described by the f element. The three vertex indexes (v1,v2,v3) are indexes into the vertex table of the mesh. These should be given in a left-hand winding order. The three mapping indexes (m1,m2,m3) are indexes into the mapping table of the mesh. The texture mapping coordinates to use can be omitted, which means they are assumed to be identical to the vertex index values (that is, the vertex and mapping coordinate tables are parallel to one another), or they can be given explicitly. Support is included for having multiple mapping coordinates per face, although there is not yet support for multiple materials per face, so this is strictly for future use.

 v1
Index into the mesh vertex table.
Typeint
Default0
 v2
Index into the mesh vertex table.
Typeint
Default0
 v3
Index into the mesh vertex table.
Typeint
Default0
 m1
Index into the mesh mapping table.
Typeint
Defaultsame as v1
 m2
Index into the mesh mapping table.
Typeint
Defaultsame as v2
 m3
Index into the mesh mapping table.
Typeint
Defaultsame as v3
 s
Smoothing group of this face.
Typeint
Defaults attribute of group
 fm
Mapping coordinate indexes for this face. If this is used, the m1,m2,m3 attributes of this f element provide the mapping coordinates for the dominant (diffuse) material.
CountZero or More

Element: fm

Appears in:  f

This element is used within a face f element to provide additional mapping coordinates for textures other than the diffuse texture.

 m1
Index into the mesh mapping table.
Typeint
Defaultm1 attribute of f
 m2
Index into the mesh mapping table.
Typeint
Defaultm2 attribute of f
 m3
Index into the mesh mapping table.
Typeint
Defaultm3 attribute of f

Element: elliptical-hermite-loft

Appears in:  object  lod

The Master Model format does not support arbitrary mesh vertex animation. However, in models of physical products, it is often necessary to include flexible cables, straps, and the like. The Elliptical Hermite Loft (EHL) is a generic mesh primitive which can represent a wide variety of these shapes. As the name implies, it is an ellipse lofted along a Hermite curve segment. It is generated at run time, based on its parameters, and can be used to simulate a wide variety of dynamic mesh elements. The EHL is mapped with a single material. If this material is a texture, the mapping coordinates are computed automatically. The U mapping coordinate wraps around the ellipse. The V mapping coordinate can be set to run along the length of the curve parametrically (for example, v=0 at the start of the curve, and v=1 at the end), or using distance (for example, v=0 at the start of the curve, v=curveLength, at the end). Or it can be any combination of these. Note that when distance-based mapping coordinates are used, the final coordinate is rounded to the nearest integer, to ensure multiple curves can be connected seamlessly.

The ellipse is specified by a radius, and a flattening (eccentricity) parameter. Flattening happens in the Y coordinate of the ellipse.

The Hermite curve starts at the origin (0,0,0) of the object which parents the curve, using the transform of this object. It ends at another object, which is specified by the target attribute, with the orientation of the target object. This object can be anywhere else in the scene graph. The exact shape of the curve is also influenced by the two weight parameters, which control how strongly the starting and ending orientations influence the curve. These units of these weights are basically the same as the world coordinate system. See the section on Hermite Curves in Computer Graphics, Foley, van Dam, et. al., for an exact treatment.

The number of faces in the mesh is controlled by the two parameters segments-around and segments-long. These can be set to any number, to control the smoothness of the shape. In practice not many segments are required in the ellipse, because Phong shading makes a relatively coarse mesh look extremely round. The number of segments required in length will vary strongly with the radius of curvature, and amount of flexing which occurs in the scene.

 material
ID of the top-level material to map onto this mesh.
TypeID
RestrictionsRequired
 flatten
Flattening parameter: 1 is a perfect circle, numbers less than one flatten in Y, and numbers larger than 1 extend in Y.
Typefloat
Default1
 radius
Radius of the ellipse X axis.
Typefloat
Default1
 segments-around
Number of linear segments to use in the approximation of the Hermite curve.
Typeint
Default11
 segments-long
Number of linear segments to use in the approximation of the ellipse.
Typeint
Default10
 target
ID of another object in the hierarchy, at which this curve ends.
TypeID
RestrictionsRequired
 source-weight
Weight of the starting direction vector in the Hermite blending function.
Typefloat
Default1
 target-weight
Weight of the ending direction vector in the Hermite blending function.
Typefloat
Default1
 texture-dist
Multiplier applied to distance in the computation of mapping V coordinates.
Typefloat
Default0
 texture-p
Multiplier applied to parameter (0 at start, 1 at end) in the computation of mapping V coordinates.
Typefloat
Default1

Viewport Elements

Element: views

Appears in:  master

A view defines the state of a camera which can view the scene. All cameras are "target cameras" defined in terms of the point in scene space which they point toward, their distance from that point, and other frustrum and projection parameters. The global defaults for these parameters are given in the outer views element, and individual views (whether they appear inside the views element, or elsewhere in the master model) use these defaults when their own parameters are unspecified.

 aspect
Intended aspect ratio (width / height). This can be used by display applications to letterbox the view appropriately, when the scene is shown in a different aspect window.
Typefloat
Default1
 dist
Distance between the target point and the camera, in scene units. Note that this must be > 1.0.
Typefloat
Defaultbased on scene extents at init
 max-fov
Maximum Field-of-View in degrees. This is the value used when zoomed out as much as possible for the camera. The conversions between field-of-view and focal length of a nominal 35mm camera are: fov = 2 * atan(17.5 / mm) and mm = 17.5 / tan(fov / 2).
Typefloat
Default28
 min-fov
Minimum Field-of-View in degrees. This is the value used when zoomed in as much as possible.
Typefloat
Default6.667
 max-phi
Maximum upward tilt of the camera, in degrees.
Typefloat
Default80
 min-phi
Maximum downward tilt of the camera, in degrees.
Typefloat
Default-80
 x
Target X.
Typefloat
Defaultcenter of scene at init
 y
Target Y.
Typefloat
Defaultcenter of scene at init
 z
Target Z.
Typefloat
Defaultcenter of scene at init
 view
Named views defined for this scene.
CountZero or More

Element: view

Appears in:  views  at  bookmark

 desc
Description of the view.
Typestring
 id
Unique ID used to refer to this view from scripts.
TypeID
RestrictionsRequired
 aspect
Aspect ratio of the view.
Typefloat
Default(from views element)
 cx
Center of screen projection, ranging from the left edge of the screen (cx=0) to the right edge of the screen (cx=1).
Typefloat
Default0.5
 cy
Center of screen projection, ranging from the top edge of the screen (cy=0) to the bottom edge of the screen (cy=1).
Typefloat
Default0.5
 dist
Distance between the camera and target point.
Typefloat
Default(from views element)
 fov
Field-of-view (zoom lens) in degrees.
Typefloat
Defaultsame as max-fov
 max-fov
Maximum field-of-view for the view.
Typefloat
Default(from views element)
 min-fov
Minimum field-of-view for the view.
Typefloat
Default(from views element)
 max-phi
Maximum upward tilt of the camrea, in degrees.
Typefloat
Default(from views element)
 min-phi
Maximum downward tilt of the camrea, in degrees.
Typefloat
Default(from views element)
 phi
Up/down tilt of the camera, in degrees. 0 is flat, 90 is pointing straight up at the target, -90 is pointing straight down at the target.
Typefloat
Default0
 theta
Orientation of the camera about the scene Y (up) axis. 0 is pointing straight up the Z axis at the target (front view). -90 is pointing straight up the X axis at the target (left view).
Typefloat
Default0
 x
Target X.
Typefloat
Default(from views element)
 y
Target Y.
Typefloat
Default(from views element)
 z
Target Z.
Typefloat
Default(from views element)

Sequence Elements

A sequence conveys the things a Master Model can do. This includes keyframe animation (changes to position, orientation, or pivot), fading, and material changes. There are two kinds of sequences: simple sequences that change the state of one object, and compound sequences which group several simple sequences together. Every sequence defines either a set of discrete states, or a continuous range of states parameterized over the range 0 to 1.

Element: sequences

Appears in:  master

This element contains the top-level sequences which may be referred to from within scripts.

 sequence
Top-level simple and compound sequences.
CountZero or More

Element: sequence

Appears in:  sequences  sequence

A sequence describes a set of related state changes. A simple sequences which acts upon an object in the scene graph must identify that object, in other cases the element acted upon is defined by nested elements.

 id
ID of the sequence, used to refer to it from within scripts.
TypeID
RestrictionsRequired
 desc
Description of the sequence.
Typestring
RestrictionsRequired
 object
Object acted upon by the sequence, if appropriate.
TypeID
 user-material
A special provision is made for sequences which are intended to be extended after model authoring, through the addition of more texture swaps. For these sequences, the user-material attribute identifies the specific material which should be extensible.
TypeID
 sequence
For compound sequences, these are the simple sequences which are combined. Note that the waypoints of the first child sequence are the controlling waypoints for the compound sequence.
CountZero or More
 waypoint
For simple sequences, these are the enumerated states which may be assumed. If they include a p attribute, then the sequence is continuous, and linear interpolation is used between waypoints. If not, the sequence is discrete and each waypoint can only be used exactly.
CountZero or More
 expose
As an optimization, the scene graph may identify individual objects which are concealed in the initial state. Sequences which may expose these objects must then include expose elements, so that optimizers can determine whether the concealed objects can be dropped during model compression.
CountZero or More

Element: expose

Appears in:  sequence

 id
Object which may be exposed if this sequence changes from its initial state.
TypeID
RestrictionsRequired

Element: waypoint

Appears in:  sequence  at

Describes the state of an object

 desc
Text description of the waypoint.
Typestring
 id
Symbolic identifier used by scripts referencing this waypoint (must be unique only within the sequence, typically given values like 0, 1, etc.).
TypeID
 p
Parameter value positioning this waypoint within the sequence.
Typefloat
Range0-1
 alpha
Set the alpha of an object.
CountZero or One
 position
Set the position of an object.
CountZero or One
 orientation
Set the orientation of an object.
CountZero or One
 pivot
Move the pivot point of an object.
CountZero or One
 filter-material
Apply a filter to a material, to change its color or transparency.
CountZero or One
 swap-material
Perform a material-swap.
CountZero or More

Element: filter-material

Appears in:  waypoint

Changes the state of a set of materials using a set of filters.

 select
Select a material to operate upon. Multiple materials may be selected.
CountOne or More
 alpha
Set the transparency of the material. Note that if the material uses a texture with its own alpha channel, this is multiplied with the alpha given here.
CountZero or One
 curve
Apply a color correction curve to the material.
CountZero or One

Element: swap-material

Appears in:  material  waypoint

 material
Select a top-level material to swap.
TypeID
RestrictionsRequired
 swap
Select a single child of that material and make it the new appearance of the top-level material.
TypeID
RestrictionsRequired

Script Elements

A script conveys a time-driven set of changes to scene state and optionally camera viewpoint. Every Master Model must have an initialization script, which sets every sequence to its initial state. Optionally, the master may include a different script which sets up the scene appropriate for thumbnail picture generation.

Element: scripts

Appears in:  master

The set of all top-level scripts defined for this Master Model.

 init
Script to use to initialize the state of the scene.
TypeID
RestrictionsRequired
 thumb
Script to run to set the scene up for thumbnail generation.
TypeID
Defaultsame as init
 script
All scripts.

Element: script

Appears in:  scripts

A script consists of a set of time-stamped operations: "at time T, do X". For usability, the script should list pre-conditions, which identify the state of the scene when this script makes sense to use. For example, a script which opens a door should list as a pre-condition that the door is closed. In general, preconditions make statements about the state of the object acted on by the script, and reflect the initial at elements of the script. A related technique is the before element, which indicates that another script should run before this script, to set the scene up. If the indicated before script does not meet its preconditions, it is skipped. Extending the example, a script which inserts a battery would give a before element indicating that the "Door Open" script should run. If the door is already open, the precondition fails, and the battery inserts. If the door is not open, then the door open script runs, and then the battery is inserted. In general, befores make statemens about other objects, not acted upon by this script, but which must be in certain states for this script to be used.

The bulk of preconditions can be stated using sequence waypoint IDs. In cases where more abstract concepts need to be tested, other variables can be explicitly set to symbolic values using assign elements.

 id
Unique identifier for this script.
TypeID
RestrictionsRequired
 desc
Text description of what this script does.
Typestring
RestrictionsRequired
 pre
List of pre-conditions which ALL must be met for this script to be run.
CountZero or More
 before
List of other scripts to run before this script (if their pre-conditions apply).
CountZero or More
 assign
List of variables assignments to make after this script completes.
CountZero or More
 at
What to do, and when to do it.
CountZero or More

Element: pre

Appears in:  script

Every sequence has an associated variable, which is set to the ID of the most-recently executed waypoint of that sequence. Other variables can be created using assign elements in a script. Both of these can be tested in preconditions.

 variable
Variable to test.
Typestring
RestrictionsRequired
 value
Value required.
Typestring
RestrictionsRequired

Element: before

Appears in:  script

Before a script runs, all its before scripts are tested to see if they can run. Those with precondition that are met are executed in the order given in the parent script.

 duration
If specified, the rate of execution of the before will be adjusted so that it takes exactly this many seconds. If omitted, the before runs at its natural rate.
Typefloat
 script
ID of the script to run.
TypeID
RestrictionsRequired

Element: at

Appears in:  script

Indicates that at a given time, some action should take place.

 t
Time at which the action takes place.
Typefloat
Default0
 view
Set the camera to the indicated view (from within the top-level views element).
TypeID
 sequence
Sequence to set the state of (use with either p or waypoint).
TypeID
 p
Set the parameter of the sequence to this value.
Typefloat
Range0-1
 waypoint
Set the sequence state to this waypoint id.
TypeID
 script
Run the script with the specified ID.
TypeID
 assign
Assign a value to a variable.
CountZero or More
 view
Set the camera to this view (useful when a script needs a unique or transitory view).
CountZero or One
 waypoint
Set the scene root transform. Note that the id attribute of the waypoint element should be left blank, and the child position, orientation, and pivot elements are applied to the scene root.
CountZero or One
 ambient-light
Change the ambient light level (the ambient light in the scene graph with a matching ID is modified).
CountZero or More
 directional-light
Change a directional light (the directional light in the scene graph with a matching ID is modified).
CountZero or More

Element: assign

Appears in:  script  at

Assign a value to a symbol. This element can be used in a script, in order to describe abstractions about the state of the scene, with other scripts can use as preconditions.

 variable
Variable to assign to.
Typestring
RestrictionsRequired
 value
Value to assign to the variable.
Typestring
Default""

Usability Elements

The Master Model format includes some elements which are not strictly part of the definition of the appearance or behavior of the model, but are often specified during modeling for historic reasons.

Element: triggers

Appears in:  master

Triggers are places on the object which can trigger the execution of a script. These are analogous to VMRL "Touch Sensors."

 trigger
List of defined triggers.
CountZero or More

Element: trigger

Appears in:  triggers

 desc
Text description of the trigger location.
Typestring
 id
ID of the trigger.
TypeID
RestrictionsRequired
 object
Object on which the trigger is placed.
TypeID
RestrictionsRequired
 radius
Size of the trigger sphere.
Typefloat
Default0
 x
Center X of the trigger sphere.
Typefloat
Default0
 y
Center Y of the trigger sphere.
Typefloat
Default0
 z
Center Z of the trigger sphere.
Typefloat
Default0
 select
Script to run when the trigger is used.

Element: bookmarks

Appears in:  master

Bookmarks are pre-defined configurations of the object, which may be used to quickly set a group of sequences to a certain state.

 bookmark
List of defined bookmarks.
CountZero or More

Element: bookmark

Appears in:  bookmarks

 desc
Text description of the bookmark.
Typestring
RestrictionsRequired
 id
ID of the bookmark.
TypeID
Defaultauto-generated
 script
Script to use to set the state.
TypeID
RestrictionsRequired
 t
Jump to this time in the script.
Typefloat
Default0
 view
Change the view to this view (overriding any camera setting in the script).
CountZero or One

Compression Elements

The Master Model format is designed to promote reuse of 3D models across a wide range of applications. One of these applications may be compressed web transmission, so there are several elements specifically for that purpose. These are entirely optional, as not all models are properly engineered for web use. Also, note that while these setting lead to a certain quality, they only provide a relative baseline - web compression algorithms may include more or less detail, based on end-user requirements.

Element: images

Appears in:  master

Defines compression parameters for texture images used by the Master Model

 image
List of image compression controls.
CountZero or More

Element: image

Appears in:  images

Each image used in the model (other than pre-compressed images, such as GIF files) can include an image tag to control compression and display when a web model is derived from the Master Model.

 has-alpha
Whether there is per-pixel alpha data in the image file.
Typeenum 
unknown, true, false
Default"unknown"
 image
Name of the image file.
Typestring
RestrictionsRequired
 tile
Size (width and height - tiles are square) of the tiles in the composite image, prior to scaling.
Typeint
Default32
 tpi
Measure of texture density on the 3D model, in texels-per-inch (square root of texel area over surface area). Computed during compression.
Typefloat
 type
A composite image collects a set of other images together for compression. When this technique is used, the parent image is marked with type=composite. Any images which were collected together may still have image elements, but they are marked type=in-composite as a hint that they are not to be compressed individually.
Typeenum 
Default""
 subimage
List of sub-images which contribute to a composite image.
CountZero or More
 web
Web compression parameters for this image.
CountZero or One

Element: subimage

Appears in:  image

 image
Image which is included in the composite image.
Typestring
 r
0 means not rotated, 1 means rotated 90 degrees clockwise.
Typeenum 0, 1
 w
Number of tiles wide to consume in the composite image.
Typeint
Default0
 h
Number of tiles high to consume in the composite image.
Typeint
Default0
 x
Coordinate tile-X of the upper left tile used by the sub-image.
Typeint
Default0
 y
Coorindate tile-Y of the upper left tile used by the sub-image.
Typeint
Default0

Element: web

Appears in:  image

This element gives a set of hints which can be used to provide the best user experience when viewing an interactive web model derived from this Master Model.

 bit16
If true, the texture needs only 16 bits per pixel, not 32.
Typeboolean
Defaulttrue
 blur
Use a more aggressive mipmap selection, to choose blurrier mip-levels when possible. This is typically set on images with repeating patterns (speaker grills, air vents, etc.) which are extremely susceptable to moiré patterns.
Typeboolean
Defaultfalse
 compression-type
Selects the preferred compression type.
Typeenum 
undefined, jpeg, wavelet
Defaultundefined
 dither
When using less than true-color, whether to apply an error-diffusion dither as the colors are sampled into the lower-bit space.
Typeboolean
Defaulttrue
 filesize
Expected file size after compression (computed automatically, if not specified).
Typeint
 mipmap
Whether to use mipmapping to reduce aliasing artifacts.
Typeboolean
Defaulttrue
 scale
Scale the original image by this factor prior to compression.
Typefloat
Default1
 tpi
Measure of texture density on the 3D model, in texels-per-inch (square root of texel area over surface area). Computed during compression.
Typefloat
Defaultcomputed
 use-alpha
If true, the texture should expect per-pixel alpha channel information in the texture data.
Typeboolean
Defaultfalse
 width
Original width of the image.
Typeint
Defaultcomputed
 height
Original height of the image.
Typeint
Defaultcomputed
 jpeg
JPEG compression parameters.
CountZero or One
 wavelet
Wavelet compression parameters.
CountZero or One

Element: jpeg

Appears in:  web

JPEG compression parameters

 noise-reduction
Whether to noise-reduce the image prior to compression (similar to smoothing, but less artifact inducing).
Typeboolean
Defaultfalse
 quality
Controls quality.
Typefloat
Default50
Range0-100
 subsampling
Sub-sampling of color within pixel blocks.
Typeenum 
"444", "411"
Default"411"
 bpp
Bits per pixel (derived from other attributes and saved during compression)
Typefloat
Default0.5

Element: wavelet

Appears in:  web

Wavelet encoding parameters are specific to the Strata wavelet compression algorithm.

 compression
Controls quality.
Typefloat
 bit-alloc-power0
Controls quality
Typefloat
 bit-alloc-power1
Controls quality
Typefloat
 bit-alloc-version
Algorithm used
Typestring
 channels
Monochrome, Full color in all bands except highest, or full color in all bands.
Typeenum 1, 1.5, 3
Default1.5
 color-compression
Relative compression of color versus intensity data.
Typefloat
Default0.5
 noise-reduction
Whether to apply noise-reduction prior to compression.
Typeboolean
Defaultfalse
 exclude-ROI-from-noise-reduction
Whether to exclude ROI from noise reduction if applicable.
Typeboolean
Defaultfalse
 priority
Relative priority of this image relative to other images, used to sort progressive bands within a compressed file.
Default0
 roi-quality
Relative quality of regions of interest.
Typefloat
Default2
 sharpen
Whether to apply sharpening to the image after decompression.
Typeboolean
Defaultfalse
 bpp
Bits per pixel (derived from other attributes and saved during compression)
Typefloat
Default0.5
 rois
Regions of interest that are compressed less agressively.
CountZero or More

Element: rois

Appears in:  wavelet

An image may use regions-of-interest (rois) to indicate areas which are compressed less aggressively.

 roi
List of regions of interest.
CountZero or More

Element: roi

Appears in:  rois

 type
Geometry of the region.
Typeenum 
rect, ellipse, polygon
 x0
Upper left corner X of bounding rectangle, expressed as portion of total width.
Typefloat
Default0
Range0-1
 y0
Upper left corner Y of bounding rectangle, expressed as portion of total height.
Typefloat
Default0
Range0-1
 width
Width of bounding rectangle, expressed as portion of total width.
Typefloat
Default0
Range0-1
 height
Height of bounding rectangle, expressed as portion of total height.
Typefloat
Default0
Range0-1
 point
For polygon regions, the vertices of the polygon, in order.

Container and Utility Elements

These elements are used in a variety of places throughout the Master Model.

Element: select

Appears in:  filter-material  trigger

Specifies an element on which to act.

 id
ID of the element.
TypeID
RestrictionsRequired

Element: alpha

Appears in:  material  object  waypoint  filter-material

Alpha conveys the transparency/opacity of a material or object. The value 0 means completely transparent, and 1 means completely opaque. Note that the VRML "transparency" material attribute is 1.0-alpha, and vice-versa.

 value
Alpha value.
Typefloat
Default0
Range0-1

Element: orientation

Appears in:  object  waypoint

Orientation of an object is conveyed using three Euler angles. First, rotation about the parent up (Y) axis through an angle theta. Second rotation about the new right (X) axis, through an angle phi. Third, rotation about the new forward (Z) axis, through an angle psi.

Given the forward direction (Z) axis, theta = atan2(-Zx, Zz).

Given the forward direction (Z) axis, phi = asin(Zy).

Given the local right (X) axis, and the local up (Y) axis, psi = atan2(Xy, Yy).

 theta
Rotation about Y, in degrees.
Typefloat
Default0
 phi
Rotation about rotated X, in degrees.
Typefloat
Default0
 psi
Rotation about rotated Z, in degrees.
Typefloat
Default0

Element: pivot

Appears in:  object  waypoint

The pivot is a local coordinate location about which rotation occurs. It contributes to the transform both before, and after, rotation. Given our position relative to our parent Positionparent, and our orientation relative to our parent Rotationparent, the position used to transform us to our parent is given by: Positionxform = Positionparent + Pivot - (Pivot * Rotationparent).

 x
Pivot X.
Typefloat
Default0
 y
Pivot Y.
Typefloat
Default0
 z
Pivot Z.
Typefloat
Default0

Element: point

Appears in:  curve-channel  roi

Point elements are used to identify generic 2D coordinates.

 x
X.
Typefloat
Default0
 y
Y.
Typefloat
Default0

Element: position

Appears in:  object  waypoint

Position elements convey the relative position of an object in its parent's coordinate system.

 x
X (right).
Typefloat
Default0
 y
Y (up).
Typefloat
Default0
 z
Z (forward).
Typefloat
Default0

Index

<alpha>
ambient   <material>
<ambient-light>
apply-to-blue   <curve-channel>
apply-to-green   <curve-channel>
apply-to-red   <curve-channel>
aspect   <views>  <view>
<assign>
<at>

backface   <material>
<before>
billboard   <object>
bit16   <web>
bit-alloc-power0   <wavelet>
bit-alloc-power1   <wavelet>
bit-alloc-version   <wavelet>
blur   <web>
<bookmark>
<bookmarks>
bpp   <jpeg>  <wavelet>

channels   <wavelet>
chrome   <material>
color   <material>
color-compression   <wavelet>
composite   <material>
compression   <wavelet>
compression-type   <web>
concealed   <object>
count   <group>
<curve>
<curve-channel>
cx   <view>
cy   <view>

desc   <object>  <view>  <sequence>  <waypoint>  <script>  <trigger>  <bookmark>
diffuse   <material>
<directional-light>
dist   <views>  <view>
dither   <web>
duration   <before>

<elliptical-hermite-loft>
exclude-ROI-from-noise-reduction   <wavelet>
<expose>

<f>
<faces>
<file>
<files>
filesize   <web>
<filter-material>
flatten   <elliptical-hermite-loft>
<fm>
fov   <view>

glossiness   <material>
<group>

h   <subimage>
has-alpha   <image>
height   <web>  <roi>

id   <material>  <ambient-light>  <directional-light>  <object>  <view>  <sequence>  <expose>  <waypoint>  <script>  <trigger>  <bookmark>  <select>
image   <material>  <image>  <subimage>
<image>
<images>
init   <scripts>
intensity   <ambient-light>  <directional-light>

<jpeg>

light   <material>
<lod>

<m>
m1   <f>  <fm>
m2   <f>  <fm>
m3   <f>  <fm>
<maps>
<master>
<material>
material   <group>  <elliptical-hermite-loft>  <swap-material>
<materials>
max-fov   <views>  <view>
max-phi   <views>  <view>
<mesh>
millimeter   <objects>
min-fov   <views>  <view>
min-phi   <views>  <view>
mipmap   <web>

name   <file>
noise-reduction   <jpeg>  <wavelet>

<object>
object   <sequence>  <trigger>
<objects>
ord   <faces>
<orientation>

p   <waypoint>  <at>
phi   <view>  <orientation>
<pivot>
<point>
<position>
<pre>
priority   <wavelet>
private   <object>
psi   <orientation>

quality   <jpeg>

<RDF>

r   <subimage>
radius   <elliptical-hermite-loft>  <trigger>
<roi>
roi-quality   <wavelet>
<rois>

s   <group>  <f>
scale   <web>
<script>
script   <before>  <at>  <bookmark>
<scripts>
segments-around   <elliptical-hermite-loft>
segments-long   <elliptical-hermite-loft>
<select>
<sequence>
sequence   <at>
<sequences>
sharpen   <wavelet>
source-weight   <elliptical-hermite-loft>
specular   <material>
src   <verts>  <maps>  <faces>
<subimage>
subsampling   <jpeg>
swap   <swap-material>
<swap-material>

t   <at>  <bookmark>
target   <elliptical-hermite-loft>
target-weight   <elliptical-hermite-loft>
texture-dist   <elliptical-hermite-loft>
texture-p   <elliptical-hermite-loft>
theta   <view>  <orientation>
thumb   <scripts>
tile   <image>
tpi   <image>  <web>
<trigger>
<triggers>
type   <image>  <roi>

u   <m>
use-alpha   <web>
user-material   <sequence>
uv-quant   <objects>

<v>
v   <m>
v1   <f>
v2   <f>
v3   <f>
value   <pre>  <assign>  <alpha>
variable   <pre>  <assign>
<verts>
<view>
view   <at>
<views>

w   <subimage>
<wavelet>
<waypoint>
waypoint   <at>
<web>
weld-thresh   <objects>
width   <web>  <roi>
wrap-u   <material>
wrap-v   <material>

x   <directional-light>  <v>  <views>  <view>  <trigger>  <subimage>  <pivot>  <point>  <position>
x0   <roi>
xyz-quant   <objects>

y   <directional-light>  <v>  <views>  <view>  <trigger>  <subimage>  <pivot>  <point>  <position>
y0   <roi>

z   <directional-light>  <v>  <views>  <view>  <trigger>  <pivot>  <position>