PolyTrans-for-3dsMax Overview

Overview

PolyTrans-for-3dsMax is a heavily developed, supported and maintained version of Okino PolyTrans that is integrated directly inside Autodesk's 3ds Max product. This plug-in system adds dozens of new 3D file formats directly accessible from inside 3ds Max via the "Utility" roll-up panel. It is considered our "main product", used by a majority of the Okino professional user base, which has been developed over a period of 23 years.

PolyTrans-for-3dsMax is also a mirror twin to the "PolyTrans-for-Maya" native plug-in system, with both being actively developed together for the tightest bi-directional conversions between these two programs.

Hyperlinks to Online Documentation

Please click on one of the following links to obtain information about the usage of the import and export converters:

PolyTrans Import Converters and Runtime Usage

PolyTrans Export Converters and Runtime Usage

How to invoke and use the PolyTrans Import Converters

How to invoke and use the PolyTrans Export Converters

Invoking PolyTrans via MaxScript or the 'Function Publishing System'

Important info about Okino .bdf File Transfer Format

Transferring data between 3ds Max and Maya

Notes and limitations about exporting skeleton deformation data (skinning) from SkinMod and Character Studio

How Hierarchies Convert Between 3ds Max, Maya, PolyTrans and Other 3D Programs

Notes about Transferring Camera Field-of-View Between 3ds Max and Other 3D Programs

Important Notices:

1. If PolyTrans-for-3dsMax cannot locate one or more bitmap files during the automatic bitmap conversion process, then you will need to inform PolyTrans-for-3dsMax where your source bitmaps are located. This can easily be done via the Search-Paths dialog box inside PolyTrans-for-3dsMax.

2. If you find that imported and resampled animation function curves ‘have wobble’ in them, then you have complete control to tweak the resampling process via the distance and angle threshold parameters shown on the "Animation Resampling and Reduction Options" dialog box. The lower you make these values the more the resampled curves will resemble the original animation curves; the higher you set these values the fewer keyframes will be created and the more the resampled animation curve will be averaged over its length. There are no absolute ideal values for these parameters and they are provided for your convenience.

Copyright (c) 1988-2020 Okino Computer Graphics, Inc. 3ds Max, Maya are registered trademarks of Autodesk, Inc.

For updates please visit the Okino WEB site at http://www.okino.com or email to support@okino.com.


PolyTrans Export Converters for 3ds Max

Click here to learn how to export objects from 3ds Max using the PolyTrans plug-in.

Click on one of these links for more information:

"3ds Max to PolyTrans dialog box" options

"Supported parameter conversions and mappings" options

Invoking PolyTrans via MaxScript or the 'Function Publishing System'

Click here to jump to the table of contents for this help file.


Export Conversion Process

The export process proceeds as follows:

1. The user presses the [image] icon on the 3ds Max user interface to cause the utility panel to be displayed.

2. If the "PolyTrans I/O Converters" button is not visible on the utility panel, as shown below, then click on the button located to the right of the "Sets" button. After the dialog box appears, link the "PolyTrans I/O Converters" utility plugin entry to one of the empty button slots.

3. Click on the "PolyTrans I/O Converters" button that should now be visible on the 3ds Max utility panel (shown above).

4. Click on the "Export" tab located just above the list box containing the import/export converters:

5. If you wish to modify the export options prior to starting one of the export converters then press the "Export Options" button located below the listbox. The "3ds Max to PolyTrans" dialog box will appear. These options control how the scene data will be exported from the 3ds Max internal database to the PolyTrans internal database. Press "Ok" to continue.

6. Click on one of the export converters listed in the listbox. A filename selector will appear with which you can choose the exported filename.

7. After the filename selector goes away, the scene data is sent from the 3ds Max internal database to the PolyTrans internal database.

8. The corresponding PolyTrans export converter DLL is then loaded and executed. The data will then be exported from the PolyTrans internal database to the export file converter.


"3ds Max to PolyTrans" Dialog Box Options:

This dialog box controls the transfer of data from the internal 3ds Max database to the PolyTrans internal database.

See also:

Notes and limitations about exporting skeleton deformation data (skinning) from SkinMod and Character Studio

Common Options

Edit Automatic Bitmap Conversion Search Paths

In specific circumstances you will need to inform PolyTrans where your source bitmap images are located so that automatic bitmap file conversion proceeds properly. If PolyTrans reports warnings that specific images could not be located during automatic bitmap conversion press this button so that the Search-Paths dialog box appears. Using this dialog box you can tell PolyTrans where your source bitmaps are located.

Enables Panel # 1

Object Hierarchy

If this checkbox is checkmarked then object hierarchy will be output from 3ds Max to PolyTrans. Please refer to the how hierarchy is output section for information about how PolyTrans converts the 3ds Max hierarchy into a DAG node hierarchy.

Assume children of bones are bone nodes

It is common to place "helper" objects beneath Biped hierarchies. These helper objects are not necessarily bones, but Physique can use them as bones for skinning purposes. To properly detect these items as "bones" for export, it is necessary to enable this option.

This option can also be useful when either Physique or the 3ds Max "Skin Modifier" uses a chain of non-bone objects as bones for skinning.

Merge Xref'd skinned meshes to scene (3ds Max v8 or newer only)

If this checkbox is checkmarked, and the exporter encounters a skinned mesh node which was defined as part of an "Object Xref'd" file, then that file will be "Merged to Scene" before the tree walking process progresses any further. This option is necessary to overcome a bug in 3ds Max v8 or newer which does not let this exporter obtain a proper bind pose matrix for a skinned mesh if it exists inside an "Object Xref'd" file. A warning will be reported to the "Message Window" after export if this exporter detects such a case in the scene graph.

If you find that an exported skinned mesh has oddities in the way the mesh is deformed, and you know that Xref's are used to define the skinned mesh(es), then you should enable this option.

Process and Output Character Studio or "Skin Modifier" deformations

See also:

Notes and limitations about exporting skeleton deformation data (skinning) from SkinMod and Character Studio

This is one of the most complex aspects of the 3ds Max and PolyTrans conversion software. It allows "skinned meshes" (meshes which are deformed by bones and skeletons) to be exported from 3ds Max to popular file formats such as Maya, Cinema-4D, LightWave, Collada, FBX, DirectX, U3D, etc..

Two deformation modifiers are supported for export: Character Studio 'Physique' modifier and the 3ds Max "Skin Modifier". These deformation modifiers allow a hierarchy of objects to deform a single mesh. In most cases, the deforming hierarchy of objects will either be a Character Studio "Biped" object or a hierarchy of 3ds Max Bone objects. However, both Physique and the 3ds Max "Skin Modifier" have the ability to use general 3ds Max objects as "bones" for skinning. PolyTrans will automatically tag objects used for skinning as "bones" when exporting (provided this option is enabled).

Remove Biped non-uniform scaling

In early versions, Character Studio used to store unnecessary scaling information in its Biped nodes. This scaling information was intended for internal Character Studio usage when visualizing Biped nodes inside 3ds Max. In early versions, this data was stored in the wrong matrix, which makes it highly visible to the export process. Recent versions of Character Studio have corrected this error, and Bipeds created with a recent Character Studio do not exhibit this unnecessary scaling data.

This extra scaling information is harmful to the export process. If a Biped with this extra scaling is exported blindly to another 3D software application it is sometimes found that the bones appear to be irregularly shaped. If a skinned model uses this Biped data for deformation, the model may look "skewed" or "skinny". This has been a common complaint of users exporting data from 3ds Max.

To overcome this nasty problem PolyTrans includes an intelligent export algorithm for Character Studio Biped data. It will remove the unnecessary scaling data without affecting the hierarchy below the Biped nodes. This will effectively fix the problem when the data is viewed in other 3D applications. Enabling this option will remove any unnecessary scaling from Biped nodes and solve this export problem.

Discard 'Footprint Nodes'

Character Studio Biped objects include "foot print" objects to show where the Biped object’s feet move during the animation. These foot print nodes are detected by the export process, but it is not possible to extract their internal data. The external data is useless to most, if not all, destination programs. By enabling this option the foot print objects will be ignored during export.

Ignore animation on skinned meshes

Programs such as Maya and DirectX ignore any animation on a skinned mesh object. This is because the ultimate location and deformation of a mesh is completely controlled by the skeleton of bones assigned to it (technically, the vertices of the mesh are transformed to "bone space" by the bind pose matrix then the current animated position of each bone transforms the mesh vertices to world-space, thus completely ignoring the current animated transformation of the mesh object).

However, 3ds Max allows animation to be applied to meshes associated with the SkinMod modifier (animation on skinned meshes in Character Studio are ignore). For example, you could deform a cylinder using two bones as well as animate the scale, position and rotation of the overall cylinder itself.

By turning on this option no animation will be exported for objects which are skinned with boning data. This is more of a visual convenience option since the DirectX, Maya, etc. destination programs will ignore the animation data anyway regardless of whether it is there or not.

Use Bone Stretch

When using pure "bones" in 3ds Max 4 or newer, each bone can have its length stretched by a user modified value. To view that stretch value for each bone choose the "Bone Tools" menu option from the main "Character" menu; the stretch value can be found in the "Object Properties" panel.

If this checkbox is enabled then the bone stretch value will be taken into account while exporting bones to the PolyTrans database. It will also enable per-frame keyframe animation resampling so that the bone stretching is properly captured into PolyTrans animation keyframe lists.

In general this option does not need to be enabled for most customer files for which bone stretching is 1.0.

It is highly recommended that you do not use bone stretching so that the exported bones are more compatible with downstream file formats. This can be done by selecting all the bones in your scene and pressing "Reset Stretch" or setting the "Stretch" radio button from "Scale" to "None" on the same "Bone Tools" dialog box mentioned previously.

-------------

In 3ds Max, "bone stretch" is a slightly different concept than "bone scaling," although both techniques can be used to arrive at similar effects.

"Bone scaling" describes the effect which occurs when the 'scale' portion of a bone's transform matrix is non-identity. This is the same as applying a scale factor to any node in 3ds Max, and is not unique to bones. "Bone scaling" is always supported by the PolyTrans-for-3dsMax plugin.

"Bone stretch" describes an effect specific to 3ds Max bones. A special stretch matrix is calculated, and it is applied after the regular node transformation matrix. This extra stretch matrix does not fully participate in the node transform hierarchy. Notice that because the "bone stretch" is part of a separate matrix, while "bone scaling" is part of the main transformation matrix, it is possible to have both "bone scaling" and "bone stretch" on a single bone. "Bone stretch" is only supported by the PolyTrans-for-3dsMax plugin when this checkbox is enabled.

Triangle Mesh

If this checkbox is checkmarked then mesh geometry will be exported from 3ds Max.

Mesh Normals

If this checkbox is checkmarked then vertex normals will be exported along with the mesh geometry.

Texture Coordinates

If this checkbox is checkmarked then (u,v) vertex texture coordinates will be exported along with the mesh geometry.

Vertex Colors

If this checkbox is checkmarked then all the colors assigned to each and every vertex will be exported along with the mesh geometry. Please note that color can only be assigned to a vertex if the parent object is in the form of an ‘Editable Mesh’ in 3ds Max (see 3ds Max online documentation). This checkbox is disabled by default because we wish to have the material definition set the color of each vertex by default.

Optimize Vertex Normal List

Optimize uv Texture Coordinate List

These options determine if redundant vertex normals or uv texture coordinate will be removed from the exported 3ds Max polygon mesh data after it has been sent to the internal PolyTrans database. These options are all enabled by default.

** Disable these options if exporting mesh morph targets. ** These options will most likely change the order of the coordinate lists and likewise the order of the index lists. Normally this is not a problem in scene conversion, but it can be a problem when mesh snapshots are being exported as morph targets (such as sending morph targets to LightWave).

Collapse All uv Map Channels to One uv Set

3ds Max allows multiple uv sets (or "UV Map Channels") per material, per polygon vertex. However, most 3D export file formats only allow a single (u,v) coordinate per polygon vertex.

If this option is enabled then the multiple sets of UV Map Channels assigned to a single mesh will be collapsed to a single set of uv coordinates. This operation will look at the "diffuse" channel of the associated material shader to find the Map Channels.

As an real example from one of our customers, let's say we have a mesh which is assigned 18 different materials on the various polygons. Each material's "diffuse" texture map of these 18 materials references one of 18 different UV Map Channels. This is an ideal case since there is no overlap or compounding of uv channels on a single polygon. In this case the 18 UV Map Channels will be collapsed down to a single set of unique, non-overlapping uv values per polygon vertex.

Output Polygons As: Triangles, Quads, N-Sided, Visible Edges

Internally, 3ds Max stores all mesh data as triangles. This is not good, however, for those who wish to have the data exported as quadrilaterals (quads), or in general polygons with as many vertices as possible (n-gons). Outputting quads rather than triangles to DirectX, for example, will speed up the DirectX redraw time since fewer vertices have to be shaded.

If the drop-down box is set to Triangles (the default) then no optimizations will be done. If set to Quads then an algorithm will be invoked so that 2 triangles which share one common edge will be exported as a quadrilateral. If set to N-Sided then the algorithm will try to piece together several adjacent triangles into one larger n-sided convex polygon. The "Visible Edges" option is the same as the "N-Sided" option except that any two triangles which have their "edge visibility" flag enabled in 3ds Max will not be coerced into one larger polygon (ie:. they will remain distinct and separate polygons).

Enables Panel # 2

Flip from "Z" up to "Y" up Coordinate System (the default)

The default for this checkbox is "enabled" (checkmarked) so that the Z-up coordinate system of 3ds Max is converted to the Y-up coordinate system of Okino's PolyTrans scene graph database. All PolyTrans import and export converters perform their operations in an explicit Y-up coordinate system, so keeping this checkbox enabled will provide you with normal and accepted operation.

However, you may want to export a scene from 3ds Max to Maya, for which you have changed Maya's native and default Y-up coordinate system to Z-up. In such a case you can disable this checkbox so that no flipping of coordinates occurs. This assumes you are saving out an Okino .bdf file then loading that file into Maya using Okino's PolyTrans-for-Maya native plug-in system.

Spline/Linear Shapes and Curves

If this checkbox is checkmarked then 3ds Max spline based shapes, if they can be converted to Bezier or linear splines, will be exported as equivalent Bezier or linear spline shapes. In the internal PolyTrans/NuGraf geometric database the ‘SplineShape’ primitive will be used to store the 1 or more grouped Bezier/linear splines that comprise the shape.

Output non pure-Mesh Geometry Objects

If this checkbox is checkmarked then geometric objects will be exported as meshes. Basically this means that any geometric object which exists in the 3ds Max stack, and which is not a mesh object, will be asked to be converted into an explicit mesh object prior to export.

Grouping & Helper Nodes

If this checkbox is checkmarked then any objects or nodes inside 3ds Max which are grouped together (under a ‘dummy’ node) will likewise be grouped together when exported. This is only applicable when the ‘Object Hierarchy’ checkbox is enabled as well.

Cameras/Lights

If this checkbox is checkmarked then lights and cameras will be exported.

Preserve Geometry Instancing

If this checkbox is checkmarked then geometry which is instanced multiple times will be exported to the Okino PolyTrans scene database as Okino-specific geometry instancing.

If this checkbox is disabled then no instancing will be exported. All geometry which has been instanced multiple times will be exported as explicit geometry copies. For example, a screw which has been instanced 100 times will be exported as 100 explicit geometry copies.

Node-Level Custom Properties

If this checkbox is checkmarked then user-defined custom properties on each node will be exported from 3ds Max to Okino per-instance meta data. These custom properties can be accessed within 3ds Max from the "Edit / Object Properties" dialog box, on the "User Defined" panel.

File & Scene-Level Custom Properties

If this checkbox is checkmarked then well known 3ds Max "File and Scene Level" custom properties will be exported as Okino scene-level meta data. These custom properties are found on the 3ds Max "File / File Properties" dialog box, on the "Summary" and "Custom" panels.

Materials

If this checkbox is checkmarked then materials will be exported along with any associated texture maps.

Renormalize Ambient/Diffuse Colors

This is a special kludge in the exporter to create two special ‘shading coefficients’ that are often required in other 3D rendering packages, but which are lacking in 3ds Max. These shading coefficients are typically known as the ‘ambient shading coefficient’ and the ‘diffuse shading coefficient’. They basically control the final intensity of the ambient and diffuse shading on a material. In 3ds Max, the intensity of the ambient and diffuse shading is controlled by changing the relative intensities of the ambient and diffuse surface colors directly (ie: if the diffuse color in the 3ds Max material editor is (255,0,0) and you wish to make it half as bright, then you would change the color to (128,0,0)). In other 3D rendering programs you could either modify the colors directly (as you do in 3ds Max) or you could modify the shading coefficient values (in our example here, you could keep the diffuse color the same at (255,0,0) but drop the diffuse shading coefficient by 50% in intensity).

If this option is enabled, then ambient and diffuse shading coefficients will be extracted from the 3ds Max ambient and diffuse material colors. The 3ds Max ambient and diffuse material colors will be subsequently modified as well, such that multiplying the new shading coefficients by the modified material colors will result in the original 3ds Max material colors. This is the default option.

If this option is disabled, then the ambient and diffuse shading coefficients will be set to 1.0 (100%) and the 3ds Max ambient and diffuse materials colors will be exported with no modifications. If you find that the exported data in the destination rendering program looks too dark or bright, or you simply don’t want this exporter to modify the material colors, then disable this option.

Append "(sub)" To Sub-Material Names

If this checkbox is checkmarked then any "sub-materials" exported from 3ds Max will be suffixed with the tag "(sub)" to differentiate them from top-level mesh materials. This is the default.

If the checkbox is disabled, then no "(sub)" will be suffixed onto material names.

NOTE: FYI, 3ds Max allows one or more material names all to be the same. A material inside of 3ds Max is only unique by its internal pointer and not its name.

Force Metal Shading Mode

This is a special kludge option used to control the accuracy of rendered highlights when a file is exported for ultimate destination to a .3ds file. If this checkbox is enabled then the PolyTrans internal ‘metal’ shading coefficient will be forced to be 0.86 during export - then, if the PolyTrans database is exported to a .3ds file the 0.86 value will force all .3ds materials to use the METAL shading mode. We originally forced metal shading mode to provide good "Load and Render" conversions in which the color of the resulting rendered materials closely matched those of the source program (beit NuGraf or 3ds Max).

If this checkbox is unchecked then the METAL shading mode will not be forced on during export to the .3ds file format (the PolyTrans ‘metal’ shading parameter will be set to 0.0).

Texture Crop Window Values

This option allows the ‘Crop Window’ values of a 2d bitmap texture to be exported from 3ds Max. These crop window values are not used by any of the PolyTrans export converters except for the DirectX export converter - this option was added to overcome a very specialized conversion case of a 3ds Max user.

This option is necessary because it is not possible for the PolyTrans export plug-in to access the enable/disable (‘Apply’) checkbox on the ‘Bitmap Parameters, Cropping/Placement’ section of the 2D bitmap panel inside 3ds Max (where the crop window values are located). Thus, this checkbox controls whether the crop window values should be output or not, regardless of the state of the ‘Apply’ check box. The checkbox should always be disabled by default.

Output Blinn Shaders as Phong Shaders

Specular highlights on objects are often simulated in 3D computer graphics using one of two mathematical techniques, either that of "Phong Highlights" or "Blinn Highlights". By far Phong is the most common used in every 3D software package while Blinn is much more rare. Thus, by default, this option is enabled so that any shaders inside 3ds Max which use Blinn specular highlights are explicitly output instead as Phong specular highlights so that they are compatible with most destination 3D file formats and programs. However, if you are exporting to programs such as Maya, which can accept Blinn highlights, then disable (turn off) this option so that Blinn highlights are output to the PolyTrans core database as pure Blinn highlights.

Confirm Potential File Overwrites

If this checkbox is enabled then a dialog box will prompt you if a file already exists on disk with the same filename that you are currently exporting to. You have the option at this point of choosing a new filename or pressing the "Cancel" button on the file selector. If this checkbox is disabled then all existing files will always be overwritten with no user confirmation.

Output One File Per Frame

This option basically provides a mechanism to output complete animated scenes to one or more physical files on disk. For example, this option can be used to output meshes with animated vertex locations and/or NURBS surfaces with animated CV locations to one or more Renderman RIB files, Collada, FBX or Presagis FLT files (as typical production examples).

Please note that this option does not output keyframe animation data. Rather, the scene is evaluated at the specific frame numbers inside 3ds Max and a physical copy of the evaluated scene is output to multiple exported files on disk. Compare this to true keyframe animation output in which the keyframe lists are sent from 3ds Max to the PolyTrans internal database, then PolyTrans outputs a single file with the lists of keyframes attached to their respective objects/cameras/etc. The benefit of multiple files is that morphed and/or animated geometry can be output to disk, whereas in keyframe animation output mode only rotate/scale/translate transformations can be applied to each object as a whole.

For this option to work properly, you must disable all animation output checkboxes on export file format dialog box (the last dialog box to appear during the export process). This might be, for example, the Renderman RIB export options dialog box, the Collada export options dialog box or the LightWave export options dialog box. If you do not disable animation output on these dialog boxes then each physical file written to disk will also contain a complete list of animation keyframes.

The options Start frame #, End Frame #, and Every Nth Frame define the interval of animation frames inside 3ds Max to output. The last parameter controls the sub-set of frames to render. If set to 0, 100, 1 then all frames from 0 to 100 will be output. If set to 0, 30, 10 then frames 0, 10, 20 and 30 will be output (every 10th frame will be output).

Animation Panel

Global Animation Export Enable

If this option is enabled (check marked) then all of the animation options can be accessed. Turning this option off (disabled) is a simply way to quickly disable all animation export from 3ds Max.

Object Animation

If this option is enabled (check marked) then object animation will be output. The definition of "Object Animation" is changes to the object's location, orientation or size based on explicit changes to the object's transformation matrix. Thus, if the transformation matrix of an object changes from frame to frame, and that matrix represents the animation for the object, then that animation can be converted to explicit scale, rotation and translation keyframes lists for other animation packages.

Camera Animation

If this option is enabled (check marked) then camera animation will be output. The definition of "Camera Animation" is changes in the camera's explicit location, look-at location, roll vector (up direction) or field of view. Only targeted cameras are supported and not "free cameras".

Light Animation

If this option is enabled (check marked) then camera animation will be output. The definition of "Light Animation" is changes in the light's explicit location, shine-at location (or shine direction for directional lights), intensity, or cone angle (for spot lights).

Material Animation

If this option is enabled (check marked) then material animation will be output. The definition of "Material Animation" is changes in the material's ambient, diffuse, specular and luminous colors, as well as opacity are all supported.

Use keyframe sampling mode for all animation

3ds Max allows both explicit keyframe animation and procedural controller animation. Procedural animation is where the animation occurs under control of an algorithm that is updated and modified on a frame by frame basis (no keyframe data is used).

If this checkbox is disabled then this exporter will output keyframe data exactly as it is defined inside 3ds Max to the PolyTrans internal database. If a procedural animation control is encountered, or if PolyTrans detects interfering factors such as timing channels, then PolyTrans will sample the output of the controller at every frame and turn that data into optimized explicit keyframe data.

If this checkbox is enabled then this exporter will ignore all explicit keyframe data. Instead, it will sample the output of the animation controller at every frame and turn that data into optimized keyframe data. This export option is preferable, unless you know that your export target supports TCB and Bezier keyframes and uses the same interpolation methods as 3ds Max.

Frames to Output

If the "Use keyframe sampling mode for all animation" option is enabled then the following two radio buttons determine over which time interval the animation data will be resampled.

Time Slider (Frames)

The frame selection will be taken from the current start/end extents of the animation timeline on the 3ds Max user interface. Animation will be resampled and output from the first to last frames.

From # to #

The frame selection will be chosen by the two user specified values. Animation will be resampled and output from the first to last frames.

Warn when having to revert to sampled-mode

This exporter will attempt to output animation keyframe data explicitly with no changes to the internal PolyTrans database. However, 3ds Max provides procedural animation controllers, timing channels, Bezier tangent handles with non-unity lengths, etc. all of which have no relation outside of 3ds Max. Thus, this exporter will use explicit keyframe resampling (see above) to "capture" this non-standard animation into normal animation keyframe channels.

If this option is enabled then a verbose amount of text will be displayed which describes which objects required keyframe resampling mode during the export process, and why each object required keyframe resampling mode.

Perform keyframe reduction

Due to the method in which the matrices are decomposed into explicit scale, rotation and translation keyframes lists, one keyframe per frame, the exported keyframe animation lists can have an overabundance of keys defined.

If this option is enabled then an algorithm will be applied to the new exported keyframe lists to reduce the number of redundant keys. The type-in values determine the threshold criteria for keeping or removing a key from a list.

If this option is disabled then no keyframe reduction will be done. If you want very accurate animation export then do not enable this option, or else keep the threshold values at minimum values to keep the degree of reduction low.

Distance Threshold

This numeric value indirectly controls how many redundant keyframes are to be removed from the re-sampled keyframe list. Higher values will cause more keyframes to be removed. This value is the maximum ‘distance’ the new keyframe list is allowed to deviate from the original re-sampled keyframe list. Take for example a sphere that is animated along a path; if this threshold value is set to 0.5 distance units (which is the default) then redundant keyframes of the animated path will be removed until such point that the sphere begins to deviate by more than 0.5 units from its ‘ideal’ location. In other words, if the value is set to 0.5 then you are guaranteed that the new reduced keyframe list will move the sphere along the same path in space, except that the sphere is allowed to deviate by 0.5 units from its original path. Smaller numbers will make the sphere adhear closer to its original path, but at the expense of retaining more keyframes.

Angular Threshold (degrees)

This is the same as the previous numeric value except that it applies to reduction of quaternion and Angle/axis rotation keyframe lists. The value is measured in degrees. For example, if set to 5.0 (the default) then redundant keyframes will be removed from a keyframe list until such point that a rotation angle begins to deviate from its ideal angle by more than 5 degrees. Small numbers (such as 1.0 and 0.5) will cause less deviation and more precise rotation conversions, but at the added expense of retaining more keyframes.


Exporting Skeleton Deformation Data ("Skinning") From 3ds Max (SkinMod And Character Studio Meshes)

Skeletal Deformation Overview

PolyTrans supports skeletal deformation, or "skinning", of polygonal objects. This section describes the general limitations imposed by PolyTrans in an attempt to provide a common basis for conversion between 3D packages. These limitations can be expressed by the following rules:

· NURBS objects cannot be deformed.

· Deformations by any method other than bones and skeletons are not supported (such as morph targets or Maya Clusters).

· "Nested" deformations are not allowed (deformations that follow one another).

NURBS Objects

In general, it is not possible to convert a skinned NURBS object into a skinned polygon object. When performing the mesh tessellation, new vertices will typically be generated. It is not mathematically possible to assign weights to these new vertices in a way which would preserve the pre-tessellation behavior of the skinned NURBS object. Rather than generating garbage weights, PolyTrans will discard all weighting data and generate a warning.

Non-Supported Deformation Types

Converting raw deformation data relies on the existence of a common deformation algorithm, available to many platforms. This is the algorithm supported by the Okino conversion pipeline, and described as "skinning."

Deformations which do not follow this algorithm cannot currently be exported through PolyTrans. These include:

· Maya "cluster" objects. In Maya, you must perform skinning using the "skincluster" or "jointcluster" dependency node types, not the "cluster" dependency node type. "Clusters" by themselves are sort of like independent handles on mesh vertices; two clusters affect the mesh in an accumulated fashion rather than in a weighted fashion in rigid/smooth bindings.

· Lattice-based deformations.

· Morph target deformations.

· Any other deformations types in 3ds Max other than the SkinMod or Character Studio Physique modifiers.

Nested Deformations

Simply put, a nested deformation occurs when an already-deformed mesh is used as the input to another deformation algorithm. To provide the best "common denominator" for conversion, PolyTrans does not allow nested deformations. This limitation is quite common for export formats where the primary goal is real-time playback.

By contrast, systems such as 3ds Max and Maya freely allow deformations to be nested. PolyTrans handles these common nested-deformation scenarios in the following ways:

· In 3ds Max, multiple SkinMod or Physique modifiers can be contained in an object’s modifier stack. This produces (generally) a non-linear result which cannot be replicated in a single layer of deformation. The top-most skinning modifier is exported as a deformation, and a static snapshot of the underlying modified object is taken at the "reference" time. (The reference time is either the first frame of animation, or the reference frame specified by the SkinMod modifier).

· In Maya, "cluster" deformations are a special type of deformation which are intended to be used in a nested manner. A "cluster" attached before regular skinning will have a completely different effect from a "cluster" attached after regular skinning. As such, PolyTrans cannot fold "clusters" into the normal skin deformation. They are discarded, and a warning message is generated.


Supported Parameter Conversions and Mappings

This section describes which 3ds Max entities are exported to the PolyTrans converters.

Polygon Geometry

3ds Max inherently handles all polygon data as triangular meshes. Hence, all polygonal data exported from 3ds Max will be triangles. If you perceive that the data is quads then what you are actually seeing are triangles with hidden edges.

If multiple materials are assigned to a mesh then they will be exported as materials assigned to each polygon, else a single material will be assigned to the object. If no 3ds Max material is assigned to an object then one is created and exported which uses the wireframe color of the object.

The following object attributes will be exported along with the basic mesh geometry:

· Vertex normals

· Vertex (u,v) texture coordinates

· Vertex colors.

· ‘Casts Shadows’ flag

· ‘Receive Shadows’ flag

· ‘Is Hidden’ flag.

· ‘User Defined’ meta data tags

Material Assignments on Mesh Geometry

3ds Max provides for a wide variety of material plug-ins to be assigned to an object or to a polygon of a mesh. The following material classes are recognized:

1. ‘Multi-Sub’. One or more materials are assigned to the polygon mesh. If each material is a 3ds Max ‘standard material’ then the multi-sub is exported to the best extent possible.

2. ‘Top/Bottom Material’. Only the first material will be exported.

3. ‘Double Sided Material’. Only the first material will be exported.

4. ‘Mix (Blend) Material’. Only the first material will be exported.

5. ‘Standard Material’. It will be exported to the best extent possible.

6. ‘Unknown Material’. This is a custom material plug-in, such as Lightscape. As many of the basic material parameters will be exported.

7. Please refer to the "Non-Standard Material Output" section for further information.

Cameras

The following camera types and camera parameters are converted:

3ds Max Entity | Converted PolyTrans Entity
Targeted camera | Targeted camera
Free camera | Targeted camera
Field of view and lens | Window width and height
Hither & yon clipping | Hither & yon, if manual clipping enabled, else ignored.

Lights

The following light types and light parameters are converted:

3ds Max Entity | Converted PolyTrans Entity
Omni light | Point light
Targeted spot light | Targeted spot light
Free spot light | Targeted spot light
Directional light | Directional light
Targeted directional light | Directional light
Color | RGB color
On/Off | Enabled
Intensity | Intensity
‘Affect Diffuse’ | Diffuse Enabled
‘Affect Specular’ | Specular Enabled
Shadow mapped shadows | Shadow mapped shadows
Ray traced shadows | Ray traced shadows
Hot size (spot light) | Delta angle (spot light)
Fall off (spot light) | Cut off angle (spot light)
Use Atten + start + end | Distance, decay, divisor (calculated)
Map bias | Bias0 = Bias, Bias1 = Bias + 0.3
Range | ResFactor
Shadow map size | Shadow map size
Use global | Use global values

Ignored light parameters:

· ‘Exclude’ light list.

· Orientation parameters for projectors.

· Overshoot toggle

· Projector options.

· Ray trace bias.

· ‘Absolute map bias’.

Materials

3ds Max has a very rich set of material attributes of which most of the standard shading parameters can be exported to the PolyTrans material database:

3ds Max Material Parameter | Converted PolyTrans Material Parameter
Ambient color | Converted to normalized ambient color and weighted ambient shading coefficient.
Diffuse color | Converted to normalized diffuse color and weighted diffuse shading coefficient.
Specular color | Converted to normalized specular color and weighted specular shading coefficient.
Filter color | Not converted
Lock ambient + diffuse | Lock ambient + diffuse
Lock diffuse + specular | Lock diffuse + specular
Shading model | Constant -> Flat, Phong -> Phong. ‘Metal’ mode simulated in PolyTrans by using Phong mode, doubling the Phong power, setting metal mode =1, doubling the specular intensity and halving the diffuse intensity.
2-sided | Ignored. No material equivalent in PolyTrans (2-sided is an object attribute).
Wire shader | Parameters mapped over to the PolyTrans ‘wireframe’ shader.
Face map | Not converted.
Specular level | Specular shading coefficient.
Glossiness | Remapped to an equivalent Phong power value with similar characteristics.
Self-illumination | Luminous shading coefficient.
Opacity | Face and reflect opacity.
Soften flag | Not converted.
Inside transparency | Mapped to equivalent ‘edge’, ‘face’ and ‘reflect’ opacity parameters.
Outside transparency | Mapped to equivalent ‘edge’ oapcity parameters.
Transparency type | Not converted
IOR (index of refraction) | IOR (index of refraction)

Texture Maps

3ds Max has a very extensive array of plug-ins that can feed RGB texture data to a material shader. For the purpose of conversion only 2D bitmap textures are converted (no custom shaders like MentalRay scripts, etc), no 3d procedurals, no PhotoShop plug-ins and no gradients).

The following are the various texture modulation methods supported and their equivalent texture modulation method in PolyTrans. If a material has more than one texture map enabled then each will be converted to a different ‘texture layer’ within PolyTrans:

3ds Max Texture Map | Converted PolyTrans Texture Map
Ambient map | Ambient color texture map
Diffuse map | Diffuse color texture map
Specular map | Specular color texture map
Shininess map | Reflection opacity texture map
Shininess strength map | Specular coefficient texture map
Self illumination map | Luminous coefficient texture map
Opacity map | Opacity texture map
Filter color | Not converted
Bump map | Bump map
Reflection environment map | Spherical reflection map
Refraction map | Not converted

As for the texture definition itself, the following 2d bitmap texture parameters are supported:

3ds Max Texture Parameter | Converted PolyTrans Texture Parameter
u & v tiling | u & v repeat
u & offset (relative to center of texture map). | u & v offset (relative to lower left corner of texture map).
Texture strength | Texture mixing values
u & v tile flags | u & v wrap flags
Angle | Not converted
Blur | Not converted
Blur offset | Not converted
Mirror | Not converted

Non- "Standard Material" Output

3ds Max is based on the newer concept of materials being "black box" plug-ins, that can basically do whatever they want, as long as they output a final RGB pixel color. Unfortunately PolyTrans-for-3dsMax, and no exporter for 3ds Max, can always access these "black boxes" and acquire all of their material shading parameters, and texture maps, unless an exposed and published programming interface is provided by such black-box material shader plug-ins.

In basic terms, PolyTrans-for-3dsMax can always access and output "Standard Materials", as documented in the charts above. If you use any other types of shaders within 3ds Max then you will either have to change them over to "Standard Materials" or use a script such as "MultyConverter" to map the parameters of your unique shader over to parameters of a "Standard Material".

However, Okino has taken good effort to output some commonly needed material or texture mapping data from V-Ray, RayTrace, Mental Ray and DirectX HSLS shaders.

V-Ray, "VRayMtl" Shader

V-Ray is a popular third party plug-in renderer for 3ds Max by the Chaos Group. There are 12 specialized material shaders which are provided with V-Ray. PolyTrans-for-3dsMax has been augmented to export specific parameters from the key and main "VRayMtl" shader.

V-Ray Material Parameter | Converted PolyTrans Material Parameter
Diffuse color | Converted to normalized diffuse color and weighted diffuse shading coefficient.
Reflect color | Converted to normalized specular color and weighted specular shading coefficient.
Reflection glossiness | Remapped to an equivalent Phong power value with semi-similar characteristics.
Refraction RGB color | The average of the RGB colors are taken and fed into the "opacity"
IOR (index of refraction) | IOR (index of refraction)

The following texture map slots are supported from the VRayMtl shader and only when the texture map is a "Bitmap" shader. The filename, on/off state and intensity of the bitmap parameters of the shader are exported.

V-Ray Texture Map | Converted PolyTrans Texture Map
Diffuse map | Diffuse color texture map
Reflect map | Specular color texture map
Opacity map | Opacity texture map
Bump map | Bump map
Environment map | Spherical reflection map

Mental Ray "Standard" Shader

MentalRay shaders, like most shaders which come with 3ds Max, cannot be supported. They are like little custom programs which compute pixel shader colors on the fly using non-exposed and custom input parameters.

PolyTrans-for-3dsMax does support one single mapping parameter from the standard "Mental Ray" shader which is a bitmap image attached to the "Basic Shaders, Surface" channel. Only the bitmap filename and its on/off state can be accessed and output.

The remainder of material shading values (such as diffuse/specular colors, opacity, shininess, etc) are taken from the same value which the 3ds Max "interactive" (viewport) renderer would normally use.

"Arch+Design" Shader

The "Arch+Design" shader, as described by its developer, is a "monolithic material shader that is designed to support most materials used by architectural and product design renderings.". It has accessible parameters which are similar to the 3ds Max "Standard" material and hence some are chosen and exported by the PolyTrans-for-3dsMax export code.

"Arch+Design" Material Parameter | Converted PolyTrans Material Parameter
Diffuse color | Converted to normalized diffuse color and weighted diffuse shading coefficient.
Diffuse level | Multiplied into the diffuse color
Reflected color | Converted to normalized specular color and weighted specular shading coefficient.
Refraction transparency | Inverted into face and reflect opacity
Reflectivity | Specular shading coefficient.
Reflection gloss | Remapped to an equivalent Phong power value with similar characteristics.
IOR (index of refraction) | IOR (index of refraction)

The following texture map slots are supported from the "Arch+Design" shader and only when the texture map is a "Bitmap" shader. The filename, on/off state and (optional) intensity of the bitmap parameters of the shader are exported.

"Arch+Design" Texture Map | Converted PolyTrans Texture Map
Diffuse color map | Diffuse color texture map
Reflection color map | Specular color texture map
Self illumination color map | Luminosity color texture map
Bump map | Bump map
Environment map | Spherical reflection map

3ds Max "Raytrace" Shader

The "Raytrace" shader is an older, built-in shader that has come with 3ds Max for many years. It is a non-standard material and hence requires special output handling for its non-published shader interface. The Raytrace material is an advanced surface-shading material. It supports the same kinds of diffuse surface shading that a standard material does.

Raytrace Material Parameter | Converted PolyTrans Material Parameter
Ambient color | Not converted because the ambient color in the 3ds Max raytrace material acts as an "absorption factor" and not an emissive factor.
Diffuse color | Converted to normalized diffuse color and weighted diffuse shading coefficient.
Specular color | Converted to normalized specular color and weighted specular shading coefficient.
Filter grayscale value or RGB color | Face and reflect opacity
Specular level | Specular shading coefficient.
Glossiness | Remapped to an equivalent Phong power value with similar characteristics.
Self-illumination grayscale value or RGB color | Converted to normalized luminous color and weighted luminous shading coefficient.
IOR (index of refraction) | IOR (index of refraction)

The following texture map slots are supported from the Raytrace shader and only when the texture map is a "Bitmap" shader. The filename, on/off state and intensity of the bitmap parameters of the shader are exported.

Raytrace Texture Map | Converted PolyTrans Texture Map
Ambient color map | Ambient color texture map
Diffuse color map | Diffuse color texture map
Specular color map | Specular color texture map
Specular level map | Specular color intensity texture map
Luminosity color map | Luminosity color texture map
Transparency map | Transparency texture map
Bump map | Bump map
Environment map | Spherical reflection map

DirectX "HLSL" Shaders

DirectX HLSL shader export is specialized when exporting from 3ds Max to the Okino DirectX 3D exporter only. You would assign a "DirectX Shader" as a material within 3ds Max. From that shader the "FX Shader" reference would be passed through and output to the DirectX file as a "EffectInstance" reference.

NOTES:

1) The basic exported material properties (such as the diffuse/specular/emissive colors and opacity) and the name of the material will come from the "Software Render Style" material (the sub-material associated with the DirectX shader).

2) As a general note of interest, the FX shader information is passed from 3ds Max through Okino software via metadata assigned to each exported material definition.

Output FX shader parameter list

The parameter list associated with a FX file will also be output to the DirectX file, as shown below:

Material StandardFX_renderstyle__sub_ {

0.588000;0.588000;0.588000;1.000000;;

3.000000;

0.000000;0.000000;0.000000;;

0.000000;0.000000;0.000000;;

EffectInstance {

"StandardFX.fx";

EffectParamFloats {

"k_a";

4;

0.000000, 0.000000, 0.000000, 1.000000;

}

EffectParamDWord {

"n";

15;

}

EffectParamDWord {

"g_AlphaVertex";

1;

}

EffectParamString {

"Tex0";

"tiger.bmp";

}

}

}

Mesh Skinning

Mesh skinning is the deformation of a single skin mesh by a deformer, either the "SkinMod" modifier or Character Studio.

See also:

Notes and limitations about exporting skeleton deformation data (skinning) from SkinMod and Character Studio

Spline/Linear Shapes and Curves

3ds Max spline based shapes, if they can be converted to Bezier or linear splines, will be exported as equivalent Bezier or linear spline shapes. In the internal PolyTrans/NuGraf geometric database the ‘SplineShape’ primitive will be used to store the 1 or more grouped Bezier/linear splines that comprise the shape.

Animation Conversion

Animation conversion is one of the most heavily developed aspects of Okino’s software, in particular within 3ds Max. PolyTrans-for-3dsMax does not simply export the raw 3ds Max animation data, but it allows deep resampling (to "capture" the animation data properly), removal of the problematic "off-axis" scaling unique to 3ds Max, fixing of Euler rotation problems, and many other oddities which would otherwise trip up a 3d exporter.

Exported Object Animation Channels

Scale as explicit X,Y, Z animation channels

Euler rotations as explicit X,Y, Z animation channels.

Quaternion rotation as a single channel relative quaternion channel.

Translation as explicit X,Y, Z animation channels

Object pivot points

Procedural animation is sampled per frame and converted to keyframes.

Exported Camera Animation Channels

Translation as explicit X,Y, Z animation channels

Look-at location as explicit X,Y, Z animation channels

Field-of-view

Bank angle around the Z axis

NOTE: Light & material animation is only converted over to select file formats or packages, as this is the newest addition to the PolyTrans-for-3dsMax converters.

Exported Light Animation Channels

Translation as explicit X,Y, Z animation channels

Orientation as explicit X,Y, Z Euler or quaternion rotation animation channels (for directional lights).

Light color (use the light color to animate the intensity of the light source)

Exported Material Animation Channels

Ambient, diffuse, specular, luminous and filter colors

Face opacity.

Entities Not Exported

· Trimmed NURBS. This code was developed in 1998 but it has not been supported nor released due to API problems with 3ds Max (mostly due to trimming curves).

· Planar and cubical environment maps.


PolyTrans Import Converters for 3ds Max

Click here to learn how to import objects into 3ds Max using the PolyTrans plug-in.

The following sections describe the options on the ‘PolyTrans to 3ds Max’ dialog box:

"Mesh" options

"Bitmap Conversion" options

"Enables" options

"Enables # 2" options

"Enables # 3" options

"Animation" options

"Animation resampling and reduction" options.

Invoking PolyTrans via MaxScript or the 'Function Publishing System'

Also, the mapping from the PolyTrans internal database to the 3ds Max internal database is described by clicking here.

Click here to jump to the table of contents for this help file.


Import Conversion Process

The import process proceeds as follows:

1. The user presses the [image] icon on the 3ds Max user interface to cause the utility panel to be displayed.

2. If the "PolyTrans I/O Converters" button is not visible on the utility panel, as shown below, click on the button located to the right of the "Sets" button. After the dialog box appears, link the "PolyTrans I/O Converters" utility plugin entry to one of the empty button slots.

3. Click on the "PolyTrans I/O Converters" button that should now be visible on the 3ds Max utility panel (shown above).

4. Click on the "Import" tab located just above the list box containing the import/export converters:

5. If you wish to modify the import options prior to starting one of the import converters then press the "Import Options" button located below the listbox. The "PolyTrans to 3ds Max" dialog box will appear. These options control how the scene data will be imported into the 3ds Max internal database from the PolyTrans internal database. Press "Ok" to continue.

6. Click on one of the import converters listed in the listbox. A filename selector will appear with which you can choose the filename(s) to import. Note that one or more files can be imported at the same time.

7. After the filename selector goes away, the scene data is sent from the PolyTrans internal database to the 3ds Max internal database.

8. The corresponding PolyTrans import converter DLL is then loaded and executed. The data will then be imported from the PolyTrans internal database to the 3ds Max database.


Supported Parameter Conversions and Mappings

This section describes which PolyTrans database entities are imported into the 3ds Max database:

Entities Not Imported

· Trimmed NURBS. This code was written in 1998 but will not be supported or released by Okino due to the unstable nature of importing trimmed NURBS into 3ds Max via the 3ds Max SDK interfaces.

· Planar and cubical environment maps. At the moment only spherical reflection maps are imported.

Polygon Geometry

All PolyTrans geometry, including n-sided polygon meshes with recursive holes, trimmed NURBS surfaces, bicubic patches and quadric surface will all be triangulated prior to import into 3ds Max. The triangulation is necessary because triangle meshes are the core geometric primitive in 3ds Max.

Please note that 3ds Max internally is geared towards the usage of ‘smoothing groups’ to make objects appear smooth whereas almost all other 3d modeling packages allow 1 or more vertex normals to be assigned to each polygon vertex. While 3ds Max allows a single vertex normal to be assigned to a polygon vertex, it does not properly allow more than 1 vertex normal to be assigned to a single polygon vertex (multiple vertex normals are deleted prior to a rendering process and replaced with single normals computed from smoothing groups). This is a problem when importing meshed data that has very long and thin triangles, at obtuse angles, such as that from STL data. PolyTrans makes a good attempt to overcome the lack of multiple vertex normals by computing proper smoothing groups and toying with the vertex normals. It is hoped that future versions of 3ds Max will provide a method to associate 2 or more vertex normals with a single polygon vertex.

The following PolyTrans object attributes will be imported along with the mesh geometry:

· Vertex (u,v) texture coordinates

· Vertex colors.

· ‘Casts Shadows’ flag

· ‘Receive Shadows’ flag

· ‘Hidden’ flag.

And these are the currently unsupported PolyTrans geometric attributes:

· U/V tangent vectors are not imported. There is no equivalent in 3ds Max.

In addition, the import plug-in allows the following geometric processing functions to be applied to the imported mesh geometry:

· Flip orientation of all normals.

· Unify the orientation of all polygons and normals.

· Weld all vertex coordinates and vertex normals together using a specified tolerance.

Cameras

The following camera types and camera parameters are converted:

PolyTrans Camera Parameter | Imported 3ds Max Parameter
Targeted camera | Targeted camera
Window width and height | Field of view

Lights

The following light types and light parameters are converted:

PolyTrans Camera Parameter | Imported 3ds Max Parameter
Point light | Omni light
Targeted spot light | Targeted spot light
Directional light | Directional light
RGB color | Color
Enabled | On/Off
Intensity | Intensity
Diffuse Enabled | ‘Affect Diffuse’
Specular Enabled | ‘Affect Specular’
Shadow mapped shadows | Shadow mapped shadows
Ray traced shadows | Ray traced shadows
Delta angle (spot light) | Hot size (spot light)
Cut off angle (spot light) | Fall off (spot light)
Not converted | Use Atten + start + end
Not converted | Map bias
Not converted | Range
Not converted | Shadow map size
1.0 | Aspect
0.0 | Overshoot
TRUE | Use global

Materials

The following table describes how the PolyTrans material parameters are mapped to equivalent material parameters in 3ds Max:

PolyTrans Material Parameter | Converted 3ds Max Material Parameter
Ambient color and ambient coefficient | Depending on ‘lock ambient’ flag, ambient coefficient multiplied by ambient color or the diffuse color.
Diffuse color and diffuse coefficient | Diffuse color multiplied by the diffuse shading coefficient.
Specular color and specular shading coefficient | Depending on ‘lock specular’ flag, specular coefficient multiplied by soecular color or the diffuse color. If ‘metal’ value < 0.2, and specular lock off, then specular color set to white.
Lock ambient + diffuse | Lock ambient + diffuse
Lock diffuse + specular | Lock diffuse + specular
Flat shading model | Constant shading model
Gouraud shading model | Phong shading model
Phong shading model | Phong shading model
Phong shading model with ‘metal’ coefficient set > 0.9 | Metal shading model
Dialog box option | 2-sided
PolyTrans ‘wireframe’ shader. | Not converted.
No equivalent. | Face map
Specular shading coefficient. | A reweighted shininess strength.
Phong power. | Mapped to a logarithmic equivalent.
Luminous shading coefficient. | Self-illumination
Face opacity. | Opacity
Reflect opacity. | No equivalent
No equivalent. | Soften flag
No equivalent | Inside/outside transparency
IOR (index of refraction) | IOR (index of refraction)
Pass-to-children flag | No equivalent
Blinn shading model | No equivalent
Compute fresnel reflections flag | No equivalent

Texture Maps

The following are the various PolyTrans texture modulation methods supported and their equivalent texture modulation method in 3ds Max.

PolyTrans Texture Map | Imported 3ds Max Texture Map
Ambient color texture map | Ambient map
Diffuse color texture map | Diffuse map
Specular color texture map | Specular map
Not converted | Shininess map (phong power)
Specular coefficient texture map | Shininess strength map
Luminous coefficient texture map | Self illumination map
Opacity texture map | Opacity map
Not converted | Filter color
Bump map | Bump map
Spherical reflection map | Reflection map
Not converted | Refraction map

As for the texture definition itself, the following 2d bitmap texture parameters are supported:

PolyTrans Texture Parameter | Imported 3ds Max Texture Parameter
u & v repeat | u & v tiling
u & v offset (relative to lower left corner of texture map). | u & offset (relative to center of texture map).
u & v wrap flags | u & v tile flags

If one or more of the same type of PolyTrans texture maps (ie.: diffuse color) are assigned to the same material slot in 3ds Max, then all the same texture maps are corralled together using a ‘COMPOSITE’ texture shader. The mixing between the various texture maps of the composite shader is set via the ‘mix’ values obtained from the PolyTrans multi-layer texture mapping system.

Mesh Skinning

"Mesh skinning" is the process of deforming a single skin mesh with a skeleton or any hierarchical set of transform nodes. The contribution of each bone of the skeleton to the deformation of a vertex in the mesh is controlled by vertex weights.

"Skinned meshes" will be imported into 3ds Max using the "SkinMod" modifier. A hierarchy of 3ds Max bones will be created then linked to a single-skin mesh using the SkinMod modifier, for 3ds Max 4.2 or newer.

Animation Conversion

The following are the animation channels converted from other software packages into 3ds Max, via the PolyTrans core animation conversion engine.

Converted Object Animation Channels

Scale as explicit X,Y, Z animation channels or a single triple-component controller.

Euler rotations as explicit X,Y, Z animation channels, or as a single quaternion channel. Proper conversion from angle/axis and quaternion rotations are made to Euler angles via keyframe resampling and reduction.

Translation as explicit X,Y, Z animation channels or a single triple-component controller.

Object pivot points

Converted Camera Animation Channels

Translation as explicit X,Y, Z animation channels or a single triple-component controller.

Orientation as explicit X,Y, Z Euler rotation animation channels, or as a single quaternion channel. Proper conversion from angle/axis, quaternion rotations and look-from/look-at/look-up camera notation are made to Euler angles via keyframe resampling and reduction.

Focal length and camera roll animation channels.

Converted Light Animation Channels

Translation as explicit X,Y, Z animation channels or a single triple-component controller.

Orientation as explicit X,Y, Z Euler rotation animation channels (for directional lights) , or as a single quaternion channe. Proper conversion from angle/axis, quaternion rotations and shine-from/shine-at orientation notation are made to Euler angles via keyframe resampling and reduction.

Light color (light intensity animation has to be embedded in the light color)

Converted Material Animation Channels

Ambient, diffuse, specular, luminous and filter colors

Face opacity


Configure File Search Paths

Configure Bitmap File Search Paths

This dialog box is accessed by choosing the "Edit Automatic Bitmap Conversion Search Paths" button on either the PolyTrans import or export options dialog boxes.

When PolyTrans does automatic bitmap conversion during an import or export process (such as converting TIFF files to DirectX compatible .ppm files), it must locate and open up the bitmap images. If the bitmap images have absolute filepaths then there will be no problem with this process. However, if the bitmaps use relative filepaths, or no filepaths at all, PolyTrans will not be able to locate them during the automatic bitmap conversion proces. To fix this problem, show this dialog box and add a new bitmap filepath that points to the directory where the bitmaps are located.


Mesh Conversion Options

"Meshes" Dialog Box Options:

When importing polygons, or NURBS surfaces converted to polygons, this dialog box specifies options relating to the import of the polygons.

Weld Adjacent Vertices Together

If this checkbox is enabled (check-marked) then a vertex welding operation will be applied to all polygon vertices. Vertex welding collapses adjacent vertices which are within a distance less than or equal to the threshold value specified on the dialog box This welding operation should be performed if the "Assign Smoothing Groups to Mesh Objects" option (see below) is enabled. Note that welding of vertices can only occur within a single object and not between different objects. This option is enabled by default so that the ‘Assign Smoothing Groups’ option works as expected.

Maximum Distance Between Two Vertices

If the distance between two vertices is less than or equal to this number, and the "Weld Adjacent Vertices Together" checkbox is check-marked (enabled) then the two vertices will be collapsed (welded) into one.

Reverse Orientation of all Polygons and Flip Normals

If this checkbox is enabled (check-marked) then the orientation of all polygons will be reversed. You might want to enable this option if you are finding that the 3ds Max renderer is displaying only the back-facing polygons rather than the front-facing polygons.

Make Polygon Orientations Consistent (Unify Normals)

For some 3d models, in particular those created using Autodesk’s AutoCAD, there is no consistent orientation of the polygons; ie: some polygons of a surface are oriented clockwise (the geometric normal points inward) while the remaining polygons are oriented counterclockwise (the geometric normal points outward). This is a problem for the "Assign Smoothing Groups to Mesh Objects" option below since all of the polygons must have the same orientation in order for the smoothed vertex normals to be computed properly.

If this option is enabled (checkmarked) then a special algorithm will be used to walk over the polygon mesh and reorient each polygon. Note, however, that adjacent polygons MUST share the same vertices for this algorithm to work; you can ensure that the vertices are shared by enabling the "Weld Adjacent Vertices Together" option above.

Vertex Normal Assignment Method

These are important options for the successful import of smoothed polygon data into 3ds Max. First it must be explained how 3ds Max assigns normals to each polygon vertex. Three methods are provided internally:

1. For 3ds Max v6 or newer, an undocumented method exists for forcing explicit, "specified" normals onto a mesh. This solves a long standing problem with 3ds Max in which accurate vertex normals could not be specified and assigned to a mesh. These accurate vertex normals are critical for importing CAD data properly. You will always want to make sure the "Assign accurate, explicit normals" checkbox is enabled.

2. If one or more polygons share a single vertex, and the vertex normal is the same for all polygons, then 3ds Max allows that single normal to be assigned to the vertex. We will call this an ‘explicit rendering normal (RNormal)’ since it will be explicitly assigned to the vertex by the import converter. Such RNormals, however, cannot be saved to a .max file. This option is really no longer necessary for 3ds Max v6 or newer users, as the "Assign accurate, explicit normals" checkbox option should be used instead.

3. If two or more polygons share a single vertex, and each polygon requires a different vertex normal, then 3ds Max uses the concept of ‘smoothing groups’ to allow different normals to be assigned to a single vertex (for example, the corner of a square box which requires 3 different vertex normals, all at 90 degrees from each other). Rather than explicitly assign the different normals to the vertex, the import converter assigns one or more smoothing groups to the vertex. Thus, the original vertex normal(s) are lost (thrown away) and replaced with some numbers representing the assigned smoothing groups. At a later stage, during a rendering process, 3ds Max will use the smoothing groups to recompute the one or more normals assigned to a single vertex. In this manner 3 different normals can be assigned to the corner of a box, for example. A side effect of using smoothing groups is that the vertex normals computed by 3ds Max using the smoothing group algorithm may not be the same as the original vertex normals imported from the data file.

Assign Smoothing Groups to Mesh Objects

If this checkbox is enabled then the import converter will automatically compute and assign smoothing groups to all polygons. This will ensure that the 3ds Max renderer computes adequate vertex normals if none should exist prior to rendering. This option must be enabled if an object has ‘creases’ in it where a single vertex can have two or more distinct vertex normals. If not enabled then the data will appear to have ugly black marks on it after being rendered.

In general you will always want to enable this option. Some modifiers in 3ds Max cannot handle "Explicit Normals" (see below), and fall back to using the assigned smoothing group normals.

Assign per-vertex 'render' normal data ("RNormals")

This option should not be enabled for 3ds Max v6 or newer, for which the "Assign accurate, explicit normals" option should be enabled instead. Also, RNormals cannot be saved to .max files.

If this checkbox is enabled then the import converter will always force a single vertex normal onto each vertex if one was specified in the imported data file, even if the vertex is known to have 2 or more distinct normals. For smooth surfaces this will probably provide good results. However, if the surface has creases or sharp corners then enabling this option will make all creases and sharp corners disappear - the reason for this is that creases and sharp corners require two or more distinct normals at each vertex, but enabling this option will only allow a single normal to be assigned. This option should also be assigned if the imported data looks faceted, even with the ‘Weld Adjacent Vertices’ and ‘Assign Smoothing Groups’ options enabled.

Assign accurate, explicit normals (3ds Max v6 or newer)

This is the most accurate way to import and assign vertex normals to mesh data, for 3ds Max v6 or newer.

If this checkbox is enabled then the import converter will assign accurate, ideal vertex normals to the mesh using an undocumented method for 3ds Max v6 or newer. This will be critical for CAD applications which often need explicit, accurate vertex normals and not smoothing groups. Smoothing groups are just an approximation and do not fair well with CAD data.

NOTE: You will want to keep this option enabled as well as the "Assign Smoothing Groups to Mesh Objects" option. The explicit normals will override the smoothing group normals (which is desired). Some older modifiers in 3ds Max may not handle these new "explicitly specified normals" and hence they will fall back to using the smoothing groups assigned to the mesh.

Caveat: these explicitly assigned vertex normals will lead to ideal renderings of the mesh data (no banding or anomalies most often encountered when using 'smoothing groups'). However, enabling some modifiers on the mesh, such as "Edit Normals" will cause these explicit vertex normals to be destroyed and replaced with the assigned semi-inaccurate smoothing groups. This is just basic a consequence of how 3ds Max works and was originally designed.


Import: Bitmap Conversion Options

"Bitmap Conversion" Dialog Box Options:

This dialog box controls how referenced bitmap files will be handled during the import into 3ds Max. The three options are basically:

1. Do not modify the bitmap filename reference and do not perform any bitmap conversion. This is useful if your bitmaps are already in a format recognized by 3ds Max and the path to the bitmaps have been specified to 3ds Max via its ‘File/Configure Paths’ dialog box.

2. Modify the extension of the bitmap filename to a bitmap format recognized by 3ds Max, but do not perform any bitmap conversion. This option is useful if you have (1) either performed the bitmap conversions in a previous import process or (2) you wish to use an external program (such as PhotoShop) to perform the bitmap conversions.

3. Perform bitmap conversion for those file formats not recognized by 3ds Max and change the file extension of the bitmap. For example, if importing from a LightWave scene file which references a bitmap called "brick.iff" (in the Amiga IFF file format), then this dialog box can enable the import converter to convert the Amiga IFF bitmap file to a 3ds Max recognized file format such as TIFF.

No Bitmap Conversion or Bitmap Filename Changes (Radio Button)

If this radio button is chosen then any bitmap reference imported into 3ds Max will not be changed, its filename extension won’t be changed, the path to the bitmap will not be changed and no bitmap conversion will be done.

Convert all Bitmap File References To... (Radio Button)

Rather than convert referenced bitmap images to another file format this radio button (when selected) simply changes all the file extensions on bitmap files to a specific type. For example, if set to "TIFF" then all bitmap filenames imported into the 3ds Max will be changed so that their file extensions end in ".tif". This is a useful option is you already have all of the referenced texture maps converted to the desired file format (either from a previous invocation of this import converter or by using a batch bitmap conversion program).

Auto-Convert Bitmap Files to Another Format (Radio Button)

If this radio button is selected then all 2d bitmap textures which are currently defined and referenced by the internal NuGraf/PolyTrans database scene will be automatically tagged then converted to a new user-specified 2d bitmap file format. For example, if you are importing a LightWave scene to 3ds Max, and the LightWave file references IFF bitmap files then this option can be enabled so that the IFF images get converted to TIFF format automatically.

If the bitmap texture(s) cannot be found in the location specified by the pathname prepended to the texture filename then the export converter will search for the texture(s) in all directories specified in the 3ds Max ‘Bitmaps’ file search paths (these can be modified by choosing the ‘File/Configure Paths’ dialog box and clicking the ‘Bitmaps’ tab).

Bitmap File Format (Combo Box)

This combo box lists the destination bitmap file format.

Bitmap Bits/Pixel: 2, 4, 8, 24 (Combo Box)

This combo lists determine the number of bits/pixel to write out to the new 2d bitmap file. The default is 24 bits. A color quantization algorithm will be used for the 2, 4 and 8 bits/pixel output formats. Not all bitmap file formats can accept 2-8 bits/pixel (in particular JPEG).

Dimensions: X = #, Y = #

These two drop-down list boxes determine the X and Y resolution for the converted bitmap file(s):

No Change = Do not change the X or Y size (default)

Closest = Use the next highest power-of-2 size

2, 4, 8, ... 256, 512 = Choose a specific size for the X or Y dimension

Confirm Potential Bitmap File Overwrites

If this checkbox is enabled (checkmarked) then the bitmap converter will confirm any potential overwrites of existing bitmap files on disk which have the same filename and extension as the one being written. If this option is disabled then no confirmation will be made.

Save Converted Bitmaps To...

These radio buttons determine where the new bitmap file will be written to. Note that enabling the ‘Replace all Bitmap File Paths With This Path:’ option or the ‘Strip File Paths From All Bitmap References’ option below will change the path prefix for the converted bitmap even though it was saved to disk in the location specified by one of these 3 radio buttons.

Directory Where Geometry Was Read From

The new bitmaps will be written to the directory where the original geometry file(s) were read from.

3ds Max ‘maps’ Directory

The new bitmaps will be written to the 3ds Max ‘maps’ directory.

Specific + Browse

The new bitmaps will be written to the directory specified by the text box. This directory can be changed by press the ‘Browse’ button.

Strip File Paths From All Bitmap References

If this checkbox is check-marked then all bitmap file references will have their filename path removed from them. This is the default because 3ds Max prefers to locate a bitmap file using the paths specified in its ‘File/Configure Paths’ dialog box rather than having an absolute (and possible non-portable) absolute path specified for a bitmap file. For example, if a bitmap reference was original ‘c:\myfiles\textures\brick.bmp’ then enabling this option will change the reference to ‘brick.bmp’. If this option is disabled then the filepath and filename to the bitmap reference will not be changed.

Replace all Bitmap File Paths With This Path:

This option allows all bitmap references imported into 3ds Max to be prefixed with a new filepath. This might be useful, for example, if all of your bitmap files are located in one specific directory or if you wish to change the prefix on the imported bitmap references. This new path will override all other options on this bitmap conversion dialog box (in other words, it will replace a bitmap’s file path regardless of any other file path added to the bitmap via other options in this dialog box). To choose the filepath press the "Browse" button. To disable this option, click on the checkbox again so that it comes un-checkmarked.

Edit Automatic Bitmap Conversion Search Paths

In specific circumstances you will need to inform PolyTrans where your source bitmap images are located so that automatic bitmap file conversion proceeds properly. If PolyTrans reports warnings that specific images could not be located during automatic bitmap conversion press this button so that the Search-Paths dialog box appears. Using this dialog box you can tell PolyTrans where your source bitmaps are located.


Enables Options

"Enables" Dialog Box Options:

These check boxes control what type of data will be imported into 3ds Max from the PolyTrans database.

Triangle Mesh

If this option is enabled (checkmarked) then all mesh (polygon) geometry will be imported from the file into 3ds Max. If disabled then all mesh geometry will be ignored.

Mesh Normals

If this option is enabled (checkmarked) then any vertex normals that are assigned to polygon vertices will be imported.

Texture Coordinates

If this option is enabled (checkmarked) then any (u,v) texture coordinates that are assigned to polygon vertices will be imported. If this option is not enabled then texture maps will not appear on the polygon surfaces.

Vertex Colors

If this option is enabled (checkmarked) then any vertex colors that are assigned to polygon vertices will be imported. There are not too many cases where you will find scene data that has vertex colors assigned to the geometry. However, some file formats, such as OpenFlight, do support vertex colors and such data can be imported through PolyTrans into 3ds Max by enabling this option.

NOTE: the vertex colors will not automatically appear in your rendered images; instead, you must assign the "Vertex Colors" shader in 3ds Max to the diffuse texture map channel of any materials assigned to the geometry which has the embedded vertex colors (see the 3ds Max documentation for more info).

Skinning Weights

Enabling this option will turn on one of the most complex aspects of the PolyTrans-for-3dsMax import process, that of being able to import skinning weights associated with mesh data.

"Mesh skinning" is the process of deforming a single skin mesh with a skeleton or any hierarchical set of transform nodes. The contribution of each bone of the skeleton to the deformation of a vertex in the mesh is controlled by vertex weights.

If this option is enabled then "skinned meshes" will be imported into 3ds Max using the "SkinMod" modifier. A hierarchy of 3ds Max bones will be created then linked to a single-skin mesh using the SkinMod modifier.

Attempt to Hide Triangle Edges to Make Quad Meshes

3ds Max always uses triangles internally to represent its polygon meshes. Hence, all quad and n-sided polygons must be converted to triangles prior to import into the 3ds Max core scene graph.

If you enable this option then the importer will attempt to set the hidden flag on specific edges in the triangle mesh so that the mesh will look entirely, or mostly, like the same original quad-based mesh. This will only work however, if there are no polygons in the original source mesh which had holes, or were concave, or had more than 4 sides to each polygon, otherwise the source mesh has to be triangulated and imported as pure triangles into 3ds Max.

Indexed 3D polylines (as 3ds Max 'linear spline shape')

If this option is enabled (checkmarked) then 3D PolyLines will be imported as 3ds Max "linear spline shapes". These PolyLines have no area and will not be 'renderable', such as with polygons.

Notes of interest:

· 3ds Max does not allow for a line segment within the PolyLine primitive to have multiple colors assigned to it (such as different colors per vertex). On the other hand, Okino software allows for colors to be assigned to each vertex of a PolyLine.

· A 3ds Max PolyLine geometry object can have multiple line segments defined within it. However, all of them must share the exact same color. On the other hand, Okino software allows for different colors to be assigned to each sub line segment.

· The 3ds Max core graphics drawing code, specifically the PolyLine::Render() method, has no notion of rendering a PolyLine with color from a 3ds Max material. The only way this was accomplished through this Okino importer for 3ds Max was to assign the imported Okino color to the 3ds Max ‘wire color’ of the PolyLine primitive. This is undocumented 3ds Max behavior. Note: if you go and assign a 3ds Max material/shader to the imported PolyLine object then it will immediately turn white, because the core engine of 3ds Max ignores materials assigned to PolyLines.

· To overcome these previous limitations of 3ds Max, any imported PolyLine object, coming into 3ds Max from the Okino PolyTrans database, which has multiple sub line segments (such as 10 lines with 10 different colors assigned to each) will be exploded into multiple 3ds Max object definitions, each with their own unique assigned colors. That color will be obtained either from the vertex color of the imported line’s first vertex (which has preference) or from the material assigned to that Okino PolyTrans line primitive. Geometry instancing is not accommodated in such situations due to the exploding of the imported raw geometry.

Object Hierarchy

If this option is enabled (checkmarked) then the hierarchical relationship of objects in the scene will be imported. This data will also use the scaling, rotation and translation data used by animation keyframe # 0. For a good explanation of object hierarchy, please refer to the section ‘ How Hierarchies Convert Between 3ds Max, PolyTrans and Other 3D Programs’ .

Re-Align Imported Skeletal Bones to be X-Axis Aligned

3ds Max will always visualize skeletal bones along their local X-axes. In order to properly visualize skeletal bones inside 3ds Max, it is thus necessary for the bones' local X-axes to point in the desired visualization direction. For example, when visualizing the thigh-bone of a character, we want the local, positive X-axis to point in the direction of the knee joint. Otherwise, the thigh-bone visualization will not "look like" it represents the thigh in 3ds Max -- even though the knee joint is in the proper position.

Other 3D packages, such as Maya, allow a more flexible range of skeletal bone visualizations. This allows them to visualize bones properly even when the local X-axis is not oriented "into" the desired visualization. If you import a skeleton from another 3D package, and find that the bones are pointing in the wrong direction, then go and enable this option. This option will cause the entire skeleton, its related matrices, and all associated animation data to be reworked so that the local X-axis is oriented in a more appropriate visualization direction.

This option is disabled by default, since the process of reorienting the bones will heavily modify the original skeleton hierarchy and animation data (all the animation curves must be resampled). In most cases, this feature will not be required. By convention, many 3D packages will attempt to keep their bones export-friendly (e.g. visualization along the X-axis), even if they can accept arbitrary visualization axes. This is an advanced option, and hence should only be used when necessary (e.g. when you find a file with bones that don't visualize well when imported to 3ds Max).

** NOTE ** The skeleton from the source 3D package should not have any non-uniform scaling embedded in its matrices. Such non-uniform scaling would become "off-axis" scaling (a.k.a. "skew") after the reorientation process. In general, this is not desired, and will cause the modified skeleton to look warped or skewed as a result. To avoid this, use only uniform scaling (e.g. scaling with the same scale factor in all 3 dimensions) in the source 3D package.

Compress PolyTrans Hierarchy During Import

If this option is enabled then PolyTrans will optimize its own internal object hierarchy tree when it is imported into 3ds Max. Any combination of PolyTrans ‘Null Node’ (empty folder, empty instance) followed by a child geometry node (mesh object) will be modified so that the Null Node is deleted and replaced with the mesh node.

As explained in the subsequent help section titled ‘How Hierarchies Convert Between 3ds Max, PolyTrans and Other 3D Programs’, PolyTrans uses a hierarchy system based on a DAG tree. In this hierarchical system only null nodes can be connected to other null nodes to form the hierarchy of the geometry tree; this form is very similar to the DAG node hierarchy used by all Alias products, including Maya. However, other popular 3D programs, such as 3ds Max and LightWave, do not adhere to pure DAG hierarchies; these programs allow objects to be connected to objects, whereas in PolyTrans objects can only be connected to their corresponding transform nodes (null nodes), and transform nodes can only be connected to transform nodes. In other words, PolyTrans only allows geometry nodes to be leaf nodes (the bottom most nodes) of a hierarchy tree while internal nodes of the tree can only be Transform node (or empty folders/instances in PolyTrans lingo).

Thus, when PolyTrans imports from such non-DAG system programs as 3D Studio (.3ds) and LightWave (.lwo, .lws), it has to change the non-DAG hierarchy into a DAG compliant hierarchy before the hierarchy can be stored within the PolyTrans internal database. To some people it may appear that PolyTrans has messed up the imported .3ds/.lw hierarchy trees. In fact, the hierarchy trees will be identical functionally and mathematically (all objects from the .3ds/.lw file will be leaf nodes of the tree, rather than internal nodes of the tree). If this option is enabled then the Transform node hierarchy shown within the 3ds Max user interface should look identical to the original 3ds Max or LightWave hierarchy (ie. no additional PolyTrans empty nodes should be visible).

Remove Useless NULL Nodes From Hierarchy

If an imported NULL/grouping node inside 3ds Max has no children, is not a joint of a bone hierarchy and has no animation on it, then it is usually discarded from the hierarchy by PolyTrans (pruned, deleted).

If this option is enabled then such useless grouping/NULL nodes are deleted during the import process into 3ds Max.

If this option is disabled then such useless grouping/NULL nodes are retained during the import process into 3ds Max and not deleted. You will want to disable this checkbox if you are importing a file of NULL nodes and you wish all of them to be imported and not pruned.

Make Dummy Nodes (NULL nodes, helper nodes) Visible

If this option is enabled then "Dummy 3ds Max Nodes" (NULLs, 'Empty Instances' or "Grouping Folders" as they are known inside Okino programs) will be made visible.

By default this option is disabled since 3ds Max users tend to find these extraneous grouping nodes to be distracting. These "Dummy Nodes" are important to Okino data imports since they are used for hierarchy and grouping purposes.

Pivot Points

Pivot points are a fundamental component of an animation system. In the realm of the Okino animation system ‘pivot points’ define a local 3D coordinate system in the space of an object about which the scale, rotation and translation animation function curves will be applied. The pivot point in Okino’s scene graph is defined by a 3D point in space and a local coordinate system defined by 3 orthogonal XYZ axes; the pivot point is itself defined relative to the local coordinate system of the underlying mesh or geometry data.

First, some rules need to be defined for the following explanations. "Pivot point processing" only needs to be done under these circumstances for the two "Minimal" modes:

1) The source pivot point 4x4 matrix has a non-zero origin or non-aligned orientation axis. In other words, it has something "interesting" in it, or

2) The instance has animated channels associated with it, or

3) The (static) transformation matrix associated with an instance has "off-axis" scaling within it. Off-axis scaling is where rotation comes before scaling, which is basically an illegal or poorly supported situation for most 3D programs.

For a "grouping folder" (an Okino "empty instance"), which is deemed to have a valid pivot point matrix, a new child ‘anti-pivot’ node is added to the 3ds Max hierarchy tree - the child node is assigned the inverse pivot matrix and the original parent transform node gets the animation data. This properly applies the anti-pivot effect to the subsequent children in the tree.

The following options specify how the Okino pivot point information is exported for instance-geometry nodes:

Embed pivots in *all* geometry data

Logic – regardless of the ‘3 rules’ explained above, this processing mode will be invoked on ALL instance-geometry nodes if any of them have a non-identity pivot matrix.

The inverse pivot matrix is multiplied into the raw mesh geometry vertices. In other words, the messy "pivot point" problem is made to disappear by having its 4x4 matrix physically multiplied into the mesh geometry vertices.

Embed minimal pivots in geometry data

Logic – same as above except that the processing mode will only be invoked when one of the "3 rules" explained above are valid. This leads to a cleaner conversion.

Output *all* anti-pivot transform nodes

Logic – regardless of the ‘3 rules’ explained above, this processing mode will be invoked on ALL instance-geometry nodes if any of them have a non-identity pivot matrix.

A new "anti-pivot" dummy node is introduced into the 3ds Max hierarchy tree, between the mesh geometry object and the parent transform node (which has the animation on it). The inverse of the Okino pivot point matrix is assigned to the transformation matrix of this new anti-pivot dummy node. This new anti-pivot node acts to ‘pivot-in’ the geometry vertices prior to the animation data being applied to the geometry.

Thus, this mode "splices in" the pivot point matrix into the 3ds Max hierarchy tree as a new transformation node rather than to multiply the pivot point matrix into the raw mesh geometry, as with the other modes.

Add minimal anti-pivot transform nodes

Logic – same as above except that the processing mode will only be invoked when one of the "3 rules" explained above are valid.

This is the default option since (1) it results in the fewest changes to the output hierarchy tree and (2) it does not physically affect the mesh geometry coordinate data.

Ignore all pivot point data (can cause problems)

This option prevents pivot point information from being sent to 3ds Max. Normally you would never want to enable this option.

Import Spline Shapes & NURBS Curves As

This combo box determines how 3D spline shapes (made up of spline curves such as B-Splines, Beziers, etc), or 3D NURBS curves, are imported into 3ds Max:

3D Spline Curves

This combo box option will import the spline shapes as equivalent 3ds Max spline shapes. They will not have any "fill color" because they will just be splines, and have no area.

Triangle mesh (if curves are closed and tagged as 'renderable'

This combo box option will convert spline curves and NURBS curves which are 'closed' (which form a 3D planar area) into an equivalent triangle mesh. These meshes can then be rendered as would any 3D object would in 3ds Max. Note: the spline shapes need the "renderable" flag set -- this is often set on the source 3D importer, such as the Okino Illustrator .ai importer.

Cylinders, Import Mode

This combo box determines how cylindrcal geometric objects will be imported into 3ds Max, as either "procedural" or meshed polygons. Using procedural mode will allow you to change the number of subdivisions for the cylinders, on the fly, inside the 3ds Max user interface after the file has been imported.

This is most useful when importing 3D piping models (such as from Navisworks) via Okino’s DWF importer. If the DWF file uses cylinder geometry for the pipes, and you disable the "Compress & Optimize Numbers of Objects" option on the Okino DWF importer, and you set this combo box to "Import all cylinders as procedural", then such pipes will be imported into 3ds Max as procedural cylindrical geometry.

Import capped cylinders as procedural; uncapped as meshes

All cylinders which have "end caps" will be imported as "procedural", while cylinders which have no "end caps" will be imported as meshed polygon geometry.

Import all cylinders as procedural (uncapped become capped)

All cylinders will be imported as "procedural" regardless of their original "end cap" status. 3ds Max only allows for capped procedural geometry, so the imported cylinders will always be capped regardless of their originating capped status.

Import all cylinders as meshes

All cylinders will be imported as meshed polygon geometry, with the correct capped or non-capped ends.

Subdivs = #

This type-in edit box sets the overall "roundness" of the final meshed or procedural cylinder. The actual number of divisions of the cylinder in the circular direction (polygons) created will be 4 times this value.

Changing this value will also explicitly change the internal Okino "Global Cylinder Geometric Subdivisions" value.


Enables Options 2

"Enables # 2" Dialog Box Options:

Atmospherics & Backgrounds

If this option is enabled (checkmarked) then fog, mist and background color schemes will be imported into 3ds Max. If disabled then these effects will be ignored.

Cameras

If this option is enabled (checkmarked) then the parameters of the current default camera will be imported.

Import Cameras as ‘Targeted’

Choosing this radio button will cause all imported cameras to be created as 3ds Max "Targeted cameras". Targeted cameras use 2 nodes, one for the "Look-From" location and one for the "Look-At" location. 3ds Max will always orient the targeted camera so that the "Up" vector always points straight up (as compared to Okino software, and other 3D programs, which allow the "Up vector" to be orientated in any direction). A "roll" value is also used to rotate the camera around the look-from to look-at vector.

Import Cameras as ‘Free’

Choosing this radio button will cause all imported cameras to be created as 3ds Max "Free cameras". Free cameras use 1 node which defines the Look-From location and an arbitrary rotation matrix to orient the camera.

Custom Properties

Node-Level Custom Properties

If this checkbox is checkmarked then Okino instance-level meta data items will be imported and assigned to 3ds Max node-level user-defined custom properties. These custom properties can be accessed within 3ds Max from the "Edit / Object Properties" dialog box, on the "User Defined" panel.

File & Scene-Level Custom Properties

If this checkbox is checkmarked then Okino scene-level meta data will be imported and assigned to 3ds Max "File and Scene Level" user-defined custom properties. These custom properties are found on the 3ds Max "File / File Properties" dialog box, on the "Summary" and "Custom" panels.

Geometry Instancing (to reduce memory usage)

If this option is enabled (checkmarked) then the mechanism of "instancing" will be used to try and keep the size of the imported 3ds Max scene as small as possible. For example, if the source scene has 1000 bolts all derived from the same mesh primitive data, and the 1000 items have been placed in the 3ds Max scene graph via "instancing" then during import process only a single copy of the geometry mesh data will be imported, but with 1000 virtual copies made of it. These virtual copy instances merely act as indexes to the original mesh primitive data instead of being full copies, which can significantly reduce the size of the final output.

If this checkbox is disabled then unique and explicit copies of mesh data will be imported into the 3ds Max scene graph regardless of whether each copy is exactly the same as previous copies already imported.

Lights

If this option is enabled (checkmarked) then ambient, point, directional and spot light sources will be imported.

Materials

If this option is enabled (checkmarked) then materials will be created and assigned to the geometric objects in the scene. If disabled then no materials will be created.

Delete Unreferenced Materials

If this option is enabled (checkmarked) then all imported materials which are not referenced in any way (such as by a mesh or NURBS surface) will be deleted prior to import into 3ds Max.

Enable Two-Sided Material Flag

If this option is enabled (checkmarked) then the ‘2-Sided’ flag associated with each 3ds Max material definition will be enabled. This is the default. If the check-mark is disabled then then 2-Sided flag will be disabled in each 3ds Max material.

Bitmap References

If this option is enabled (checkmarked) then all 2D bitmap textures will be assigned to their associated materials. If this option is disabled then no bitmap references will be created and none will be assigned to the 3ds Max materials (this basically disables texture mapping).

Pass All Handle Names Through Autodesk's "Make Name Unique" Routine

If this option is enabled (checkmarked) then all object, camera, light, material, etc. names imported from the PolyTrans scene graph will first be processed by the 3ds Max "MakeNameUnique()" routine prior to being sent to the 3ds Max scene graph. This is the default option. The benefit of doing this operation is that it guarantees no name space collisions. In other words, all object, camera, light, material, etc. names imported into 3ds Max will be unique and non-colliding. In addition, you can import the same scene multiple times and have no colliding names -- all imported names will be made unique.

The disadvantage of enabling this option is that the 3ds Max "MakeNameUnique()" routine can indirectly mangle the suffixes on each handle name. A name such as "Part0542893" might be turned into "Part05". For most users this won't matter, nor will it occur too often. However, some users may require that all part names remain unchanged. If that is the case then simply un-checkmark this option. Disabling this option will prevent the handle names from being modified, but may allow for name space collisions if an item with the same name is imported more than once.

Image Alpha Processing

This combo box provides finer control over how the 'Alpha Source' parameter is set for each imported texture map.

Import as per source 3D file info. Default 'alpha = None (opaque)'

If the source 3D file explicitly says that the texture reference should use the alpha channel of the image, then the radio button in 3ds Max will be set to 'Alpha = Image Alpha'. Otherwise, set the radio button to 'Alpha = None (opaque)'.

Import as per source 3D file info. Default 'alpha = Image Alpha'

If the source 3D file explicitly says that the texture reference should use the alpha channel of the image, then the radio button in 3ds Max will be set to 'Alpha = Image Alpha'. Otherwise, set the radio button to 'Alpha = Image Alpha'.

Import as per source 3D file info. Default 'alpha = RGB Intensity'

If the source 3D file explicitly says that the texture reference should use the alpha channel of the image, then the radio button in 3ds Max will be set to 'Alpha = Image Alpha'. Otherwise, set the radio button to 'Alpha = RGB Intensity'.

Don't import any image alpha info

Ignore any alpha info specified by the source 3D file. Just set the radio button to 'Alpha = None (opaque)'.

Shading Parameter Modification Combo Boxes

These combo boxes provide hands-on control over how imported material shading parameters should be modified so that the imported model can be rendered nicely as it would have looked in the source 3D program. The two combo boxes and the single numeric type-in box provide you good control over the ambient, diffuse, specular, luminous and reflection shading coefficients imported into 3ds Max, as well as the opacity of the material, its index of refraction (IOR) and Phong shininess value.

The first drop-down combo box selects which of these shading parameters you want to modify. Each shading coefficient has its own operation which can be selected (the second combo box) and an optional numeric type-in value (the third data entry text input). The following describes the various shading parameters that can be controlled:

Ambient Coefficient: This controls the amount of color reflected from an object based on the ambient light in a scene. A good default value is 0.1 through to 0.3 and ideally ranges from 0.0 to 1.0.

Diffuse Coefficient: This controls the amount of color reflected from an object based on the direct light shining on it. A good default value is 0.4 and ideally ranges from 0.0 to 1.0.

Specular Coefficient: This controls the intensity of the highlight color on an object. A good default value is 0.7 and ideally ranges from 0.0 to 5.0.

Luminous Coefficient: This controls how much color is added directly to an object, irrespective of any light which shines on it (the higher the value, the more the object will appear to glow). In general you should keep this value at 0.

Reflection Coefficient: This controls the ray trace reflectivity of an object. If set to 1.0 then the object will be 100% reflective and if set to 0.0 then the object will not be reflective at all.

Opacity: This is the inverse of transparency. 0.0 will make the object fully transparent, while at 1.0 the object will be fully opaque.

Index of Refraction (IOR): This is the ray traced index of refraction of an object. If the value is greater than 1.0 then a ray will refract as it passes from one material to another (as per Snell’s law), each of different IORs. Ideal ranges are 1.0 through to 3.0.

Phong Shininess: This controls the width of the specular highlight seen on an object. An ideal range is 6 (very wide) to 300 (very narrow). The default is 32.

For each material shading parameter, several actions can be performed on it during the import process:

Do Not Import: The shading parameter is set to 0, effectively making the shading channel appear black (for color channels).

Import Unchanged: The shading parameter is imported as is, with no change.

Set and Use Default: The shading parameter is set to some "good" default value (as determined by the import converter). This default value will be shown in the type-in box.

Set to Specific Value: The imported shading parameter will be overridden with the user specified value of the numeric type-in box.

Import and Crop by: The shading parameter is imported and will remain unchanged if it is less than the numeric type-in value shown on the dialog box. If it is greater, then the imported value will be clamped to be no greater than the numeric type-in value. This is a good operation, for example, if you do not wish for the ambient shading coefficient to be greater than 0.3.

Import and Scale by: The shading parameter is imported and multiplied by the numeric type-in value shown on the dialog box

Normalize Color and Coefficient: This option only applies for the ambient, diffuse, specular and luminous shading coefficients and their respective RGB colors. This option is a hybrid approach which tries to automatically "guess" at a proper shading coefficient value given the raw (and corresponding) color imported from the file. As mentioned, the shading coefficient is needed to create nice looking (nicely shaded) images in a photo-realistic rendering program. If this option is chosen, then the specific shading coefficient will be derived directly from the relative intensity of the imported color which corresponds to this shading coefficient (diffuse color for diffuse shading coefficient etc.). For example, if the imported diffuse color is (0.4, 0, 0), which is 40% of full-bright red, then the diffuse shading coefficient will be set to 0.4 and the diffuse color will be modified to be (1, 0, 0). When the new color (1,0,0) and the new shading coefficient (0.4) are multiplied together, it results in the original color imported from the file (0.4, 0, 0). In general you may wish to use the "Set and Use Default" option to get good rendered results.


Enables Options 3

"Enables # 3" Dialog Box Options:

Dialog Boxes Shown During the Import Process

The following options control whether specific dialog boxes will be shown during the import process:

Always Ask If Viewport is to be Auto-Resized

If this option is enabled (checkmarked) then a dialog box (see below) will be presented to the user every time a scene is imported into 3ds Max. This dialog box will ask the user whether the currently active perspective camera viewport should be auto-resized around all of the imported objects. If this checkbox is disabled then this dialog box will not be shown after the import process is completed and no auto-resizing will be done.

Normally the active perspective camera imported from a 3D file format is pre-defined to view the objects in the scene, and hence you should press "No". But often, when importing from CAD models there is no pre-defined camera and in this case you should pres "Yes".

Auto-Resize 'Orthographic' Viewports Around Geometry Data

This checkbox has a similar effect to the previous one. If this checkbox is enabled then all the orthographic viewports (such as "Right", "Left" and "Top") will be zoomed to encompass all the geometry in the scene. This option will always be invoked (when the checkbox is enabled) even if this dialog box is not shown.

Always ask to add default lights if none in scene

If this option is enabled (checkmarked) then a dialog box will be presented to the user every time a scene is imported into 3ds Max if there are no lights in the scene. This dialog box will ask the user whether two or three lights are to be added to the scene automatically. If this checkbox is disabled then this dialog box will not be shown after the import process is completed and no lights will be added to the scene.

Show Import Converter Progress Dialog Box

If this option is enabled (checkmarked) then a small status dialog box will appear while a file is being imported into the core PolyTrans software.

Show PolyTrans to 3ds Max Progress Dialog Box

If this option is enabled (checkmarked) then a dialog box will appear while the PolyTrans database is being imported into 3ds Max. This is the second phase of an import process. This dialog box will describe which entity is currently being processed, the amount of memory currently being used and the overall completion status.

Show 'CAD Import Optimization Request' Dialog Box

After an import process is completed, a dialog box may pop up saying that PolyTrans has detected a large number of objects named "face", "body", etc. This normally occurs if you import from a CAD file format and you have not enabled the "Optimize Hierarchy" checkbox. That dialog box will warn you of this situation and it will suggest that you re-import the CAD file again with the "Optimize Hierarchy" checkbox enabled on the CAD importer.

If you decide to choose the "Never show this dialog box again" combo box option then the dialog box can once again be shown after an import process by enabling the "Show 'CAD Import Optimization Request' Dialog Box" shown above.

Set currently selected camera viewport to the imported "active" camera

If this checkbox is enabled, and the currently active viewport within 3ds Max is the "User" viewport or the "Camera" viewport, then the camera from the import file which is marked as the "Active Camera" will be made the active camera within 3ds Max. If this checkbox is disabled then the current active camera within 3ds Max will not be changed.

Zoom up the newly imported camera.

If this checkbox is enabled then the current camera viewport within 3ds Max, which had been modified to be the same as the active camera from the imported file, will be zoomed up to full extents.

3ds Max Animation Parameters Imported from File

The following checkboxes control how various animation user interface aspects of 3ds Max are modified according to animation timing and extents data imported from the file.

Frame Rate FPS

If this option is enabled (checkmarked) then the 3ds Max animation frame rate will be updated to be equal to those imported from the file. For example, if the file uses 24 frames per second then the global animation frame rate will be set to ‘Film (24 fps)’ in 3ds Max.

Start/End Timeline Extent Times

If this option is enabled (checkmarked) then the start/end of the imported animation data will be used to modify the animation start/end time limits in 3ds Max’s user interface.

Polygon Triangulation Enables

These options select which polygon triangulator will be used when a polygon mesh is converted into a set of triangles during import (3ds Max internally uses a triangulator for objects). Three different types of triangulators are available. All handle n-sided geometry with recursive holes, but some are better than others for different mesh topology. If all 3 are enabled, then each one will be used in succession if a predecessor triangulator could not triangulate the mesh data.

Triangulator 1

The first algorithm creates nicely triangulated meshes of n-sided concave polygons with optional holes but it cannot handle polygons with self intersecting edges or holes that intersect with the outer boundary. If it cannot triangulate the mesh data then triangulator 2 and then 3 will be executed next.

The following image shows the type of tessellation expected from triangulator # 1 and # 2:

Triangulator 2

The second algorithm is a more modern version of triangulator # 1. It should be able to handle all possible cases of triangulation, including self intersecting edges. This version will create new vertex locations when self intersecting edges are found, or it will remove vertices from the final triangulated mesh if it determines that such vertices are not required. If you want this triangulator to always work first, then disable triangulator # 1.

Triangulator 3

This triangulator can handle any topology of polygon, including butterfly polygons (those that fold back on themselves), self-intersecting polygons and polygons whose interior holes intersect with its exterior boundary. In general, the newer triangulator # 2 should be used by default; however, triangulator # 3 is better than # 2 if you wish to use trapezoidal decomposition of the mesh.

Triangulator 3: Assume Concave Polygons are Complex (slower)

If this option is enabled then triangulator # 3 will triangulate the polygon using a trapezoid scanline-based scheme which will allow any type of polygon to be triangulated but at the expense of creating less visually appealing triangle meshes. If disabled then the triangulator may not be able to triangulate butterfly polygons or simple polygons.

The following image shows the type of tessellation expected from triangulator # 3 for concave geometry with holes:


Animation Conversion Options

"Animation" Dialog Box Options:

Animation Import Enables

Object Animation

If this option is enabled (checkmarked) then object animation data which is currently contained within the internal database will be imported into 3ds Max.

Please note that this importer will most probably insert new nodes into the tree called ‘anti-pivot’ nodes. These represent the object pivot point locations from the imported data file.

Camera Animation

If this option is enabled (checkmarked) then camera animation data which is currently contained within the internal database will be imported into 3ds Max (look-from, look-at, field-of-view and Roll vectors).

Light Animation

If this option is enabled (checkmarked) then light animation data which is currently contained within the internal database will be imported into 3ds Max (shine-from, shine-at, shine-direction and light color).

Material Animation

If this option is enabled (checkmarked) then material animation data which is currently contained within the internal database will be imported into 3ds Max (ambient, diffuse, specular, luminous and filter material colors, as well as material opacity).

Animation Resampling Related Options

PolyTrans-for-3dsMax contains highly advanced animation conversion capabilities. Indeed, the animation conversion capabilities arise from some of Okino's most complex and well-designed code. Years of development effort, and feedback from users like you, have allowed us to refine our animation code into one of the most important aspects of this converter.

In particular, "animation resampling" is the hidden 'insurance guarantee' that allows all sources and types of imported animation data to be properly and ideally matched to an equivalent 3ds Max form of animation, such that the source and destination animation data playback identically. In the ideal world the imported data from the source animation program would be fed directly to 3ds Max, but this is not always possible, depending on the animation controllers and interpolation methods desired. "Resampling" is the process of mathematically converting the source animation data format (such as quaternion rotations + linear interpolation) into the desired destination format in 3ds Max (such as Euler rotations + Bezier interpolation).

This animation importer will attempt to import the animation data in raw format, without any resampling, wherever possible (and thus no changes in animation data will be made). Otherwise, resampling will be used.

To minimize the amount of resampling done, and maximize your chances of getting

"raw" keyframes imported, the following options should be used on this animation panel:

· "Keep Original Interpolation When Possible" checkbox enabled.

· "Keep Original Rotation Controller Type When Possible" checkbox enabled.

· "Resample to Import as 'Vector Valued' Channels" checkbox disabled.

· "Fix up -180/180 Degree Euler Flips (Maintain Continuity)" checkbox disabled.

· All the "Force Keyframe Resampling Enables" checkboxes should be disabled on the "Animation Resampling & Reduction Options" dialog box (press the "Animation Resampling & Reduction Options" button found on this panel.

Preferred Interpolation Method (Linear, TCB, Bezier)

If and when animation resampling must be performed during the import process, it must select a target animation interpolation method. Since source animation data can possibly have controller types (such as 'constant') which cannot be readily replicated into 3ds Max, it is sometimes necessary to pick an arbitrary interpolation type as output for the resampling process. This arbitrary choice is left to you to choose and is selected via this drop-down box.

When the original interpolation method can be replicated into 3ds Max, you have a choice between keeping the original interpolation method or always using one specific interpolation method. That choice is controlled by the "Keep Original Interpolation Method When Possible" checkbox below. If you disable that checkbox, then all animation imported into 3ds Max will be forced to use the interpolation type selected in the "Preferred Interpolation Method" drop-down box.

Keep Original Interpolation Method When Possible

If this checkbox is enabled then the animation resampling process will

attempt to preserve the interpolation method used in the original source animation data. This can often be accomplished, but not in all cases. When it can be accomplished, then the animation data sent to 3ds Max will preserve the same interpolation type as the original source animation data. Otherwise, the animation output to 3ds Max will use the "Preferred Interpolation Method" you have specified above. You will typically want to keep this checkbox enabled, unless you have specific reasons for wanting all your 3ds Max controllers to use the same interpolation type.

NOTE: When this checkbox is enabled, keyframe resampling might still occur. However, the interpolation type of the resampled keyframes will have the same interpolation method as the original source animation data, when possible (or the "Preferred Interpolation Method" when the original source animation data's interpolation method cannot be used.)

If this checkbox is disabled then the resampling process will use the "Preferred Interpolation Method" you have specified above. If the original animation source data has a different interpolation type, then resampling must occur. If the original source data has the same interpolation type as the "Preferred Interpolation Method" you have specified above, then resampling will only occur if otherwise mandated.

Resample to Import as 'Vector Valued' Channels

3ds Max has one of the most flexible animation systems, at least in terms of programming and in terms of usage. It allows, for example, translation animation to be imported either as a single animation controller which handles all of the X, Y and Z channels, or it allows for 3 separate and independent controllers to be created each of which handles one of the X, Y and Z channels.

If this checkbox is enabled then X, Y and Z triples of animation channels (such as those for translation and scaling) will be imported into 3ds Max using a single animation controller which contains all 3 X, Y and Z animation channels. Note, however, for this to occur the 3 source animation channels have to be resampled so that all 3 share keys at the common key times (for example, the original X channel might only have 2 keys and the Y and Z channel has 20 keys, so more keys need to be added to the X channel so that all three have 20 keys).

If this checkbox is disabled then X, Y and Z triples of animation channels (such as those for translation and scaling) will be imported into 3ds Max as 3 distinct and independent animation controllers parented to one superior controller. This is the most compatible with the internal PolyTrans database which always uses 3 independent controllers for triple channels.

Preferred Rotation Type (Quaternion, XYZ, XZY, YXZ, YZX, ZXY, ZYX)

When we refer to the "rotation controller type" (or just rotation type), we are indicating whether a rotation animation is expressed in terms of Quaternions or in terms of Euler Angles. When rotation data is expressed in terms of Euler Angles, it is expressed in terms of some specific rotation axis order (such as XYZ or YZX). The rotation controller type of the original source animation data will have been chosen by the format-specific plugin which brought the source data into PolyTrans-for-3dsMax. Generally, the rotation controller type of the original source animation data could vary from object to object, from camera to camera, and from light to light.

If and when animation resampling occurs on a rotation channel, the resampling process must select a target rotation type. Since repetitive-order Euler rotations (XYX, ZXZ, etc) of the source animation data are not entirely compatible with 3ds Max's repetitive-order Euler rotations, it is sometimes necessary to pick an arbitrary rotation type as output for the resampling process. This arbitrary choice is left in your hands and is selected via this drop-down box.

Whenever the original rotation type can be replicated into 3ds Max, you have a choice between keeping the original rotation type or always using one specific rotation type. That choice is controlled by the "Keep Original Rotation Controller Type When Possible" option below. If you disable that checkbox, then all rotation animation imported into 3ds Max will be forced to use the rotation type selected in the "Preferred Rotation Type" list box.

Keep Original Rotation Controller Type When Possible

If this checkbox is enabled then the resampling process will attempt to preserve the rotation controller type used in the original source animation data. This can often be accomplished, but not in all cases. When it can be accomplished, then the rotation animation imported into 3ds Max will use the same rotation controller type as the original source animation data. Otherwise, the rotation animation imported into 3ds Max will use the "Preferred Rotation Type" as specified above. You will typically want to keep this checkbox enabled, unless you have specific reasons for wanting all your 3ds Max rotation animations to use the same rotation type.

NOTE: When this checkbox is enabled, rotation keyframe resampling might still occur. However, the resampled rotation keyframes will have the same rotation type as the original source animation data, when possible (or the "Preferred Rotation Type" when the original source animation data's rotation type is not compatible with 3ds Max).

NOTE: The rotation type is not to be confused with the interpolation type. The selection of rotation type determines which rotation data channels are created inside 3ds Max (either a single Quaternion channel or 3 independent Euler Angle channels), as well as which Euler Angle order to use (when the rotation type is not Quaternion). Each rotation channel created in 3ds Max must then be assigned an interpolation type, which is determined according to the relevant options above ("Preferred Interpolation Type" and "Keep Original Interpolation Type When Possible").

If this checkbox is disabled then the resampling process will use the "Preferred Rotation Method" you have specified above. If the original animation source data has a different rotation type, then resampling must occur. If the original source data has the same interpolation type as the "Preferred Rotation Method" you have specified above, then resampling will only occur if otherwise mandated.

Fix up -180/180 Degree Euler Flips (Maintain Continuity)

This option fixes imported Euler rotation channels which flip back and forth between values close to 180 degrees and -180.0 degrees, from key to key. Normally this flipping will not pose a problem unless 3ds Max "slows down" an animation for previewing in slow motion, and does sub-key interpolation (in such cases the objects may appear to randomly spin in the wrong direction at specific keys).

This option can only take effect when rotation curves are explicitly resampled during the import process.

NOTE: This option will not take effect if the 'Preferred Rotation Type' is set to Quaternion and the 'Keep Original Rotation Controller Type When Possible' is disabled.

Background Info:

There are several cases where the imported rotation animation needs to be "resampled" from one mathematical format to another, such as if the Euler order has to be changed, or when quaternion animation needs to be cross converted to Euler animation curves for 3ds Max.

The resampling process first converts the imported rotation value(s) at each keyframe to a 4x4 rotation matrix, and then the matrix is decomposed into explicit (X, Y, Z) Euler rotation angles, of the desired Euler order. The Euler angles will always be in the range -180 to 180 degrees.

The primary disadvantage of the traditional Euler decomposition method comes about when the target program (DirectX, Motion Builder, Maya or 3ds Max) attempts to view the animation in a "slow motion" mode. Since two adjacent frames might have values of, say, -179.9 and 179.9 (or vice versa) on one of the Euler angles, the sub-frame interpolation between these values will result in a quick spin through 359.8(!) degrees, rather than the intended 0.2 degree change. When a "slow motion" mode is not in effect, the user will traditionally never see the sub-frame interpolated values because the -179.9 and 179.9 rotations are absolute and correct values (needing no further interpolation between them).

Problem example: if the imported source rotations are 150.0 deg, 179.0, deg, 185.0 deg, 190.0 deg then after resampling the rotations will be 150.0 deg, 179.0 def, -175.0 deg, -170.0 deg. These are correct. However, programs like 3ds Max, Maya, Motion Builder and DirectX, during slow-motion playback where sub-frame interpolation is performed, will look at the 179.0 to -175.0 degree interval and create new interpolated values through a 354 degree rotation interval and not the shorter 6 degree rotation.

What This Option Does:

Enabling this option will allow an additional algorithm to be used which detects cases of "-180/180 degree Euler Flips" and attempts to fix them. This alternative algorithm will take the previous frame of animation into account when performing rotation resampling. It will attempt to decompose the rotation into a equivalent set of Euler angles which represents the smallest Euler-space change of values. This makes the algorithm very good for preventing -180/180 discontinuities in the Euler animation curves. This allows "slow motion" sub-frame interpolation to function as ideally expected.

One possible down-side to this alternative algorithm is that Euler angles are free to "drift" away from the normal -180/180 range. Let us suppose you have an animation of a spinning top. Under the traditional algorithm, the top might spin from 0 to 180, then a discontinuity effect occurs, causing the next frames to go from -180 to 0 to 180, and so forth. With this option enabled, the top would spin from 0 to 180, then from 180 to 360 to 540, and so forth. There are hypothetical scenarios where users might not want that to happen. If that is the case, disable this option to ensure that all angles are clamped to the -180/180 range.

Animation Resampling and Reduction Options

Pressing this button will show the animation resampling and reduction options dialog box. This, in general, controls the precision and reduction options used globally during animation resampling (for both import and export). If you find that your imported animation data looks jittery or does not hit target translations/rotations, then reduce the tolerance values.

If you disable keyframe reduction, then resampled animation data will have a key at every frame. You might have a specific reason to desire that output. Leaving keyframe reduction enabled, but setting the tolerance values to zero, will result in a curve which perfectly fits the original curve at all frames, but has all redundant keys eliminated. For example, if a channel is actually non-animated, then leaving keyframe reduction enabled with a zero tolerance will result in far fewer keys than entirely disabling keyframe reduction.


Animation Resampling and Reduction Options

"Animation Resampling & Reduction Options:

The documentation for this dialog box can now be accessed through these two methods:

1. Display the "Animation Resampling and Reduction Options" button on the "Animation" panel of the "Import Options" dialog box inside PolyTrans-for-3dsMax, then press the Help button located on that dialog box.

2. Or, start up the stand-alone PolyTrans or NuGraf software, select the "Animation Resampling and Reduction Options" menu item from the Edit/Preferences menu, then press the Help button.


Invoking PolyTrans via MaxScript or the Function Publishing System

Invoking PolyTrans-for-3dsMax via MaxScript or the Function Publishing System

PolyTrans-for-3dsMax includes an alternative method to invoke its import and export converters within 3ds Max using MaxScript or the "Function Publishing System". This will only work in 3ds Max 4.0 or newer.

NOTE: PolyTrans-for-3dsMax is implemented as an independent utility panel plug-in and hence the built-in import/export commands of MaxScript do not apply to it. Instead PolyTrans-for-3dsMax includes two exposed functions that are accessible through the 3ds Max 4.x (or newer) "Function Publishing System", PolyTrans.Import() and PolyTrans.Export().

Invoking a PolyTrans Import Converter

The MaxScript syntax to import a file into 3ds Max via PolyTrans is as follows (all the arguments would normally be provided on one MaxScript line):

Status = PolyTrans.Import

"filename in quotes"

"importer GUID in quotes (optional)"

"option string in quotes (optional)"

0 0 0 0

The return "Status" integer will be TRUE (non-zero) if an error occurred or the import process was aborted. Otherwise FALSE (0) will be returned for a successful import.

The four "0 0 0 0" integers are just place holders. They do nothing at present. Just set them to four zero integers.

If the "importer GUID in quotes" argument is not null (quotes "" back to back) then an importer which matches the specified GUID will be used to load in the file. For example, the GUID for the Wavefront OBJ importer is {B38F3C58-FDA7-4930-8F2E-F1612B01DC8B}. The GUID must be specified with the curly brackets as well. You can find most GUIDs by examining the .rti files located in the "vcplugin" directory of the main PolyTrans or NuGraf directory. Otherwise, if the argument is "" an importer will be invoked based on the file extension of the file (ie: the 3D Studio importer if the file extension is .3ds).

The "option string in quotes (optional)" argument specifies 0 or more additional text arguments in one single string, separated by commas or spaces. If the argument is set as "" then no options are expected. The valid tokens that can be provided in this argument string are:

-show_importer_options

If this option is specified then the options dialog box for the PolyTrans importer (such as .3ds) will be shown. If not specified, the import options dialog box will not be shown.

-display_queued_messages

If this option is specified then any error or warning messages encountered during the import process will be displayed in a dialog box.

-ok_to_ask_user_to_autoresize_viewports

If this option is specified then you will be prompted with a dialog box asking whether the view ports should be auto-resized around the imported data. The corresponding option on the PolyTrans-for-3dsMax import options dialog box must also be enabled.

-ok_to_ask_to_add_default_light_sources

If this option is specified then you will be prompted with a dialog box asking whether 2 default light sources should be added to the scene (if there are none in the imported data). The corresponding option on the PolyTrans-for-3dsMax import options dialog box must also be enabled.

-dont_autoset_animation_length

If this option is specified then the import converter will not ask if the animation length inside 3ds Max should be changed to match that of the imported file.

Examples:

1) The first example auto-loads the file.3ds. Note the two null strings.

PolyTrans.Import "d:\\models\\file.3ds" "" "" 0 0 0 0

2) The second example explicitly uses the Wavefront OBJ importer (specified via the GUID) to load in the file "file.obj". Two options are provided in a single string, -show_importer_options and -display_queued_messages.

PolyTrans.Import "d:\\models\\file.obj"

"{B38F3C58-FDA7-4930-8F2E-F1612B01DC8B}"

"-show_importer_options, -display_queued_messages" 0 0 0 0

Notes:

-You MUST surround all strings with double quotes.

- If you don't want to specify any string arguments then use "" quotes.

- If you use the backslash character (\) in the filename then you must double them up (\\). See the example above. Alternatively, use the forward slash character for filenames (/).

Invoking a PolyTrans Export Converter

The MaxScript syntax to export a file from 3ds Max via PolyTrans is as follows (all the arguments would normally be provided on one MaxScript line):

Status = PolyTrans.Export

"filename in quotes"

"option string in quotes"

"exporter file type in quotes"

"exporter match string in quotes"

"exporter GUID in quotes"

0 0

The return "Status" integer will be TRUE (non-zero) if an error occurred or the export process was aborted. Otherwise FALSE (0) will be returned for a successful export.

The two "0 0" integers are just place holders. They do nothing at present. Just set them to two zero integers.

The export converter can be selected in one of several ways. You MUST specify one of the following three strings. The other two of the three strings can be set to "" (empty string):

"exporter file type in quotes"

This string argument specifies the export converter based on the file extension; for example, you would use the string argument ".3ds" to invoke the 3D Studio export converter. You must surround the file extension with double quotes. The list of supported file extensions can be found on the PolyTrans-for-3dsMax export list box.

"exporter match string in quotes"

The string argument represents the name of the PolyTrans export converter. You must take this string from the text shown on the PolyTrans-for-3dsMax export list box. For example, if the list box has the string "Wavefront Files" then you can use this string as the string argument. Internally PolyTrans-for-3dsMax will compare your specified string against each of the supported export converters - if a match is made then that export converter will be invoked.

"exporter GUID in quotes"

If the "exporter GUID in quotes" argument is not null (quotes "" back to back) then an exporter which matches the specified GUID will be used to save out the file. For example, the GUID for the Wavefront OBJ exporter is {C0E402F6-6796-4284-A8FC-FCCFBEE6EF84}. The GUID must be specified with the curly brackets as well. You can find most GUIDs by examining the .rti files located in the "vcplugin" directory of the main PolyTrans or NuGraf directory.

The "option string in quotes (optional)" argument specifies 0 or more additional text arguments in one single string, separated by commas or spaces. If the argument is set as "" then no options are expected. The valid tokens that can be provided in this argument string are:

-show_exporter_options

If this option is specified then the options dialog box for the PolyTrans exporter (such as 3D Studio) will be shown. If not specified, the export options dialog box will not be shown.

Examples:

1) The first example exports the database to the file.3ds. The 3D Studio exporter is selected based on the ".3ds" file type string. Note the three null strings.

PolyTrans.Export "d:\\models\\file.3ds" "" ".3ds" "" "" 0 0

2) The second exports the database to the file.3ds. The 3D Studio exporter is selected based on the "3D Studio" match string. Note the three null strings.

PolyTrans.Export "d:\\models\\file.3ds" "" "" "3D Studio" "" 0 0

3) The third example explicitly uses the Wavefront OBJ exporter (specified via the GUID) to save out to the file "file.obj". A single option is provided in a single string, -show_exporter_options. Note the two null strings.

PolyTrans.Export "d:\\models\\file.obj" "-show_exporter_options" "" ""

"{C0E402F6-6796-4284-A8FC-FCCFBEE6EF84}" 0 0

Notes:

-You MUST surround all strings with double quotes.

- If you don't want to specify any string arguments then use "" quotes.

- If you use the backslash character (\) in the filename then you must double them up (\\). See the example above. Alternatively, use the forward slash character for filenames (/).

Example Batch Exporter Maxscript

The following Maxscript file was submitted by Jim Napier, Idea Spectrum, Inc. It shows how a directory full of .max files can be batch converted to .3ds format by way of the PolyTrans-for-3dsMax function publishing interface. Copy this text into a text file and execute using Maxscript. Modify the source directory accordingly.

-- GetFilesRecursive... Get files recursively based on the passed root

-- directory.

--

fn GetFilesRecursive root pattern =

(

dir_array = GetDirectories (root+"*")

for d in dir_array do

(

join dir_array (GetDirectories (d+"*"))

)

my_files = #()

for f in dir_array do

(

join my_files (getFiles (f + pattern))

)

my_files

)

------------------------------------------------------------------------------

-- Batch3DSFiles... Open all Max files and export as 3DS.

--

fn Batch3DSFiles root =

(

max file new

src_files = GetFilesRecursive root "*.max"

for f = 1 to src_files.count do

(

src_file = src_files[f]

dest_name = (GetFilenameFile src_file)

dest_file = (GetFilenamePath src_file) + dest_name + ".3ds"

print ("Exporting " + src_file + " to " + dest_file)

LoadMaxFile src_file

PolyTrans.Export dest_file "" ".3ds" "" "" 0 0

)

print ("Export complete. " + (src_files.count as string) + " files exported.")

)

------------------------------------------------------------------------------

-- Run script

--

print "Exporting 3DS files..."

Batch3DSFiles "c:\\max_files_to_be_exported\\"

Function Definitions for the 3ds Max Function Publishing System

For programmers who wish to call the two exposed functions of the PolyTrans utility panel plug-in from their own plug-ins, the interface and functions are defined as follows:

Exposed Interface name = "PolyTrans"

Interface ID = (0xdc8702c, 0x30e92566)

Function name # 0 = "Import", return argument = TYPE_INT

_T("Filename"), 0, TYPE_STRING,

_T("ImporterGUID"), 0, TYPE_STRING,

_T("OptionString"), 0, TYPE_STRING,

_T("DummyPlaceholderArgument1"), 0, TYPE_INT,

_T("DummyPlaceholderArgument2"), 0, TYPE_INT,

_T("DummyPlaceholderArgument3"), 0, TYPE_INT,

_T("DummyPlaceholderArgument4"), 0, TYPE_INT,

Function name # 1 = "Export", return argument = TYPE_INT

_T("Filename"), 0, TYPE_STRING,

_T("OptionString"), 0, TYPE_STRING,

_T("ExporterFileType"), 0, TYPE_STRING,

_T("ExporterMatchString"), 0, TYPE_STRING,

_T("ExporterGUID"), 0, TYPE_STRING,

_T("DummyPlaceholderArgument1"), 0, TYPE_INT,

_T("DummyPlaceholderArgument2"), 0, TYPE_INT,


Okino .bdf File Transfer Format Information

This help section describes the importance of the Okino .bdf Transfer File format to your data translations. This file format is the best way to move between 3ds Max and other 3D packages which read/write the Okino .bdf Transfer File format directly, such as the Okino NuGraf software, the Okino stand-alone PolyTrans program, or Maya (which has native PolyTrans plugin support). If you don’t use these programs then this section will have no bearing on your 3D data translations

First, it should be explained how PolyTrans works. An import/export process in PolyTrans proceeds in 2 stages. For export, the data must first be transferred from the internal 3ds Max database to the internal PolyTrans database; the PolyTrans internal database is one of the most extensive of any 3D program as it can natively store data from most 3D packages, such as 3ds Max, LightWave, Maya, etc. Once the 3ds Max data has been successfully mapped to equivalent entities inside the PolyTrans database, the selected export converter module (such as the PolyTrans Wavefront OBJ exporter) walks through the PolyTrans internal database and exports the data to its particular file format, in this case Wavefront OBJ. This 2 step process is necessary to make the PolyTrans exporters independent of whatever program they are accepting data from. For an import process, this 2 step process is reversed in such way that the import converters feed data to the PolyTrans internal database, then the PolyTrans internal database is mapped/copied into the 3ds Max internal database.

Now that you understand the concept of the PolyTrans internal database, you will understand why the Okino .bdf File Transfer format is significant. In a nutshell, the Okino .bdf File Transfer format is a complete snapshot of the internal PolyTrans database saved to a disk file. Thus, this .bdf file contains the most complete description of the 3ds Max translated database. Now, if two programs cannot be connected together directly (such as Maya and 3ds Max), then the .bdf file format can be used to create a pseudo-data pipeline between the two programs, just as if they were connected directly through the PolyTrans internal database.

Why is the .bdf file format so important to my data translation work?

The Okino .bdf Transfer File format will only have significance to you if you wish to transfer data to/from 3ds Max and one of:

· The stand-alone Okino NuGraf program

· The stand-alone PolyTrans program

· Maya (which has native PolyTrans plugin support).

· Or, any 3D program which has native .bdf file support (no others at this time).

Moving Data Between 3ds Max and Maya

In particular, those with Maya will want to use the .bdf file format at all times to move data to/from 3ds Max and Maya. Okino has developed a native plugin version of PolyTrans for Maya. Since 3ds Max can’t read/write Maya files, and Maya can’t read/write 3ds Max files, the .bdf file format is the best method to cleanly transfer data between these two programs. In essence, the .bdf format forms a conduit or data pipeline between the two programs just as if they were connected directly with the PolyTrans internal database forming the connecting bond.

To reiterate, to move 3ds Max data to Maya, stand-alone PolyTrans or NuGraf, export out a .bdf file from 3ds Max then read it into these application programs. Vice versa, a .bdf file can be written out by any of these programs and read into 3ds Max directly. Inside Maya, the .bdf file is read/written using the special PolyTrans plugin module for Maya.


Hierarchies Convert Between Maya, PolyTrans and Other 3D Programs

How Hierarchies Convert Between 3ds Max, PolyTrans and Other 3D Programs

One of the truly hardest parts of writing a good data translation system is the proper and clean conversion of object hierarchy. Object hierarchy defines the relationship of one connected object to another, such as a human hand connected to the forearm, connected to the upper arm and then connected to the torso.

3D computer graphics complicates hierarchy conversion with such issues as pivot points, different methods of applying or inheriting transformations and related animation curves and whether object nodes can be directly connected to other object nodes or whether they can be connected to ‘null nodes’ (joints) only.

The entire jist of this overview is to explain that Okino’s PolyTrans software does not allow object nodes to be connected directly to other object nodes. Many 3D software packages available today (3ds Max, LightWave, Maya, Cinema-4D, etc). began their lives in the early to mid 1980’s as other lesser 3D software programs (CAD-3D, Journeyman, Alias 1.0); in those days it was common to allow objects to be connected to objects. For our discussion, we define an ‘object’ as some type of data inside a 3D program which encapsulates raw geometry data, such as meshes, NURBS or quadrics. 3ds Max and LightWave still allow objects to be connected to objects at the time of this writing.

When Okino began development of its NuGraf and PolyTrans software in 1988 it realized the limitations of allowing objects to be connected to objects: if you move a parent object then all children objects move with it. Programs such as 3ds Max get around this limitation by internal hacks in which anti-transformations are applied to the object children to keep them stationary while the parent object is moved about the scene.

In 1988 Okino realized that a pure DAG hierarchy system would be much better to use to store object hierarchy. The idea came from the Alias Research ‘Power Animator’ software package of the time. In this system the hierarchy tree is formed by ‘null nodes’ (think of them as joint nodes) which form a type of ‘skeleton’. The relative location of each node defines the location and orientation of each joint in a hierarchy. Then, the objects themselves (which contain the geometry) are hung off each null node.

To put it another way, the hierarchy tree is defined by ‘null nodes’ (no geometry) and all object nodes (which contain the geometry) are always leaf nodes in the tree.

Or to put it in very simple terms, PolyTrans only allows null nodes to be connected to other null nodes. In addition, objects can only be connected to null nodes.

This can sound very confusing but the following diagrams are meant to provide a visual counter-explanation.

Hierarchy as Defined by 3ds Max (and LightWave)

In many 3D software packages which originated from the mid-1980’s the software would allow objects to be directly connected to other objects, objects to be connected to null nodes, or null nodes to be connected to other null nodes. This is exemplified by the following diagram:

To reiterate, null nodes are nothing more than an object node with no geometry associated with it; they are used to define a relative position and orientation in a hierarchy or skeleton to which other children can use as a new local coordinate system. In PolyTrans lingo these null nodes are called ‘Yellow Folders’, or ‘Empty Instances’. In 3ds Max these are called ‘Dummy Objects’ and in LightWave these are called ‘Null Objects’.

These null nodes often contain a 4x4 transformation matrix that define the relative location and orientation in the hierarchy. In addition, they sometimes contain a ‘pivot point’ definition which defines yet another local coordinate system about which the animation, scales and rotates are to applied. How the pivot point is defined is completely different in PolyTrans, Maya, 3ds Max and LightWave (if only we could have all sat down and had a meeting in 1985 to come up with a general solution!). PolyTrans has the most general pivot point system (a secondary 4x4 transformation matrix); 3ds Max and LightWave provide for a translation-only pivot point; Maya assumes the pivot points are located at the origin of each mesh.

Hierarchy as Defined by Okino’s PolyTrans and NuGraf

As mentioned above, Okino decided to implement its hierarchy system as a series of DAG nodes into a DAG tree (DAG means ‘directed acyclic graph’). In this system the hierarchy is defined by connected null nodes, and objects can only be the leaf nodes in the tree. This is a good system because objects can be moved without affecting any of their children. In addition, if any branch of the tree is to be moved then only the parent null node has to be selected and transformed. If you don’t want a specific portion of the hierarchy tree to be affected by transformations, then DAG trees implicitly allow for this.

The following diagram is a DAG equivalent to that same 3ds Max hierarchy diagram shown above. All we have done is to replace each object node with a new null node, and propagate the original object nodes to be children of the new null nodes.

This hierarchy behaves exactly the same as the original 3ds Max hierarchy. Several times per year we receive email saying that PolyTrans has bugs in it because the hierarchy has been mucked up. We assure all readers that the hierarchy will work the same in PolyTrans as it did in the source 3D software program.

Hierarchy as Defined by Maya

After we began development of the new PolyTrans-for-Maya software we quickly realized that Maya inherited (no pun intended) the same DAG hierarchy system as that used by the early Alias Research software packages, in particular Power Animator of the late 1980’s (from which the PolyTrans DAG hierarchy system was chosen).

Although opaque to users, Maya too only allows null nodes to be connected to other null nodes, and objects only to be connected to null nodes (in comparison with 3ds Max and LightWave which allows objects to be connected to objects).

In Maya, everything works on the principle of ‘Transform Nodes’ with optional child ‘Shape Nodes’. All the hierarchy nodes you see in the ‘Outliner’ or the ‘HyperGraph’ are actually just the Transform Nodes. These Transform Nodes contain the 4x4 transformation matrix, the assigned animation curves and the pivot point information. If there is geometry associated with the transform node then it is stored in a Shape Node which is made a child of the Transform Node; the material and textures are assigned to the Shape Node only. Normally the Shape Nodes are not shown in any display window inside Maya unless you enable the ‘Shape Nodes’ option.

The Maya hierarchy system is very similar to that in PolyTrans. Maya uses the concept of Shape Nodes connected to Transform Nodes whereas PolyTrans uses the concept of Object Nodes (equivalent to Shape Nodes) connected to Empty Instances (Transform Nodes). In PolyTrans the object nodes (turquoise icons in the user interface Selector Window) are always visible whereas in Maya they are implicitly made hidden. To make the imported PolyTrans hierarchy look cleaner within Maya, the PolyTrans Object Nodes are converted into children Shape Nodes of a corresponding Maya Transform Node; this will make the hierarchy appear cleaner.

Another nice benefit of this clean-up process is that the imported hierarchy into Maya will now appear to be exactly the same as it did in 3ds Max or LightWave. The relationship of the nodes, and the naming of the nodes will be the same in Maya as they appeared in 3ds Max or LightWave; however, Maya internally makes the distinction of having the object nodes be hidden children of the main Transform nodes which form the hierarchy tree.

It should also be noted that in certain cases PolyTrans may have to introduce new Transform Nodes into the Maya hierarchy tree when animation is present. As mentioned previously, Maya does not have the same capabilities to import pivot point information as other 3D programs, especially if the pivot is associated with a Transform Node with no child Shape Node. If a node-pair contains a Shape Node then PolyTrans will embed the inverse pivot point in the mesh vertices or NURBS Cvs; if a Transform Node exists with no corresponding Shape Node geometry them PolyTrans must add a new child Transform Node called an ‘anti-pivot’ node which will contain the inverse pivot point location and orientation. All of this is necessary to place the proper pivot points into the hierarchy graph when animation data is present.


Notes about Transferring Camera Field-of-View Between 3ds Max and Other 3D Programs

You may be surprised to hear that converting a camera's field of view parameter between different software packages is one of the more challenging aspects of the PolyTrans software's development over the last decade. Polygons convert to polygons in most 3d file formats, but a camera's field-of-view invariably has little direct relation from one 3D program to the next. This section provides some cursory overview notes about this.

Some conventions:

3ds Max:

A camera's field of view is measured horizontally. This means that no matter how you change the render resolution of the final image the same contents will be seen between the horizontal extents of the camera; the vertical field of view will change according to the current image render resolution.

In the modeling view ports, right click on the camera name (in the upper left corner of the view port) and enable the "Show Safe Frame". The portion of the viewport within the yellow rectangle is the area which will be seen when you do a full rendering to an image. This is also the area that PolyTrans will preserve when converting the FOV to other programs.

Maya:

Maya's field of view is one of the more complex ones to convert. The actual contents of a rendered image in Maya is dependent upon a camera's Film Gate (such as 35mm Anamorphic), the Fill Fit mode, focal length and the current Global Render Resolution. PolyTrans takes all of these attributes into effect and exports FOV as equal horizontal and vertical FOV values (actually, internally PolyTrans uses a square "projection plane" computed from Maya's vertical FOV, then enables the "Type4" overscan film fit mode to stretch the FOV automatically in the horizontal direction).

Maya actually animates the focal length and not the FOV (as does 3ds Max). However, PolyTrans will convert the focal length animation to FOV animation via the PolyTrans-for-Maya plug-in system.

In the modeling view ports, from the "View" menu, enable the "Resolution Gate" menu option. The black rectangle is the area which will be seen when you do a full rendering to an image. This is also the area that PolyTrans will preserve when converting the FOV to other programs.

Converting Between 3ds Max and Maya

When converting from Maya to 3ds Max, PolyTrans-for-3dsMax will take the vertical FOV value and convert it to a horizontal FOV value based on the Global Rendering Resolution set in Maya and passed over to 3ds Max via the .bdf file format. This conversion will occur for static or animated cameras. It has been fully tested and mathematically tweaked using special test cases.


Potential Speedups of the PolyTrans to 3ds Max Transfer

Potential Speedups of the PolyTrans to 3ds Max Transfer Process:

Importing data into 3ds Max is a two step process:

1. Importing from the source file into the Okino scene graph and SDK.

2. Converting from the Okino scene graph into the 3ds Max scene graph.

Step # 2 can sometimes be a slow process. 3ds Max tends to import scenes with thousands to hundreds of thousands of objects slowly. It is not the number of polygons which hinders the import speed but rather the sheer number of objects in the scene. This has often been a problem with various animation programs once the number of objects exceed 5000, 10000 or even 50000 objects. If you blindly import a source file without considering the object count then you may end up experiencing such a slow import. In addition, a high number of objects in the 3ds Max scene graph (with few polygons per object) will result in slow redraw speeds and rendering times.

There is no "one single answer" to speeding up this process, but these are common suggestions which may apply to your situation:

1. On each Okino CAD importer make sure you keep the "Hierarchy Optimizer" (or "Optimize Hierarchy") checkbox enabled – it is also known as "Optimize scene" or "Compress & Optimize Number of Objects" on other Okino importers. This is Okino’s unique and proprietary scene optimizer that is the "black magic" which allows very large files to be efficiently imported into 3ds Max. It does not modify the geometry in any way but rather compress the scene hierarchy (object hierarchy) so many fewer objects and/or hierarchy nodes are imported. Enabling this option will make a night & day improvement in import speed for many files with more than a few hundred objects and grouping nodes in them.

2. On Okino’s BREP solids-based CAD importers keep the "Topology = Bodies" radio button or list box option enabled, if not grayed out (unavailable). This is accessible from the "Expert" mode and "Advanced Options" in some Okino CAD importers such as SolidWorks, Solid Edge, Inventor, etc. If you use the "Topology = Faces" option, especially without the "Hierarchy Optimizer" option enabled, then you’ll get a very large number of objects which will take a long time to import.

3. If, after import, you still find that there are more hierarchy (grouping) nodes and children objects than you desire, then there is a simple, direct solution. Press the "Options…" button located to the right of the "Optimize Hierarchy" or "Compress & Optimize Number of Objects" checkbox (as described in the first paragraph) and change the "Number of times to run this optimization process" number. The default is 1, which will be more than adequate for most models. In general, good numbers to use are 1, 2, or 3. This number determines how many times the optimizer will be run on the scene before being imported into 3ds Max. In some cases you can cause the entire scene to collapse into a single object, or even just a dozen or so objects from their original thousands of objects (this will result in much faster import times and redraws in 3ds Max). Note: do not forget to return this number back to "1" for future 3D file imports.

4. If you need a more "interactive" method to choosing how many times to run the scene optimizer before importing the data into 3ds Max, then use this tried and true method. This is the primary method Okino teaches many of its customers for truly massive file imports:

· First, import the file into Okino’s stand-alone PolyTrans or NuGraf program. Keep the "Number of times to run this optimization process" number set to "1", as described in the last paragraph. Okino’s stand-alone software is an order of magnitude more efficient at loading large files than 3ds Max. It can be considered a "stepping stone" between massive files which 3ds Max cannot handle, and much more efficient files which 3ds Max will be able to load easily. The software is regularly tested and optimized for a large 550,000 node scene (which is about 10 to 20 times larger than what should normally be imported into 3ds Max).

· Second, examine the scene hierarchy in the "Selector Window" in the upper-right corner of the Okino stand-alone software. Examine each yellow grouping folder and see how many children objects are contained in a sampling of them. This will be a purely subjective choice to make – let’s say that there are 50 children in each grouping folder, and there are dozens to hundreds of such grouping folders. If this is the case, execute the "Optimize Number of Objects and Folders" command from the "Win" menu of the Selector Window. This is exactly the same as if the CAD importer executed the "Optimize Hierarchy" function itself, except that we are invoking it another time. The scene will then become faster to redraw (and interact with) and the scene hierarchy will become a lot "tighter". Save this scene out to the Okino .bdf file as an intermediate step. Now, repeat the process outlined in this paragraph multiple times until you are happy with the number of objects which are shown in the "Selector Window", as well as the scene’s redraw speed. In general terms, we find that 1 or 2 additional executions of the scene optimizer will most often reduce a massively complex file down to just a few dozen or hundred objects. You can also look at the "Scene Statistics" available from the Translate! Menu (PolyTrans program) or File menu (NuGraf program) - this dialog box will list how many instances and object definitions are contained within the scene, and provide you some numerical feedback in terms of the overall scene complexity (scenes with tens of thousands, or more, of instances and/or objects are on the more complex side which should be optimized further).

· Third, once you are happy with the state of the imported scene, save it out to an Okino .bdf file (binary data transfer file format) and then load it into 3ds Max using PolyTrans-for-3dsMax. At this point the .bdf file should load rather quickly into 3ds Max.