Strata - The Power of 3D > Products > Strata 3D CX Suite > Strata Live 3D CX

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.
Count	Zero or One

files
		Ancillary data files, in base 64 format.
Count	Zero or One

materials
		A list of material definitions used by meshes in this master.
Count	Zero or One

objects
		The scene graph.
Count	Zero or One

views
		Named camera configurations.
Count	Zero or One

sequences
		Parameterized state change definitions for objects in the scene graph and materials.
Count	Zero or One

scripts
		Time-based animations which control one or more sequences, and optionally the camera.
Count	Zero or One

triggers
		3D locations on the object which may be used in interactive applications to trigger behaviors or highlight parts.
Count	Zero or One

bookmarks
		Named scene configurations.
Count	Zero or One

images
		Image compression information used in the creation of web-resolution models.
Count	Zero 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.
Count	Zero 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.
Type	string
Restrictions	Required

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.
Count	Zero or More

Element: material
Appears in: materials material

id
		Unique identifier which meshes in the scene graph use to reference this material.
Type	ID
Restrictions	Required

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.
Type	string

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.
Type	string

backface
		Indicates whether back-facing triangles which use this material should be rendered.
Type	boolean
Default	false

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).
Type	boolean
Default	true

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).
Type	boolean
Default	true

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.
Type	enum =, *, +
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.
Type	enum none, phong
Default	"none"

ambient
		The global ambient light level is multiplied by this value to compute the color/texture baseline brightness value.
Type	float
Default	1

diffuse
		Direct light levels are multiplied by this value to compute their contribution to the color/texture brightness value.
Type	float
Default	1

specular
		Specular highlights are multiplied by this value to compute their contribution to the whiteness of the material.
Type	float
Default	0

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.
Type	float
Default	0

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.
Type	float
Default	0

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.
Count	Zero or One

curve
		Apply this color curve to texture values prior to rendering.
Count	Zero 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.
Count	Zero or More

swap-material
		Indicates a child material which should be used as the initial version of this material.
Count	Zero 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.
Count	One or More

Element: curve-channel
Appears in: curve

apply-to-red
		Whether to run the red channel through this curve.
Type	boolean
Default	false

apply-to-green
		Whether to run the green channel through this curve.
Type	boolean
Default	false

apply-to-blue
		Whether to run the blue channel through this curve.
Type	boolean
Default	false

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).
Count	Zero 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:

System	Master X	Master Y	Master Z	Triangle Winding
VRML	x	y	-z	Reverse
PLY	x	y	-z	Reverse
STL	x	z	y	Reverse
OBJ	x	-z	-y	Reverse
3DS	x	z	y	Reverse
Direct3D	x	y	z	Unchanged

millimeter
		Translation from native modeling units to millimeters. The default of 25.4 is appropriate for models which are in inches.
Type	float
Default	25.4

uv-quant
		When compressing this model for use in Web applications, the number of bits of precision (quantization) to use for texture coordinates.
Type	int
Default	11

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).
Type	float
Default	0.0005

xyz-quant
		When compressing this model for use in Web applications, the number of bits of precision (quantization) to use for positional coordinates.
Type	int
Default	11

ambient-light
		Ambient lights in the scene.
Count	Zero or More

directional-light
		Directional lights in the scene.
Count	Zero or More

object
		Object hierarchies which make up the scene.
Count	Zero 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.
Type	ID
Default	auto-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).
Type	float
Default	0

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.
Type	ID
Default	auto-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).
Type	float
Default	0

x
		X component of the light direction vector.
Type	float
Default	0

y
		Y component of the light direction vector.
Type	float
Default	0

z
		Z component of the light direction vector.
Type	float
Default	0

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.
Type	ID
Default	auto-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.
Type	string
Restrictions	Required

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.
Type	boolean
Default	false

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.
Type	boolean
Default	false

billboard
		If specified, indicates that the object should use spherical billboard rules, meaning always face the camera in all 3 degrees of freedom.
Type	enum 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.
Count	Zero or One

lod
		Level-of-detail representation of the mesh of this object.
Count	Zero or One

mesh
		Direct triangular representation of the mesh of this object.
Count	Zero or One

elliptical-hermite-loft
		Instructions for algorithmically generating the mesh of this object.
Count	Zero or One

object
		Objects which are attached to this object in the scene graph (sub-hierarchies of objects).
Count	Zero or More

orientation
		Parent-relative orientation of the mesh of this object, and parent coordinate orientation for children of this object.
Count	Zero or One

position
		Parent-relative position of the mesh of this object, and parent coordinate position for children of this object.
Count	Zero 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.
Count	Zero 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.
Count	Zero or More

elliptical-hermite-loft
		Various algorithmic representations of the geometry of this object.
Count	Zero 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.
Count	Zero 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.
Count	One or More

maps
		Table of texture mapping coordinates.
Count	Zero or One

faces
		Face topology and material mapping.
Count	One 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.
Type	string

v
		Directly specified vertex locations.
Count	Zero or More

Element: v
Appears in: verts

One vertex in the vertex table.

x
		X coordinate.
Type	float
Default	0

y
		Y coordinate.
Type	float
Default	0

z
		Z coordinate.
Type	float
Default	0

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.
Type	string

m
		Directly specified mapping coordinates.
Count	Zero or More

Element: m
Appears in: maps

u
		U mapping coordinate.
Type	float
Default	0

v
		V mapping coordinate.
Type	float
Default	0

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.
Type	string

ord
		Number of 4-byte data items in the file, per triangle.
Type	int
Default	7

group
		Groups of triangles which use the same material.
Count	Zero 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.
Type	int
Default	0

material
		ID of the material to use for this group. This must be a top-level material within the materials element.
Type	ID
Restrictions	Required

s
		Smoothing group code to use for this group.
Type	int
Default	1

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.
Count	Zero 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.
Type	int
Default	0

v2
		Index into the mesh vertex table.
Type	int
Default	0

v3
		Index into the mesh vertex table.
Type	int
Default	0

m1
		Index into the mesh mapping table.
Type	int
Default	same as v1

m2
		Index into the mesh mapping table.
Type	int
Default	same as v2

m3
		Index into the mesh mapping table.
Type	int
Default	same as v3

s
		Smoothing group of this face.
Type	int
Default	s 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.
Count	Zero 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.
Type	int
Default	m1 attribute of f

m2
		Index into the mesh mapping table.
Type	int
Default	m2 attribute of f

m3
		Index into the mesh mapping table.
Type	int
Default	m3 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.
Type	ID
Restrictions	Required

flatten
		Flattening parameter: 1 is a perfect circle, numbers less than one flatten in Y, and numbers larger than 1 extend in Y.
Type	float
Default	1

radius
		Radius of the ellipse X axis.
Type	float
Default	1

segments-around
		Number of linear segments to use in the approximation of the Hermite curve.
Type	int
Default	11

segments-long
		Number of linear segments to use in the approximation of the ellipse.
Type	int
Default	10

target
		ID of another object in the hierarchy, at which this curve ends.
Type	ID
Restrictions	Required

source-weight
		Weight of the starting direction vector in the Hermite blending function.
Type	float
Default	1

target-weight
		Weight of the ending direction vector in the Hermite blending function.
Type	float
Default	1

texture-dist
		Multiplier applied to distance in the computation of mapping V coordinates.
Type	float
Default	0

texture-p
		Multiplier applied to parameter (0 at start, 1 at end) in the computation of mapping V coordinates.
Type	float
Default	1

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.
Type	float
Default	1

dist
		Distance between the target point and the camera, in scene units. Note that this must be > 1.0.
Type	float
Default	based 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).
Type	float
Default	28

min-fov
		Minimum Field-of-View in degrees. This is the value used when zoomed in as much as possible.
Type	float
Default	6.667

max-phi
		Maximum upward tilt of the camera, in degrees.
Type	float
Default	80

min-phi
		Maximum downward tilt of the camera, in degrees.
Type	float
Default	-80

x
		Target X.
Type	float
Default	center of scene at init

y
		Target Y.
Type	float
Default	center of scene at init

z
		Target Z.
Type	float
Default	center of scene at init

view
		Named views defined for this scene.
Count	Zero or More

Element: view
Appears in: views at bookmark

desc
		Description of the view.
Type	string

id
		Unique ID used to refer to this view from scripts.
Type	ID
Restrictions	Required

aspect
		Aspect ratio of the view.
Type	float
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).
Type	float
Default	0.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).
Type	float
Default	0.5

dist
		Distance between the camera and target point.
Type	float
Default	(from views element)

fov
		Field-of-view (zoom lens) in degrees.
Type	float
Default	same as max-fov

max-fov
		Maximum field-of-view for the view.
Type	float
Default	(from views element)

min-fov
		Minimum field-of-view for the view.
Type	float
Default	(from views element)

max-phi
		Maximum upward tilt of the camrea, in degrees.
Type	float
Default	(from views element)

min-phi
		Maximum downward tilt of the camrea, in degrees.
Type	float
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.
Type	float
Default	0

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).
Type	float
Default	0

x
		Target X.
Type	float
Default	(from views element)

y
		Target Y.
Type	float
Default	(from views element)

z
		Target Z.
Type	float
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.
Count	Zero 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.
Type	ID
Restrictions	Required

desc
		Description of the sequence.
Type	string
Restrictions	Required

object
		Object acted upon by the sequence, if appropriate.
Type	ID

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.
Type	ID

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.
Count	Zero 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.
Count	Zero 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.
Count	Zero or More

Element: expose
Appears in: sequence

id
		Object which may be exposed if this sequence changes from its initial state.
Type	ID
Restrictions	Required

Element: waypoint
Appears in: sequence at

Describes the state of an object

desc
		Text description of the waypoint.
Type	string

id
		Symbolic identifier used by scripts referencing this waypoint (must be unique only within the sequence, typically given values like 0, 1, etc.).
Type	ID

p
		Parameter value positioning this waypoint within the sequence.
Type	float
Range	0-1

alpha
		Set the alpha of an object.
Count	Zero or One

position
		Set the position of an object.
Count	Zero or One

orientation
		Set the orientation of an object.
Count	Zero or One

pivot
		Move the pivot point of an object.
Count	Zero or One

filter-material
		Apply a filter to a material, to change its color or transparency.
Count	Zero or One

swap-material
		Perform a material-swap.
Count	Zero 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.
Count	One 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.
Count	Zero or One

curve
		Apply a color correction curve to the material.
Count	Zero or One

Element: swap-material
Appears in: material waypoint

material
		Select a top-level material to swap.
Type	ID
Restrictions	Required

swap
		Select a single child of that material and make it the new appearance of the top-level material.
Type	ID
Restrictions	Required

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.
Type	ID
Restrictions	Required

thumb
		Script to run to set the scene up for thumbnail generation.
Type	ID
Default	same 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.
Type	ID
Restrictions	Required

desc
		Text description of what this script does.
Type	string
Restrictions	Required

pre
		List of pre-conditions which ALL must be met for this script to be run.
Count	Zero or More

before
		List of other scripts to run before this script (if their pre-conditions apply).
Count	Zero or More

assign
		List of variables assignments to make after this script completes.
Count	Zero or More

at
		What to do, and when to do it.
Count	Zero 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.
Type	string
Restrictions	Required

value
		Value required.
Type	string
Restrictions	Required

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.
Type	float

script
		ID of the script to run.
Type	ID
Restrictions	Required

Element: at
Appears in: script

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

t
		Time at which the action takes place.
Type	float
Default	0

view
		Set the camera to the indicated view (from within the top-level views element).
Type	ID

sequence
		Sequence to set the state of (use with either p or waypoint).
Type	ID

p
		Set the parameter of the sequence to this value.
Type	float
Range	0-1

waypoint
		Set the sequence state to this waypoint id.
Type	ID

script
		Run the script with the specified ID.
Type	ID

assign
		Assign a value to a variable.
Count	Zero or More

view
		Set the camera to this view (useful when a script needs a unique or transitory view).
Count	Zero 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.
Count	Zero or One

ambient-light
		Change the ambient light level (the ambient light in the scene graph with a matching ID is modified).
Count	Zero or More

directional-light
		Change a directional light (the directional light in the scene graph with a matching ID is modified).
Count	Zero 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.
Type	string
Restrictions	Required

value
		Value to assign to the variable.
Type	string
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.
Count	Zero or More

Element: trigger
Appears in: triggers

desc
		Text description of the trigger location.
Type	string

id
		ID of the trigger.
Type	ID
Restrictions	Required

object
		Object on which the trigger is placed.
Type	ID
Restrictions	Required

radius
		Size of the trigger sphere.
Type	float
Default	0

x
		Center X of the trigger sphere.
Type	float
Default	0

y
		Center Y of the trigger sphere.
Type	float
Default	0

z
		Center Z of the trigger sphere.
Type	float
Default	0

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.
Count	Zero or More

Element: bookmark
Appears in: bookmarks

desc
		Text description of the bookmark.
Type	string
Restrictions	Required

id
		ID of the bookmark.
Type	ID
Default	auto-generated

script
		Script to use to set the state.
Type	ID
Restrictions	Required

t
		Jump to this time in the script.
Type	float
Default	0

view
		Change the view to this view (overriding any camera setting in the script).
Count	Zero 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.
Count	Zero 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.
Type	enum unknown, true, false
Default	"unknown"

image
		Name of the image file.
Type	string
Restrictions	Required

tile
		Size (width and height - tiles are square) of the tiles in the composite image, prior to scaling.
Type	int
Default	32

tpi
		Measure of texture density on the 3D model, in texels-per-inch (square root of texel area over surface area). Computed during compression.
Type	float

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.
Type	enum
Default	""

subimage
		List of sub-images which contribute to a composite image.
Count	Zero or More

web
		Web compression parameters for this image.
Count	Zero or One

Element: subimage
Appears in: image

image
		Image which is included in the composite image.
Type	string

r
		0 means not rotated, 1 means rotated 90 degrees clockwise.
Type	enum 0, 1

w
		Number of tiles wide to consume in the composite image.
Type	int
Default	0

h
		Number of tiles high to consume in the composite image.
Type	int
Default	0

x
		Coordinate tile-X of the upper left tile used by the sub-image.
Type	int
Default	0

y
		Coorindate tile-Y of the upper left tile used by the sub-image.
Type	int
Default	0

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.
Type	boolean
Default	true

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.
Type	boolean
Default	false

compression-type
		Selects the preferred compression type.
Type	enum undefined, jpeg, wavelet
Default	undefined

dither
		When using less than true-color, whether to apply an error-diffusion dither as the colors are sampled into the lower-bit space.
Type	boolean
Default	true

filesize
		Expected file size after compression (computed automatically, if not specified).
Type	int

mipmap
		Whether to use mipmapping to reduce aliasing artifacts.
Type	boolean
Default	true

scale
		Scale the original image by this factor prior to compression.
Type	float
Default	1

tpi
		Measure of texture density on the 3D model, in texels-per-inch (square root of texel area over surface area). Computed during compression.
Type	float
Default	computed

use-alpha
		If true, the texture should expect per-pixel alpha channel information in the texture data.
Type	boolean
Default	false

width
		Original width of the image.
Type	int
Default	computed

height
		Original height of the image.
Type	int
Default	computed

jpeg
		JPEG compression parameters.
Count	Zero or One

wavelet
		Wavelet compression parameters.
Count	Zero 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).
Type	boolean
Default	false

quality
		Controls quality.
Type	float
Default	50
Range	0-100

subsampling
		Sub-sampling of color within pixel blocks.
Type	enum "444", "411"
Default	"411"

bpp
		Bits per pixel (derived from other attributes and saved during compression)
Type	float
Default	0.5

Element: wavelet
Appears in: web

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

compression
		Controls quality.
Type	float

bit-alloc-power0
		Controls quality
Type	float

bit-alloc-power1
		Controls quality
Type	float

bit-alloc-version
		Algorithm used
Type	string

channels
		Monochrome, Full color in all bands except highest, or full color in all bands.
Type	enum 1, 1.5, 3
Default	1.5

color-compression
		Relative compression of color versus intensity data.
Type	float
Default	0.5

noise-reduction
		Whether to apply noise-reduction prior to compression.
Type	boolean
Default	false

exclude-ROI-from-noise-reduction
		Whether to exclude ROI from noise reduction if applicable.
Type	boolean
Default	false

priority
		Relative priority of this image relative to other images, used to sort progressive bands within a compressed file.
Default	0

roi-quality
		Relative quality of regions of interest.
Type	float
Default	2

sharpen
		Whether to apply sharpening to the image after decompression.
Type	boolean
Default	false

bpp
		Bits per pixel (derived from other attributes and saved during compression)
Type	float
Default	0.5

rois
		Regions of interest that are compressed less agressively.
Count	Zero 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.
Count	Zero or More

Element: roi
Appears in: rois

type
		Geometry of the region.
Type	enum rect, ellipse, polygon

x0
		Upper left corner X of bounding rectangle, expressed as portion of total width.
Type	float
Default	0
Range	0-1

y0
		Upper left corner Y of bounding rectangle, expressed as portion of total height.
Type	float
Default	0
Range	0-1

width
		Width of bounding rectangle, expressed as portion of total width.
Type	float
Default	0
Range	0-1

height
		Height of bounding rectangle, expressed as portion of total height.
Type	float
Default	0
Range	0-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.
Type	ID
Restrictions	Required

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.
Type	float
Default	0
Range	0-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(-Z_x, Z_z).

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

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

theta
		Rotation about Y, in degrees.
Type	float
Default	0

phi
		Rotation about rotated X, in degrees.
Type	float
Default	0

psi
		Rotation about rotated Z, in degrees.
Type	float
Default	0

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 Position_parent, and our orientation relative to our parent Rotation_parent, the position used to transform us to our parent is given by: Position_xform = Position_parent + Pivot - (Pivot * Rotation_parent).

x
		Pivot X.
Type	float
Default	0

y
		Pivot Y.
Type	float
Default	0

z
		Pivot Z.
Type	float
Default	0

Element: point
Appears in: curve-channel roi

Point elements are used to identify generic 2D coordinates.

x
		X.
Type	float
Default	0

y
		Y.
Type	float
Default	0

Element: position
Appears in: object waypoint

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

x
		X (right).
Type	float
Default	0

y
		Y (up).
Type	float
Default	0

z
		Z (forward).
Type	float
Default	0

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>

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>

Master Model Format Specification

Overview

Master Model XML

Style Guide

Simple Example

Master Model Element

Element: master

Metadata Elements

Element: RDF Appears in: master

Embedded Files

Element: files Appears in: master

Element: file Appears in: files

Material Elements

Element: materials Appears in: master

Element: material Appears in: materials material

Element: curve Appears in: material filter-material

Element: curve-channel Appears in: curve

Scene Graph Elements

Element: objects Appears in: master

Element: ambient-light Appears in: objects at

Element: directional-light Appears in: objects at

Element: object Appears in: objects object lod

Element: lod Appears in: object

Element: mesh Appears in: object lod

Element: verts Appears in: mesh

Element: v Appears in: verts

Element: maps Appears in: mesh

Element: m Appears in: maps

Element: faces Appears in: mesh

Element: group Appears in: faces

Element: f Appears in: group

Element: fm Appears in: f

Element: elliptical-hermite-loft Appears in: object lod

Viewport Elements

Element: views Appears in: master

Element: view Appears in: views at bookmark

Sequence Elements

Element: sequences Appears in: master

Element: sequence Appears in: sequences sequence

Element: expose Appears in: sequence

Element: waypoint Appears in: sequence at

Element: filter-material Appears in: waypoint

Element: swap-material Appears in: material waypoint