home  

Shout3D™ 2.5 - What's New

Some enhancements have been added with each incremental release of Shout3D. The items below are grouped by the release in which they were added, with the most recent changes first. Each item is followed by the release number in which it was added. 

New Features in 2.5

OpenGL Hardware Acceleration

Shout3D 2.5 offers an option to use a tiny plug-in that can dramatically increase performance for users with OpenGL accelerated graphics cards. See the Hardware Acceleration page.

Improved 3ds max Export

New point Field in MultiAppaearance

The MultiAppearance has a new 'point' field. It's default value is false.  Set it to true, and the shape will render only as points.

New perspectiveCorrect field in ImageTexture

The ImageTexture has a new 'perspectiveCorrect' field. It's default value is true. Set it to false, and the texture will be rendered without perspective correction. This will yield faster frame rates.

New 'h' and 'c' key controls to toggle software mode and display polygon count.

The Shout3DApplet (and hence all other applets, since the behavior is inherited)  will display a polygon count, written to the Java Console, whne you click in the applet window and press the 'c' key.  And when you press the 'h' key, it will toggle the applet between hardware and software modes.

New applet parameters to enable/disable the 'f', 'h',and 'c' keys.

The Shout3DApplet has 3 new parameters. All of these default to a value of true.  See the user guide for more details.

New Features in 2.0

Multi Texturing with MultiAppearance (2.0)

Shout3D 2.0 includes a new kind of appearance node named MultiAppearance.  This node lets you perform multi texturing by combining diffuse textures with bump mapping, environment mapping, alpha mapping, and specular level mapping in any combination.  The MultiAppearance also supports specular highlights.   There are tons of demos in the directory Shout3d_runtime/demos/renderTests directory.  There is also an interactive demo that lets you play with all the different kinds of maps and parameters.   Click hereto launch the interactive demo, or click here for more information about that demo.  Other demos are listed in the next section about the MultiMesh geometry. 

MultiMesh geometry (2.0)

Shout3D 2.0 contains a new kind of geometry called MultiMesh.  This geometry allows you to:

Most of the examples in the demos\renderTests directory use MultiMesh geometries. Here are a few examples, but there are lots more:   demos\android\android.html,
demos\interactiveRenderDemo\interactiveRenderDemo.html,
demos\renderTests\select_a_panorama_teapot.html,
demos\renderTests\multimesh_battered_chrome.html,
demos\renderTests\multimesh_specbumpmap.html.

Panorama Backgrounds (2.0)

Shout3D 2.0 is capable of rendering Panoramic Backgrounds, by inserting a Panorama node into the scene.  The images for the backgrounds are specified with an EnvironmentCubeMap -- a collection of six image in the left/front/right/back/up/down directions.   Each time Shout3D renders, it takes the current Viewpoint's orientation into account and renders the panoramic background behind the geometric elements of the scene, so the background appears to envelop the world in which the viewer is located.  Examples of this feature may be found by following these links: demos\multiTexturedTemple.html, demos\renderTests\select_a_panorama_teapot.html, demos\renderTests\select_a_panorama_curl.html. 

Skeletal Deformation (2.0)

Shout3D 2.0 contains the ability to perform skeletal deformation, including that which is authored with 3D Studio Max's Character Studio package.  Shout3D's new 3D Studio Max Exporter Plugin will export the Physique and Biped correctly (see 3D Max Pluginand 3D Max Plugin User's Guidefor more information).  Following this, the exported file will employ the new PhysiqueSkeletalDeformer node to recreate the skeletal deformation effect within Shout3D.  Examples of this exported content may be found at Shout3d_runtime/demos/biped/hopscotch.htmland Shout3d_runtime/demos/biped/pixel_doubled_hopscotch.html

Weighted Morphing (2.0)

Shout3D 2.0 allows multiple morph targets to be combined to form a weighted combination of those targets.  The targets are specified as deltas (or offsets) from a starting set of coordinates.  The result is a flexible and space-efficient way of representing a model that smoothly changes sections of the overall shape in a variety of combinations.  Common applications of this technique are for facial expressions and lip synching.

Shout3D's 3D Studio Max Exporter Plugin will successfully export multiple morph targets into Shout3D files that will play back exactly the same in the Shout3D 2.0 applets.

The technique is performed with the new ChannelDeformer and TranslationArrayDefChan nodes.  A ChannelDeformer contains a starting set of coordinates and a set of one or more TranslationArrayDefChan nodes.  Each TranslationArrayDefChan has a set of offset translations relative to the starting coordinates, and also a weight with which to apply those offsets to the starting coordinates.  The ChannelDeformer combines the effects of all TranslationArrayDefChans to produce a new shape.  By animating the weights of several TranslationArrayDefChans, complex shape changing may be realized.

Examples of this technique, exported from 3D Studio Max with our new exporter, may be found at: Shout3d_runtime/demos/morphtargets/morph_box.htmland Shout3d_runtime/demos/android/morph_android.html.  Other examples may be found in the Shout3d_runtime/demos/morphtargets directory.

H-Anim Suport (2.0)

Shout3D 2.0 contains an implementation of nodes required for the H-Anim 1.1 Specification.  The nodes provided are in the shout3d.hanim package.  and are named Displacer, Humanoid, Joint, Segment, and Site.   The new HAnimExamineApplet is a special applet which will print a description, H-Anim style, of any scene loaded into it that contains an H-Anim humanoid.   The printout is sent to the Java Console, and source code of this applet (as well as its associated HAnimExaminePanel) is provided in the Shout3d_runtime/codebase/applets directory.

To see an example, click to launch Shout3d_runtime/demos/H-Anim/H-Anim.html, then open the Java Console to see the printed information.

Progressive Antialiase (2.0)

Shout3D 2.0 comes with a new kind of antialiasing, called progressive antialiasing.  This method produces an antialiased image over the course of successive renders.  To use it, you just need to insert a StillCamProgAntialias node into your scene.  The scene will become antialiased whenever the camera stops moving.

Examples may be found in the interactiveRenderDemo, as well as many of the demos in demos\renderTests.

VRML Geometries (2.0)

The following geometry nodes from VRML97 are now included in Shout3D 2.0:

These have the same specification as their VRML counterparts, with the following additions:

The demo demos\primitiveTest.html lets you change the number of sides in the primitives.

Other demos that use these are demos\multiTexturedTemple.html, demos\primitiveTest.html, demos\elevationGridTest.html, demos\extrusionTest.html, and demos\renderTests\primitives_with_multiapp.html

NurbsSurface and NurbsLineSet (2.0)

Shout3D contains two new geometries for that draw nurbs.   These are NurbsSurface and NurbsLineSet.  They can be placed within any Shape node just like other geometry nodes.

KeyframeInterpolator and timeScale field (2.0)

Shout3D 2.0 contains a new abstract class KeyframeInterpolator serves as the base class for all the pre-2.0 Interpolators as well as all the other new interpolators, with the exception of EulerXYZInterpolator (which aggregates 3 KeyframeInterpolators and is subclassed directly from Interpolator).

The KeyframeInterpolator has a new field, timeScale, which is inherited by all the other KeyframeInterpolators.  The timeScale field allows you to think of your animations in terms of total number of seconds or frames, and therefore to set your "key" time values relative to this total number of seconds or frames.  For more information, see the documentation about the timeScale field in the Javadoc for KeyframeInterpolator .

New Spline (TCB & Bezier) and EulerXYZ Interpolators (2.0)

Shout3D 2.0 contains support for spline interpolation of two flavors: TCB (which stands for tension/continuity/bias) and Bezier.   You can also interpolator the separate XYZ channels of three euler angles with an EulerXYZInterpolator.  The following new node classes add this functionality:

3D Studio Max uses will be pleased to know that all of these interpolators will export seamlessly from the appropriate animation controllers with Shout3D's new 3D Studio Max Exporter Plugin, provided with this release.

Demos for these may be found in the demos\animTests directory.  One example may be found by following this link to demos\animTests\tcb_boxes.html.

Step Interpolators (2.0)

Shout3D 2.0 includes a complete new set of step interpolators.  These interpolators change instantaneously from one value to the next in sudden "steps" without smoothly interpolating the values.  They are useful for scripting sudden changes in a scene, like changing the choice below a Switch node, swapping one node for another, or jumping the camera to a new location.

Also included is the CurrentTimeStepInterp.  This node sends out the current time through its output whenever a the time of a key is reached.  This is useful for triggering other animations or starting the play of sounds in coordination with other animations that may be in progress. 

The complete set of step interpolator nodes is:

Two examples of these interpolators may be found at: Shout3d_runtime\demos\stepInterpolatorTest\intStepInterpTest.html and currentTimeStepInterpTest.html.  Other demos for these interpolators may be found in the Shout3d_runtime\demos\stepInterpolatorTest directory.

CoordinateNodeInterp (2.0)

Shout3D 2.0 contains the CoordinateNodeInterp.  It performs the same kinds of tasks as the CoordinateInterpolator, but uses a much more compact format.  The key values are given as references to nodes (in file format this is done with DEF/USE) instead of restatements of the lists of points.  An example may be found here at this link:  demos\coordinateNodeInterpTest.html.

FractionRemapper node (2.0)

The new FractionRemapper node lets you take the fraction from a TimeSensor and remap it to drive only a subsection of an interpolator's keyframes.  It is used by the 3D MAX exporter to properly export animations that do not begin at frame 0 in MAX.  But it may also be used to play any subsection of any Interpolator.

The node has 6 fields, inFraction, isPunchedIn, timeScale, startKey, endKey, and outFraction.

FractionRemapper watches for changes to it inFraction field, which is ordinarily routed from a TimeSensor and falls in the range [0,1]. If isPunchedIn is false (the default) the outFraction is remapped to play the specified range of keyframes (startKey to endKey) over the entire animation interval. If isPunchedIn is true, then outFraction is not remapped, however it is only passed through to the interpolator during the specified subsection of the keyframes.  The timeScale field should be set to match the timeScale in the destination interpolator. This way, the startKey and endKey may be expressed using the same timeScale as keys in the interpolator.

SimpleInline Node (2.0)

Shout3D 2.0 contains a new, simple version of the VRML Inline node, named SimpleInline. The SimpleInline has a "url" field that denotes an .s3d or .wrl file.  The contents of that file are fetched, parsed, and set as the children of the SimpleInline file whenever the url field's value changes, and also when the SimpleInline node itself is read in from file.  Following this, the children of the SimpleInline are treated like the children of any other Group node.  When the url field value changes, the new file is read/parsed, and the old children of the Inline are replaced by the children that were read/parsed from the file.

A simple example of one file that contains two SimpleInline nodes may be found at ../Shout3d_runtime/demos/simpleInlineTest.html .

The SimpleInline node differs from the VRML version in the following ways:

createNodeFromString() method (2.0)

The Shout3DApplet and Shout3DPanel each have a new method:

public Node createNodeFromString(String stringToParse)

This method creates and returns a Shout3D node by parsing the string given as an argument. The string should be the same format as a Shout3D s3d or VRML file. 


If the string denotes a node that has children, those children will be added as well. If the string contains more than one top-level node, the returned node will be a Transform node containing all of the top-level nodes in the string. This method always loads the resource in the same thread as the main thread, regardless of the setting of isLoadResourcesInSeparateThread().

A javascript example that parses 3 different strings and loads them into the applet may be found at ../Shout3d_runtime/demos/javascriptCreateFromString.html.

Resizable Applets (2.0)

Shout3D Applets and Panels may be resized now. 

Demo: there are demos that show how these features work at demos\javascript_resize.html. demos\resizable_full_screen.html,and demos\javascript_pixDble_resize.html.

Node Search Path (2.0)

Shout3D 2.0 lets you specify a node search path Node Search Path that specifies where it will look for nodes when reading a file. 

This allows you to place your custom nodes in your own packages instead of just the custom_nodes directory as was required in Shout3D 1.0.  You can even keep your classes in the same directory as your models!

New methods setNodeSearchPath() and getNodeSearchPath() are available for the Shout3DApplet and Shout3DPanel classes. There is extensive documentation on node search paths in the JavaDocs pages for those two classes.

A new applet parameter "nodeSearchPath" allows you to set the path in your html file.

Demos for working with the node search path may be found in the directory demos\nodeSearchPathTests

Render Loop Control (2.0)

In Shout3D 2.0, you pause or unpause the render thread, and while the rendering is paused you can render frames one at a time.  New API on Shout3DViewer (and hence Shout3DApplet and Shout3DPanel) allows you to control this:

There is an example of this API in action at this link:  demos\pausable_viewer_test.html

ExamineApplet enhancements (2.0)

The ExamineApplet has many new enhancements and some new demos.

The new examine applet demos are:

WalkApplet enhancements (2.0)

The ExamineApplet has many new enhancements and some new demos.

The new walk applet demos are:

Viewpoint fovMapping field (2.0)

The Viewpoint node has a new fovMapping field. The field controls which dimension of the applet will correspond to the given field of view.  The fovmapping field has 4 possible values:  "SHORTEST", "HORIZONTAL" "VERTICAL" and "DIAGONAL."

There is a new demo, in demos/javascriptChangeFovMapping.html, that lets you play with the 4 different settings.

PostRenderEffect (2.0)

Shout3D 2.0 allows you to create nodes that process the image before it is painted to the screen.  To do this, derive a node from the PostRenderEffect node and then implement the filter() method to change the image.  Examples of how to do this are provided in the custom_nodes directory, and described below.  The PostRenderEffect allows you to process the image in two ways:

You can also combine the two types of effect in one PostRenderEffect node.  The following example shows how:

Pixel Doubling (2.0)

Shout3D has a new Pixel Doubling feature. When pixel doubling is enabled, the applet will internally render the image at half size, then when it draws the image to screen, it will blow the image back up to full size. 

There are two kinds of pixel doubling: regular and smooth.  The regular pixel doubling just copies each pixel into a 2x2 block of 4 pixels.  Smooth pixel doubling adds filtering for a smoother appearance.  While smooth pixel doubling looks better for many scenes, it is also a little bit slower than regular pixel doubling.

Pixel doubling is controlled by new API on Shout3DViewer.  The new API on Shout3DViewer is comprised of three new methods, setPixelDoubling(boolean enabled, boolean smooth), isPixelDoubling(), and isPixelDoublingSmooth().  These methods are documented in the javadocs for Shout3DViewer, Shout3DPanel, and Shout3DApplet. 

Pixel doubling may also be controlled through the html file via a new applet parameter named "pixelDoubling."   This applet parameter may be set to one of 4 values:

  1. "false" means no pixel doubling
  2. "regular" means regular pixel doubling
  3. "smooth" means smooth pixel doubling
  4. "true" means regular pixel doubling

Examples of regular pixel doubling are provided in the demos directory at: demos\javascript_pixDble_resize.html, demos\biped\pixel_doubled_hopscotch.html, demos\renderTests\pixDbl_battered_chrome.html, demos\renderTests\pixDbl_multimap.html.

Examples of smooth pixel doubling are provided in the demos directory at: demos\biped\smooth_pixel_doubled_hop.html, demos\renderTests\smoothPixDblBatteredChrome.html, demos\renderTests\smoothPixDblMultimap.html.

VisibilityLimit (2.0)

The visibilityLimit field of the NavigationInfo node is now implemented.  This field sets a far clipping plane for rendering.  The far clipping plane is a plane perpendicular to the view direction, located at a distance of visibilityLimit from the Viewpoint.  Triangles which are fully behind the far clipping plane are not rendered. 

The visiblityLimit used is always that of the currently bound NavigationInfo node.  If the visibilityLimit is 0, then an infinite visibilityLimit is assumed.  A simple test which shows an animated visibilityLimit is provided in the demos section at visibilityLimitTest.html.

Line Numbers With Parsing Output To Console (2.0)

The Shout3D parser produces error and warning messages while parsing and prints these messages to the Java Console.   Examples of these messages are "skipping field" "skipping node" and "failed to parse file."   In Shout3D 2.0, these messages are all preceded by current line number of the file at the time the message is produced.  The messages are the same as in earlier versions, only the line numbers are new.

Texture API for editing Pixels (2.0)

Shout3D 2.0 adds the ability to examine and change the pixels in a texture. This allows for either image processing of the images loaded into the url of an ImageTexture, or for the algortithmic generation of textures without any fetching of texture files at all.

A new class, PixelBasedTexture, has been added as a derived class of the Texture node.  The ImageTexture node is now derived from PixelBasedTexture.  PixelBasedTexture contains the following API for examining the current texture:

The 'which' argument of getChannel may be either RED,GREEN,BLUE, or ALPHA.  And if getCopy is true, it returns a copy of the pixels, otherwise a reference to the pixels.  Using these calls, the texture may be examined (and in the case of an ImageTexture, the results will be the pixels that were loaded from the url).  

PixelBasedTexture also contains a method for establishing new pixels in the texture:

When this method is called, the given pixels will replace the ones in the texture.

The above API provides a way to perform the following types of task:

GradientTexture and TintedImageTexture nodes (2.0)

Shout3D 2.0 includes the source code (in the custom_nodes directory) for two new nodes derived from PixelBasedTexture   These were created using the new Texture API for editing pixels (see previous section).

Examples of these textures (whose fields may be animated to produce animated textures) may be found in:

demos/textureManipulation/fourGradientTextures.html, demos/textureManipulation/threeTintedTextures.html, demos/textureManipulation/gradientAndTintedMultiApp.html

JavaSound nodes can play .wav files (2.0)

JavaSound nodes used to be restricted to playing only sound files of the ".au" format. Now they can play files of the ".wav" format as well.

Picker API Additions (2.0)

The Picker interface has a number of new API additions.  These fall into two categories:

  1. Access to information stored in the Picker
  2. Utilities for interchange between screen space and world space.

Various API Additions (2.0)

Shout3D 2.0 contains a number of small but useful API additions to make programming Shout3D a bit easier.  All of these are documented further in the Javadocs for their respecitive classes. The API additions are:

Shout3DWizard Changes (2.0)

The Shout3DWizard has been changed to provide numerous changes and enhancements. Below is a summary of these changes, however all documentation about the wizard in the QuickStart Tutorial and the User Guide is up to date.

No Wizard for the Mac Yet

This release of Shout3D 2.0 does not yet have a version of the Shout3DWizard that will run on the Macintosh platform. This will be remedied for our final release.

"Optimize Archive" option - generates minimal zip archive of classes for your applet

The new Shout3DWizard is capable of creating a custom zip file when it publishes your applet.  This zip file will contain the exact set of class files required to run the applet you are publishing -- nothing more and nothing less. This custom archive feature allows you to distribute content that downloads to those who visit your site in the most efficient manner possible.

If the "optimize archive" option is set to false (the default), then no custom archive is generated -- a default archive named shout3dClasses.zip will be used.  This is much the same was as it was in Shout3D 1.0.   In this case, publishing is a one-step process: just press the publish button and the published directory will be created.

If the "optimize archive" option is set to true, then the wizard will generate a custom archive for you, as follows:

  1. When you click "publish,"  the wizard will not immediately write out the results to the published directory, rather:
  2. The wizard will launch your applet in a special testing window.
  3. In order to insure that all the required classes are included in the archive, you'll  need to put your applet through its paces and exercise all the functionality of the applet.  So, if you are using an ExamineApplet, you should make sure to click in the applet and rotate the view.  And if you've got a TouchSensor that kicks off an animation, make sure to click on that TouchSensor so that the proper classes are all loaded and run.
  4. If you miss something, the consequences are not dire.  Your applet will never crash, but when a user visits your website and tickles the overlooked functionality, the required classes will need to be fetched in separate trips to the server from the archive.
  5. When you have exercised all the features of your applet, close the window containing the applet.
  6. The Shout3DWizard will now publish your applet with a special archive.  All classes not in the archive will still be present in the published directory.  You should upload the entire directory to your server when preparing your web site.  But if you've exercised all the features of your applet during the testing phase, these classes won't be downloaded to your users' machines.
No Distinction Made between File Types on Input

When you read a file into the Shout3DWizard, you can read in either a .wrl file or a .s3d file.  There's only one option in the File--Open pulldown, and with that command you can read in either kind of file.  The Shout3D 1.0 version of the wizard required you to select either "open vrml" or "open s3d."  This distinction is no longer made and you can read either kind of file using "File-->Open"

Model Directory Remembered from Session to Session

In Shout3D 1.0, the Shout3DWizard would not remember the last directory from which you loaded a model.  The Shout3D 2.0 wizard will remember the directory from the last session.

"Optimize Model" replaces old "convert to s3d" option

The Shout3DWizard will now write out only one version of your model into the published directory.  If "Optimize Model" is false, it will copy the file (.wrl or .s3d) exactly from where it is read.  If "Optimize Model" is true, the Shout3DWizard will strip out all Nodes, Fields, and comments that it ignores upon parsing, and it will gzip the results into a smaller file with the extension .wrz.

"Pixel Doubling" option

The Shout3DWizard has a new "Pixel Doubling" option, with three settings: none, regular, and smooth.  For documentation about Pixel Doubling and these three settings, follow this link.

Changes between 1.0 & 2.0 (2.0)

DiffuseColor no longer modulates texture by default (2.0)

In previous versions of Shout3D, the diffuseColor of Materials would always tint the color of any applied textures.  This was confusing for our users because most modeling packages, as well as VRML97, do not behave this way.  Hence, we have made the default behavior of Shout3D to be that the diffuseColor will NOT affect the color of an applied texture.

However, we have added a field to the Material node named modulateTextureWithDiffuse. The value of the field is false by default.  If you set the field to true, then you will get the old Shout3D behavior wherein the diffuseColor will tint the applied Texture.

API change -- appearance field in Shape is now an array (2.0)

Why: The new MultiMesh geometry allows you to specify different appearances for different sets of polygons within a single mesh.   In order to accomodate this, the appearance field of the Shape node has been changed from a NodeField to a NodeArrayField.  

No Problems with parsing Files: This will NOT cause any problems with reading old Shout3D files, or files that specify a single appearance for a Shape.  The reason that parsing will continue to work is because any ArrayField is capable of reading a value of dimension 1 without putting brackets around it.

Programming API for appearance is affected: If, in your Java code, you are setting or getting the value of an appearance field, you will now get compiler errors because the programming API for setting/getting values of NodeArrayFields differs from that of NodeFields.  In order to port your old code to Shout3D 2.0, you will need to make the following two changes.

Setting the appearance field -- porting from 1.0 to 2.0:  Where you were setting the appearance in Shout3D 1.0 like this: 

    myShape.appearance.setValue(myApp);

you would now set the value in Shout3D 2.0 like this:

    myShape.appearance.setValue(new Appearance[] { myApp });

Getting the appearance field -- porting from 1.0 to 2.0:  Where you were getting the appearance in Shout3D 1.0 like this: 

    myApp = myShape.appearance.getValue();

you would now get the value in Shout3D 2.0 like this:

    if (myShape.appearance.getValue() == null)
        myApp = null;
    else
        myApp = myShape.appearance.getValue()[0];

Known Bugs & Limitations (2.0)

The following known bugs and limitations will be fixed before the final release of Shout3D 2.0.  In the meantime, you will need to work around them.

Bug Fixes in 2.0

Incorrect Behavior (2.0)

The following features of Shout3D worked incorrectly in previous releases, but have been fixed as of the Shout3D 2.0 release:

Exceptions (2.0)

The following cases used to throw exceptions, but have been fixed as of the Shout3D 2.0 release:

Minor Errors (2.0)

The following minor errors have all been fixed as of the Shout3D 2.0 release:

New Features in 1.0.3

Shout3D works with Spazz3D! (1.0.3)

Shout3D is now integrated into the Spazz3D authoring system. With Spazz3D, you can author interactivity, behaviors, and built-in animations without any programming. The resulting files produced by Spazz3D make use of Shout3D's new Logic Nodes, described in the next section.

Within Spazz3D, you can now just click on "export to Shout3D" to create optimized Shout3D content. Or, to preview and/or publish Shout3D applets directly from Spazz3D, you can click on "launch Shout3DWizard" from within the "File" menu. For more information about Spazz3D, go to www.spazz3d.com.

New Logic Nodes with Demos(1.0.3)

Shout3d has a new set of six logic nodes, complete with a demo showing how each of them can be used. These logic nodes allow input events to trigger the generation of output events. They can be used to specify logic and behavior in a Shout3D file without the use of additional Java or JavaScript programming. The new nodes are listed below. Click the word "doc" to the right of each name to see the new documentation in the Shout3D Specification, or click the word "demo" to see the new "Logic Nodes" section of the demo page.

New Javascript demos (1.0.3)

Shout3d 1.0.3 contains two new javascript demos:

switchTest.htmlThis is a simple demo that switches between two dancing figures by changing the whichChoice field of a switch node. For more info, click here.

segmentedAnimationTest.html  This demo shows how to take one long animation and play back different sections of that animation at different times.  It is particularly useful for users who model and export their animations from 3D Studio Max, because this program exports multiple animations end-to-end as one long animation.  So users who want to switch between those sections can follow this example. Click herefor more info on the demo, and click herefor more info on modeling hints for 3D Studio Max users.

Field values are not copied the moment Routes are created (1.0.3)

In prior releases, the value of a field was copied to the destination field the moment a Route was created. This created incosistencies with the behavior of some VRML97 files. Shout3D now waits until the value of the "source" field is set before copying the value of that field to the "destination" field.

New Node::getViewer() method (1.0.3)

The base node class has a new method, getViewer(), which may be used to retrieve the Shout3DViewer in which the node is being displayed.(1.0.3) See Node.html for more info.

Bug Fixes new in 1.0.3

Missing Polygons (1.0.3)

Some polygons within non-uniformly scaled IndexedFaceSet nodes were being incorrectly culled from the scene, resulting in occasional polygon drop-out as well as incorrect shading. This problem is fixed in the 1.0.3 release.

Funny-colored Polygons (1.0.3)

In the case where an IndexedFaceSet node had a ccw field with a value of false (the default value is true), certain polygons would be rendered in an incorrect color. This is fixed as of the 1.0.3 release.

Fan-In from Interpolators (1.0.3)

Fan-in from Interpolator nodes to other fields was broken. This meant that you could not route multiple Interpolators into the same Transform field, leave the routes in place, and change animations by starting one of several TimeSensors (which in turn controlled different sets of Interpolators). This is fixed as of the 1.0.3 release.

Picking of Billboards (1.0.3)

There was a bug in picking which caused crashes in certain cases where Billboard nodes were used. This showed up when attempting to view Billboards in the WalkApplet, for example. The bug is fixed as of the 1.0.3 release.

Animating Texture Coordinates (1.0.3)

Previous versions of Shout3d would not successfully display animation of texture coordinates. The initial set of coordinates would always be used. As of the 1.0.3 release, you can change Texture Coordinates on the fly (either with CoordinateInterpolator nodes or by setting the values via Java or JavaScript) and they will animate correctly.

New Features in 1.0.2

Registration Codes can work on multiple hosts and domains (1.0.2)

Background: Purchasers of the Profession and Education Editions of Shout3D receive a license to serve Shout3D applets that are free of the Shout3D logo strip displayed along the bottom edge of the applet.  With each license, a registration code is provided that works for a single user on a single domain.

Multiple Domains: In previous versions of Shout3D, each html file could contain only one registration code.  This was problematic, because users would need to upload unique content with unique registration codes to serve the same applets from different domains.  This problem is now fixed, and multiple registration codes may be used in a single html file, allowing the applet to be served, logo-strip-free, from multiple domains.  For more information, read the new sections of the user guide about Multiple Domainsand Multiple Registration Codes.

Multiple Hosts:  A single html file might be served from more than one host on a given domain.  For example, a purchaser of a license for www.manyhosts.com might want their content served from both www1.manyhosts.com and server7.manyhosts.com.  In previous versions of Shout3D, a single domain license would not successfully work for these multiple hosts.  This problem is now fixed. So, for example, a license for www.manyhosts.comwill work for all the above cases.  For more information, read the new sections of the user guide about Multiple Hosts.

Switch Node (1.0.2)

Shout3D 1.0.2 now contains a Switch node in the core library.  This node corresponds exactly to the Switch node from the VRML97 specification.  For an exact specification of the Switch node, see the new section of the Shout3D specification.

New JavaScript demos (1.0.2)

Shout3D 1.0.2 includes two new JavaScript demos, created in answer to questions from the Shout3D message board. Both are located in the Shout3d_runtime\demos directory.  The first, jump_after_animate.html, shows how to jump to a new web page after an animation has finished running.  The second, wheres_the_camera.html, shows how to display the position and orientation of the camera when the user clicks a button.  For descriptions of all the JavaScript demos, see the JavaScript section of the Shout3D demo guide.

getNodeByName() no longer throws exceptions (1.0.2)

The getNodeByName(String name) method on CoreShout3DViewer (implemented in both Shout3DApplet and Shout3DPanel) searches for a node with the given name.  If no node can be found in the scene with the given name, this method used to throw an exception.  This behavior has been changed to simply return null when the node can not be found.  This new behavior allows you to test for a node's presence without the risk of throwing an exception.   In practice, it is now a good idea to always test the results of getNodeByName().  In some cases, the correct behavior is to throw an exception, as when the program can do nothing useful if the given node does not exist.  In other cases, graceful action may be taken by the program, such as skipping an action but continuing on.  The source code of the following demos have all been changed to test the results of getNodeByName():  Shout3d_runtime\codebase\applets\ModDunkPanel.java, Shout3d_runtime\codebase\applets\LightTestPanel.java, and Shout3d_runtime\demos\javascript_demo.html.

Shout3DWizard no longer converts files by default (1.0.2)

Background: Many of our users were confused by how the Shout3DWizard converts files.  When adding a node of a customized type to a scene (such as a Pyramid), or when adding the hasAlphaTexture field to an ImageTexture node, most people would assume they could edit these things into their VRML files and then run them through the wizard.  Unfortunately, the converter assumes that the input file is correct VRML and strips out any fields or nodes which are not legal VRML97.  So these users would find that the additions they had worked hard to add would be removed.

What has changed:  To avoid the above confusion, we have changed the default behavior of the Shout3DWizard.  The wizard contains a parameter called "convert to s3d."  This parameter was true by default in prior versions, but as of version 1.0.2, the parameter is false by default.  The result is that, when running the Shout3DWizard on a VRML file, that file will not be converted, but rather copied as is into the publish directory.

Compression of VRML files has been added: Because the above change means that much more people will be publishing their content as .wrl files, we have added an automatic feature to the Shout3DWizard.  When the .wrl file is copied to the publish directory, a gzipped version of the same file will be placed there as well, and the applet parameter "gzip_src" will point to that file.  The result is that, when the html file is visited by somebody browsing the web (i.e. with a 4.0 browser or higher), their browser will fetch the smaller, gzipped file instead of the larger file.  This behavior was always present in the Shout3DWizard for files published in the .s3d format, but has been added for files published in the VRML format.

Bug Fixes new in 1.0.2

Other bug fixes (1.0.2)

The following assorted bugs have all been fixed as of the Shout3D 1.0.2 release:

Shout3DWizard for Macintosh (1.0.1)

Shout3D 1.0 did not contain a version of the Shout3DWizard that would run on Macintosh machines. The Macintosh release of Shout3D now contains a fully functional, double-clickable, version of the Shout3DWizard. It is located within the Shout3d_wizard directory of the release, and named Shout3DWizard.exe. For a quick tutorial on how to use the wizard, try going through the Shout3D QuickStart Tutorial.

New Features in 1.0.1

8-bit Texture Transparency (alpha texturing) (1.0.1)

Shout3D provides a way to associate different 8-bit levels of transparency with the pixels in a texture, a technique called alpha texturing. The feature is enabled through a field in the ImageTexture node. Complete documentation is provided in the Shout3D specification and Shout3D includes a new demo to illustrate the feature. Click hereto see the documentation and click here to find a link to the demo. Note: This feature was actually present in the first version of Shout3D 1.0, but it was never documented.

New Node: ColorInterpolator (1.0.1)

Shout3D now contains a ColorInterpolator node. It works just like the VRML ColorInterpolator node.

More tips for 3D Studio Max Users (1.0.1)

The User Guide now contains more information to help users of 3D Studio Max export their VRML files effectively for Shout3D. Click hereto see the new, expanded section.

Improved WalkApplet (1.0.1)

The WalkApplet demo source code has been improved as follows:

Bug Fixes new in 1.0.1

Wizard bug fixes (1.0.1)

The following bugs, concerning the running of the Shout3DWizard, have all been fixed as of the Shout3D 1.0.1 release:

Preview and File Reading bug fixes (1.0.1)

The following bugs, concerning the preview and reading of files by the Shout3DWizard, have all been fixed as of the Shout3D 1.0.1 release:

IndexedFaceSet bug fixes (1.0.1)

The following bugs, which effected the behavior of IndexedFaceSet nodes, have all been fixed as of the Shout3D 1.0.1 release:

Other bug fixes (1.0.1)

The following bugs, which effected the behavior of Shout3D applets once a scene was successfully loaded and displayed, have all been fixed as of the Shout3D 1.0.1 release:


Copyright© 1999-2001, Shout3D LLC.