X3D, Classic VRML and VRML 2.0 Importer

Overview of the X3D, Classic VRML and VRML 2 Import Converter

In the realm of writing import converters this X3D and VRML 2.0 import converter was one of the more delicate and difficult to implement. X3D and VRML 2.0 are very verbose and extensive 3D scene description languages that provide much freedom of expression to write complex files. The development of this import converter has concentrated on implementing a proper and exacting import of complex VRML and X3D files, including nested PROTOS, object+camera+light+material keyframe animation and even the extraction of embedded bitmap data to stand-alone TIFF files. While there are many 3D VRML browsers, there are few stand-alone data conversion programs which properly implement the import of VRML and X3D files.

Other related links on the Okino WEB site:

• The corresponding X3D/Classic-VRML/VRML2/VRML1/Inventor2 exporter.
• Inventor/VRML1 importer.
• List of supported Okino import/export file formats.

This importer has been, without comparison, the most stable Okino importer in our history. It had been completely error free for 5 years before the new X3D file support was added. As such, we have been very happy with it, and it has proven itself to many a customer.

Click image to view full size version

How to Import VRML 1.0 and SGI Inventor 2.x Files

Okino has a sister importer to this VRML/X3D importer which handles native VRML 1.0 and SGI Inventor 2.x files (not to be confused with Autodesk Inventor native solid modeling files). This alternative importer does not, however, import animation data as does this VRML 2.0 and X3D importer.

Features of this import converter:

The following are some of the features of this converter:

• Object, camera, light and material animation using keyframe data. See below for descriptions of the animation support.
  
  
• Indexed face sets (meshes), indexed line sets, 3D point sets, extrusions, height field, box, cone, cylinder and sphere geometry is supported.
  
  
• Triangle primitives: TriangleSet, IndexedTriangleSet, TriangleFanSet, IndexedTriangeFanSet, TriangleStripSet and IndexedTriangleStripSet.
  
  
• Unique support for importing of X3D NURBS surfaces and NURBS curves.
  
  
• Vertex normals, vertex texture coordinates, vertex colors, per-face colors and material assignments are supported for the indexed face set geometry.
  
  
• For IndexedFaceSets and IndexedLineSets geometry, colors (in addition to VRML/X3D Materials) can be assigned on a per-vertex or per-face basis. If assigned on a per-face basis, the face colors are converted to polygon-assigned NuGraf/PolyTrans materials. Any inherited texture maps will be assigned to these per-polygon materials as well.
  
  
• User options are available to import a specific sub-child of LOD (level of detail) nodes.
  
  
• VRML and X3D hierarchy is recreated, including support for DEF/USE and nested PROTOs.
  
  
• Unique support for the X3D CAD working group extensions: CADassembly, CADpart and CADface.
  
  
• External references are supported, whereby external VRML/X3D files are inserted into the main hierarchy tree of the source file.
  
  
• If geometry is DEFd then USEd more than once in the VRML/X3D file (ie: the geometry is instantiated multiple times), then this converter will create one object definition internally and create multiple instances of the object definition (to replicate the behaviour of VRML).
  
  
• Each Material parameter is imported and stored, including diffuse & specular colors, ambient intensity, luminous color, shininess and transparency.
  
  
• The directional, point and spot light sources are properly imported as well as their related parameters.
  
  
• File-referenced bitmaps and embedded texture bitmaps are supported.
  
  
• Bitmaps which are embedded within the VRML/X3D file are automatically extracted and converted to TIFF files on disk. The images are also displayed on the screen as they are being imported.
  
  
• The various fields of the Transform node (scale, rotation, translation, center, scale orientation) are imported and converted to an equivalent 4x4 transformation matrix.
  
  
• Fog and Backgrounds (color only) are imported and converted to equivalent forms.
  
  
• Viewpoint nodes are converted to perspective cameras.
  
  
• An optional optimization algorithm can be enabled after import is completed to remove redundant nodes from the scene graph and hierarchy.
  
  
• Global and per-node metadata. WorldInfo imported as user-data.

Converter Limitations

• The rotation parameter of the TextureTransform is not supported.
  
  
• Because of the order in which scaling and translation is applied using the TextureTransform node, the TextureTransform is not fully supported for the parametric primitive such as the Box, Cone, Cylinder and Sphere when both the scale and translate parameters are non-zero. This problem is overcome for the meshed primitives through direct modification of the uv texture coordinate values.

X3D Converter Primary Limitations

This importer provides extensive support for X3D files. However, the following are not supported:

• X3D IMPORT/EXPORT statements (for inline nodes)
  
  
• EXTERNPROTOs
  
  
• Compressed X3D format.

Description of Object Animation Support

Object animation is supported in a specific manner. This implementation will allow object animation data, for example, to be imported from VRML/X3D files exported from 3DS MAX and many other VRML 2.0 and X3D files that we have come across.

Object animation is supported such that Transform nodes have PositionInterpolator or OrientationInterpolator nodes routed to them (transform nodes describe the scale, rotation and translation transformations). These interpolators must be routed from a TimeSensor node. The Transform nodes scale, rotation, and translation fields are supported for animation, whereas scaleOrientation and center fields are not.

Object animation is supported as follows: A TimeSensors fraction_changed event-out is routed to a PositionInterpolator or OrientationInterpolators set_fraction event-in. The TimeSensor creates fractional values from 0.0 to 1.0 (corresponding to its cycle time) which are used to interpolate values in the subsequent interpolators. The interpolators value_changed event-out is then routed to a Transform nodes set_translation, set_rotation, or set_scale event-in field. The hierarchy is as follows:

TimeSensor, output = fraction_changed (value from 0.0 to 1.0)
--> PositionInterpolator, input = set_fraction, output = value_changed
--> Transform node, input = set_translation, or set_rotation, or set_scale.

Object animation import notes:

• Since a Transforms scale field is a SFVec3f, a ScalarInterpolator cannot be used with this import converter. If you need to apply scaled key framed animation, use the PositionInterpolator as a scaling interpolator with your scale values as the SFVec3f values in this interpolator. Then route it to set_scale in the Transform node.
  
  
• It is assumed by this VRML/X3D import converter that an Interpolators key field should vary from 0.0 to 1.0. Any interpolator node found to have keys outside this range will be ignored, and thus any Transform nodes routed to this interpolator will not be animated. The keys must be normalized to within the range of 0.0 to 1.0 in order to direclty associate a keyframe with a TimeSensor's fraction_changed value (which is from 0.0 to 1.0). Keys outside this range would imply that certain keyframes are not invoked by a TimeSensor, and hence this cannot be supported by Okino's software.
  
  
• A TimeSensors startTime and stopTime fields are ignored.
  
  
• In VRML/X3D, animating a parameter of the Transform node will basically just override than one field within the Transform node (such as position) without affecting the other parameters of the Transform node (such as the scale orientation or center). However, in Okinos PolyTrans and NuGraf software, any field of a Transform which is animated requires that all other Transform parameters have an animation key created as well (the transformation matrix is recreated every time the time changes, based on the current list of animation channels); this is similar to how programs such as 3DS MAX and SoftImage work as well. To overcome this problem when one or more Transform fields are animated, this import converter takes a snapshot of the VRML/X3D Transform field values (the ones without any animation applied to them) and creates keyframes for them at time 0; the animated field values are created as normal keyframe lists in NuGraf/PolyTrans. This works fine except for the case when the VRML/X3D Transform node has non-zero Center or Scale-Orientation values. Such have to be ignored when animation is associated with a Transform node since NuGraf/PolyTrans (or most other animation packages) cannot animate these parameters.

An Example of a Supported VRML/X3D Object Animation

The following sample shows the animated translation of a box. A TimeSensor, Box01-TIMER, is routed to a PositionInterpolator Box01-POS-INTERP, and this is routed to the Transform node Box01. The TimeSensor has a loop enabled and will restart at the end of the interval, which is every 10 seconds. The box moves along the path interpolated by the position interpolator.

#VRML V2.0 utf8

DEF Box01 Transform {
  translation -158.1 -85.02 92.16
  rotation -1 0 0 -1.571
  children [
  DEF Box01-TIMER TimeSensor { loop TRUE cycleInterval 10 },
  DEF Box01-POS-INTERP PositionInterpolator {
    key [ 0 0.33 0.66  1 ]
    keyValue [-158.1 -85.02 92.16,
	      -131.6 -85.02 31.07, 
	      142.9 -85.02 101.7, 
	       146 -85.02 109.5, ] },
    Shape {
      appearance Appearance {
        material Material {
         diffuseColor 0.5686 0.1098 0.6941

        }
      }
      geometry Box { size 59.9 24.15 55.07 }
   }
  ]
}
ROUTE Box01-TIMER.fraction_changed TO Box01-POS-INTERP.set_fraction
ROUTE Box01-POS-INTERP.value_changed TO Box01.set_translation

Description of Camera Animation Support

Camera animation import is supported in a specific manner. This implementation will allow camera animation data, for example, to be imported from VRML/X3D files exported from 3DS MAX and many other VRML 2.0 and X3D files that we have come across. The camera's location, orientation and field-of-view animation can be imported.

Camera animation is supported such that their nodes have PositionInterpolator, OrientationInterpolator or FieldOfViewInterpolator nodes routed to them. These interpolators must be routed from a TimeSensor node..

Camera animation is supported as follows: A TimeSensor’s fraction_changed event-out is routed to a PositionInterpolator, OrientationInterpolator’s or FieldOfViewInterpolator's set_fraction event-in. The TimeSensor creates fractional values from 0.0 to 1.0 (corresponding to it’s cycle time) which are used to interpolate values in the subsequent interpolators. The interpolator’s value_changed event-out is then routed to a camera node’s set_position, set_orientation or set_fieldOfView event-in field. The hierarchy is as follows:

TimeSensor, output = fraction_changed (value from 0.0 to 1.0)
	--> PositionInterpolator, input = set_fraction, output = value_changed
	--> Camera node, input = set_position, set_orientation or fieldOfView.

An Example of a Supported VRML/X3D Camera Animation

The following sample shows the animation of a camera. A TimeSensor, Camera01-TIMER, is routed to a PositionInterpolator Camera01-POS-INTERP, and this is routed to the camera's look-from location. The TimeSensor has a loop enabled and will restart at the end of the interval, which is every 3.33 seconds. The camera moves along the path interpolated by the position interpolator. Likewise, a rotation interpolator is used to define the look-at viewing direction of the camera. Field-of-view animation is also supported but not shown in this example.

#VRML V2.0 utf8

DEF Camera01 Viewpoint {
  position -236.4 0 96.12
  orientation 0 1 0 -1.112
  fieldOfView 0.6024
  description "Camera01"
}
DEF Camera01-TIMER TimeSensor { loop TRUE cycleInterval 3.333 },
DEF Camera01-POS-INTERP PositionInterpolator {
  key [0, 0.03, 0.06, 0.09, 0.12, 0.15, 0.18, 0.21, 0.24, 0.27, 0.3, 
      0.33, 0.36, 0.39, 0.42, 0.45, 0.48, 0.51, 0.54, 0.57, 0.6, 0.63, 
      0.66, 0.69, 0.72, 0.75, 0.78, 0.81, 0.84, 0.87, 0.9, 0.93, 0.96, 
      0.99, 1, ]
  keyValue [-236.4 0 96.12, -227.4 0 89.71, -218.1 0 83.72, -208.4 0 78.15, 
    -198.5 0 73.01, -188.2 0 68.29, -177.6 0 63.99, -166.8 0 60.12, 
    -155.6 0 56.67, -144.1 0 53.64, -132.3 0 51.04, -120.2 0 48.86, 
    -107.8 0 47.1, -95.15 0 45.76, -82.15 0 44.85, -68.84 0 44.36, 
    -55.22 0 44.29, -41.31 0 44.65, -27.08 0 45.43, -12.55 0 46.63, 
    2.279 0 48.26, 17.42 0 50.3, 32.86 0 52.77, 48.61 0 55.67, 
    64.66 0 58.99, 81.02 0 62.73, 97.68 0 66.89, 114.7 0 71.48, 
    131.9 0 76.49, 149.5 0 81.92, 167.4 0 87.77, 185.6 0 94.05, 
    204.1 0 100.8, 222.9 0 107.9, 229.2 0 110.3, ] },
DEF Camera01-ROT-INTERP OrientationInterpolator {
  key [0, 0.03, 0.06, 0.09, 0.12, 0.15, 0.18, 0.21, 0.24, 0.27, 0.3, 
      0.33, 0.36, 0.39, 0.42, 0.45, 0.48, 0.51, 0.54, 0.57, 0.6, 0.63, 
      0.66, 0.69, 0.72, 0.75, 0.78, 0.81, 0.84, 0.87, 0.9, 0.93, 0.96, 
      0.99, 1, ]
  keyValue [0 1 0 -1.112, 0 1 0 -1.118, 0 1 0 -1.123, 0 1 0 -1.127, 
    0 1 0 -1.129, 0 1 0 -1.129, 0 1 0 -1.126, 0 1 0 -1.12, 
    0 1 0 -1.111, 0 1 0 -1.096, 0 1 0 -1.075, 0 1 0 -1.045, 
    0 1 0 -1.003, 0 1 0 -0.9441, 0 1 0 -0.8593, 0 1 0 -0.736, 
    0 1 0 -0.5559, 0 1 0 -0.3006, 0 -1 0 -0.02207, 0 -1 0 -0.3524, 
    0 -1 0 -0.6231, 0 -1 0 -0.8175, 0 -1 0 -0.9513, 0 -1 0 -1.044, 
    0 -1 0 -1.109, 0 -1 0 -1.157, 0 -1 0 -1.191, 0 -1 0 -1.217, 
    0 -1 0 -1.236, 0 -1 0 -1.239, 0 -1 0 -1.24, 0 -1 0 -1.24, 
    0 -1 0 -1.239, 0 -1 0 -1.237, 0 -1 0 -1.236, ] },
ROUTE Camera01-TIMER.fraction_changed TO Camera01-POS-INTERP.set_fraction
ROUTE Camera01-POS-INTERP.value_changed TO Camera01.set_position
ROUTE Camera01-TIMER.fraction_changed TO Camera01-ROT-INTERP.set_fraction
ROUTE Camera01-ROT-INTERP.value_changed TO Camera01.set_orientation

Supported VRML 2.0 and X3D Node Types

Anchor	
	Partially supported; if there is actual geometry in the node,
	 it will be imported.
Appearance 	
Background		
	Background color set to first color found in skyColor.
Billboard
	Partially supported; geometry will be imported, but will not 
	be transformed to face the camera.
Box 	
CAD Geometry
	CADAssembly, CADFace, CADLayer, CADPart
Collision 		
	Treated exactly as Group node
Color 	
ColorRGBA
	Partial support
ColorInterpolator 
	Supported for materials animation and light colour animation
Cone 	
Coordinate 	
Cylinder 	
DirectionalLight 	
ElevationGrid 	
Extrusion 	
Fog			
	Only fog node with greatest visibilityRange is used
Group 	
ImageTexture 	
IndexedFaceSet 	
IndexedLineSet	
IndexedQuadSet
IndexedTriangleFanSet
IndexedTriangleSet
IndexedTriangleStripSet
Inline 			
	Only non http paths
LineSet
LOD 			
	User specifies level of detail via VRML/X3D importer dialog box
Material
	Including diffuse, emissive, specular and colour animation, 
	and opacity, shininess, ambient intensity animation.
Metadata
Normal 	
NURBS
	Support for Contour2D, ContourPolyline2D, CoordinateDouble, 
	NurbsCurve, NurbsCurve2D, NurbsPatchSurface and NurbsTrimmedSurface.
OrientationInterpolator	
	Only used for routes in rotation animation
PixelTexture 		
	Extracted from VRML/X3D file into stand-alone TIFF image
PointLight 	
PointSet
	Random array of 3D points
PositionInterpolator 	
	Only used for routes in translation and scaling animation
QuadSet
	Part of the CAD Geometry extensions
ScalarInterpolator 
	Supported for materials animation
Shape 	
Sphere 	
SpotLight
StaticGroup 	
Switch 			
	Selects the user specified child node
TextureCoordinate 	
TextureTransform 	
	Only fully supported for Extrusion, IndexedFaceSet and ElevationGrid
TimeSensor 		
	Only TimeSensors singly routed to position and orientation interpolators
Transform 
TriangleFanSet
TriangleSet
TriangleStripSet
Viewpoint 
Worldinfo	
PROTO			
	Nested Protos are supported
DEF/USE			
	DEF/USE (object instantiation) is supported.

Unsupported VRML 2.0 and X3D Node Types

Many of the unsupported VRML/X3D node types relate to interactive behaviours (sensors) for VRML/X3D scene browsers, for multi-media related content (sound, billboards) or for data that has no significance to this 3D data import converter.

Node Name	

AudioClip 	
CoordinateInterpolator	
CylinderSensor 	
FontStyle 	
GeoSpatial nodes
H-Anim nodes
MovieTexture 	
NavigationInfo 	
NormalInterpolator 
NURBS CV interpolators	
NURBS swept and swung surfaces
NURBS NurbsTextureCoordinate
PlaneSensor 	
ProximitySensor	
Script 	
Sound 	
SphereSensor 	
Text 	
TouchSensor 	
VisibilitySensor 	

Source of VRML/X3D Data Files

If you need VRML/X3D file content, these are some sites which we have found on the Internet:

	http://www.web3d.org/
		Main portal to X3D and VRML2.

	http://www.ento.vt.edu/~sharov/3d/3dinsect.html     
		3d insect VRML/X3D  models - very interesting!

	http://www.gamespot.com/3dgallery/index.html    
		GameSpot character  models (animated)

	http://www.geo-metricks.com
		Some free VRML/X3D models

Dialog Box Options

Optimize Hierarchy

If this option is enabled (check-marked) then the imported file will be optimized so that redundant nodes in the hierarchy are deleted. You will often find that there are many redundant red folders in the imported dataset, each corresponding to a PROTO or group inside the original VRML/X3D file. Enabling this option will drastically clean up all of the redundant folders. The only drawback to enabling this option is the speed decrease of the import process.

Flip Model to that Y is Up

If this checkbox is enabled then the model will be reoriented so that the Up axis of the model will be aligned with the positive Y axis (which is used by the converter) instead of the positive Z axis as used by some VRML/X3D files, or as used by models exported from the Rhino modeler.

Remove Redundant Vertices, Normals & UV Texture Coordinates

If this checkbox is enabled then an algorithm will be invoked on each imported mesh primitive to remove all redundant vertices, normals, uv texture coordinates and vertex colors.

Create One Head Light Per Imported Camera

If this option is enabled (check-marked) then a directional light will be placed at each imported camera location, shining in the direction of view.

Use Quick Naming (for faster imports)

If this option is enabled (check-marked) then the import converter does not check whether the current database has objects with the same name as objects being imported from the VRML/X3D file. This makes import very fast for large scenes, but, if you import multiple VRML/X3D files into the same database then errors such as Instance name already exists will be reported to the error window (because unique names were not created between the multiple VRML/X3D files). This option is disabled by default.

Report Statistics about the Geometry File

If this option is enabled (check-marked) then statistics about the imported file will be printed after the file has been imported.

Create Smoothed Extrusions

If this option is enabled (check-marked) then any VRML/X3D extrusion objects imported from the VRML/X3D file will be assigned a completely smooth flag. This will make the object appear smooth without any faceting.

Compute Averaged Normals If No Smoothing Information Or Vertex Normals Found

If this checkbox is enabled then new vertex normals will be computed for a polygon if it does not have any vertex normals already, and it does not have a "crease angle" specified for it in the VRML/X3D file. The smoothing criterion is based on the angle between abutting polygons; common smoothed vertex normals will be computed if the angle between their geometric surfaces normals is less than the angle specified on the dialog box (which defaults to 45 degrees).

Secondary Options

Level of Detail Selection

If the VRML/X3D file has level-of-detail (LODs) nodes then this drop-down box specifies which of the children nodes will be imported. Level of detail allows varying levels of geoemtry detail to be displayed in a VRML/X3D browser; geometry closer to the camera will use the highest level of detail and geometry far from the camera will use the lowest level of detail. Rather than import all the LOD children via this import converter, this drop down box allows the first child to to be imported, the last child to be imported or a specific child to be imported (starting at 1).

Transparency Source

In the VRML/X3D file format specification the transparency of an object can come from one of two sources: either the explicit Transparency attribute of a Material assigned to an object, or from the alpha channel of a 32-bit RGBA texture map. Deriving the transparency of an object from the alpha channel of a texture map is useful, for example, if you have a bitmap of a window frame and you wish to make the areas of the object where the glass appears be completely or partially transparent - the 8-bit alpha channel of the bitmap can be used to determine which parts of the object will be fully opaque or partially transparent. This capability is really only of use to Okinos NuGraf Rendering System software. See the Alpha Channel Source options below to see how the alpha channel is actually pulled from the RGB or RGBA texture map.

Unfortunately, it is not always possible for this import converter to determine if the texture map in question indeed has a valid alpha channel, or that the texture map is 32-bit (RGBA format). For this reason, three options are provided on the dialog box to determine how the transparency for the imported VRML/X3D objects are to be derived:

Follow VRML/X3D Specification

If a 32-bit RGBA texture map has been assigned to an object, then the transparency of that object will be taken from the alpha channel of the texture map. If not, the transparency will be taken from the Transparency attribute of the Material definition assigned to the object. This is per the VRML 2.0 and X3D file format spefication. If the VRML/X3D importer cannot locate the texture map, or the texture map is not in RGBA format (no alpha channel present), then the transparency of the object will be used instead.

Material Transparency

Regardless of whether a texture map with an alpha channel has been assigned to an object or not, the transparency of an object will always be taken from the Transparency attribute of the Material definition assigned to the object

Alpha Value from Texture Map

Regardless of whether this VRML/X3D importer can locate the texture map or not, or if a texture map does not have an alpha channel, this option will always take the transparency of an object from the alpha channel of its assigned texture map. If no texture maps exists, or no alpha channel exists on the texture map, the object will be fully opaque.

X3D Validation Method

This combo box determines whether the imported X3D file will first be validated against the official X3D XML schema file. Validation ensures that the source X3D file is written in a proper XML format, and it also tends to speed up the overall import process.

No validation

Choosing this option will cause no X3D file validation to occur.

However, the Microsoft XML parser may complain that it cannot locate the DTD file, if you have no Internet access, and even if you set this option to "No validation".

Simple validation

Choosing this option will use the DTD file to validate the imported X3D file.

Simple validation ensures that all nodes syntactically belong to the X3D specification and contain the correct fields. Simple validation is fast, but requires a connection to the Internet.

Comprehensive validation

Choosing this option will use the complete XSD schema file to validate the imported X3D file.

Comprehensive validation ensures that the nodes conform to the semantics of the X3D specification. It is slower than simple validation, but requires no Internet connection.

Treat Errors as Warnings Only

If this checkbox is enabled then any errors output from the DTD or XSD validation routines will simply be considered a "warning" and not abort the import process.

Animation Data Loading

Object Animation

If checkmarked, then object animation is loaded.

Camera Animation

If checkmarked, then camera animation is loaded.

Light Animation

If checkmarked, then light animation is loaded This includes animation for point, directional and spot lights.

Material Animation

If checkmarked, then material animation is loaded This includes diffuse, emissive, specular and colour animation, as well as opacity, shininess, ambient intensity animation.

Meta Data Loading

The VRML/X3D file format allows for "meta data" information to be defined globally in the scene, and per entity on geometry, lights, cameras and material nodes.

The following internal Okino scene graph meta data types are supported when importing from VRML/X3D: strings, shorts, ints, floats, colors, vectors, double precision vectors, 4x4 matrices, 4x4 double precision matrices, time, double precision floats, 4 valued vectors, and 4-valued double precision vectors.

Global File-Level Meta Data

If checkmarked, then global meta data will be imported as "scene meta data" in the Okino scene graph.

Per-node Meta Data

If checkmarked, then meta data will be imported from the various VRML/X3D nodes, in particular geometry, lights, cameras, materials and textures.

The following is a snippet of a VRML2 file with per-node meta data:

Group {
  metadata MetadataSet { value [
		MetadataFloat { value [ 4 3 2.2 1 ] }
		MetadataFloat { value [ 4.1 3.2 2.2 1 ] }
		MetadataFloat { value [ 0 0  ] }
		MetadataFloat { value [ 99 ] }
		] }
  children [
    Transform {
      metadata MetadataSet { value [ MetadataString {
	value [ "value1" "value2"] } ] }
      translation -1.18587 -0.651405 -5.5323

Selective Loading

Meshes (FaceSet, Quads, Triangles, TriStrips, etc).

This controls the import of meshed data, namely these geometric primitives: IndexedFaceSet, QuadSet, IndexedQuadSet, TriangleSet, IndexedTriangleSet, TriangleFanSet, IndexedTriangleFanSet, TriangleStripSet and IndexedTriangleStripSet.

Vertex normals

If checkmarked, then vertex normals for mesh data is loaded. Vertex normals are needed to create the illusion of smoothing.

Vertex uv texture coordinates

If checkmarked, then uv texture coordinates are loaded for mesh data. These are needed to define the mapping of a 2D planar texture map to a 3D object.

Vertex colors

If checkmarked, then vertex colors are loaded for mesh data, line sets and 3D point sets. These RGB colors will override any material/shaders assigned at the global object level.

Boxes, Cones, Cylinders and Sphere

If checkmarked, then box, cone, cylinder and sphere geometric primitives are loaded.

Independent NURBS Curves

If checkmarked, then NURBS curves (not associated as trim curves to NURBS surfaces) are loaded.

3D Line Sets

If checkmarked, then 3D line sets are loaded.

3D Point Sets

If checkmarked, then 3D point sets are loaded.

NURBS Surfaces & NURBS Trim Curves

If checkmarked, then NURBS surfaces and their trim curves will be loaded.

Elevation Grids

If checkmarked, then elevation grid primitives are loaded.

Extrusions

If checkmarked, then extrusion primitives are loaded.

Lights

If checkmarked, then lights are loaded.

Cameras

If checkmarked, then cameras are loaded.

Materials

If checkmarked, then materials are loaded.

Load external file references

If checkmarked, then VRML/X3D files which are referenced externally within a master file will be loaded. If disabled, then all externally referenced files will be ignored.

Texture Map Extraction Options

Extract images from VRML/X3D files as new texture maps

VRML/X3D files have the capability of embedding raw bitmap data within their ASCII files rather than have the VRML/X3D file reference an external bitmap image. When this occurs, enabling the 'Extact images from VRML/X3D files' will extract the raw bitmap data from the VRML/X3D file and store the bitmaps on disk as stand-alone TIFF files. The resulting TIFF bitmap will also be linked to the imported 3D geometry data as a texture map so that the two align properly during subsequent renderings. If this option is un-checkmarked then no bitmap will be extracted and no texture coordinates will be assigned to the imported 3D data.

Display textures when extracting from geometry files

If this option is checked then the image that is embedded within the VRML/X3D file will be displayed while it is being loaded. Note: the picture preview window might hide the import status dialog.

Location to store extracted textures:

The two following options specify where the extracted bitmap image(s) that are sembedded within the VRML/X3D files will be stored on disk in TIFF format:

Same location as imported VRML/X3D file

The texture images that are stored in the VRML/X3D file will be saved in the same directory as the file being imported. (e.g. if the file is located in c:\vrml\, the images will also will also be stored in c:\vrml\).

In this specific directory:

This option allows you to specify a directory where the images are to be stored.

Confirm possible texture file overwrite

If the checkbox is enabled then if the extracted TIFF image file already exists on disk a dialog box is displayed to ask the user whether or not to overwrite the file.

Strip file path from all bitmap references

When this checkbox is enabled then any filepath prefixed to the imported bitmap images will be removed. This option also applies to the case where the VRML/X3D file makes explicit references to external bitmap files.

Replace all texture file paths with this file path:

This option allows an explicit file path to be prepended to each imported bitmap TIFF file. Either this option or the Strip path from all bitmap references can be checked, but not both. This option also applies to the case where the VRML/X3D file makes explicit references to external bitmap files.

Alpha Channel Source Options

As described in the 'Transparency Source' combo-box options above, this VRML/X3D import converter can feed the alpha channel of a texture map into the transparency shader channel of an object. This is useful, for example, to make a window frame (texture mapped with the image of a window frame) partially or fully transparency where the glass appears.

Several methods are available to pull an alpha channel from a texture map. Sometimes a 8-bit alpha channel is provided with a RGB image (to form a RGBA image), but in other cases you will have to derive an alpha channel through algorithmic means. Many of these options only have significance to Okinos NuGraf Rendering System software.

Alpha Channel Source

This option defines how an alpha channel is derived from texture maps used with the VRML/X3D file. These alpha channels really only have use within Okinos NuGraf Rendering System software for which the alpha channel can be used to make parts of a texture mapped object appear transparent (such as the windows inside a window frame). These options correspond directly to the alpha channel source type in the NuGraf texture definition edit dialog box:

Alpha Channel From Image

Use the alpha channel from the 32-bit RGBA input file. If there is no alpha channel then the alpha is assumed to be fully opaque.

Chroma key: upper left

Use the upper-left pixel color in the texture image as the chroma-key color. Whereever this color appears in the image, the alpha will be 0 else the alpha will be 255.

Chroma key: lower left

Same as previous option, but the chroma key color is taken from the lower- left corner of the texture map image.

Alpha Channel always opaque

Dont create any alpha channel matte for the texture images.

Invert Alpha Channel

If this checkbox is enabled (check-marked) then the alpha channel computed for the texture image will be inverted prior to its usage in the NuGraf renderer.