Review – Swift 3D v3

Since the release of Flash 3.0, Macromedia have been working to improve the facilities for creating interactivity in Flash movies. These enhancements have included form submission abilities, a JavaScript-style scripting language called ActionScript, and now in Flash MX a complete set of user interface widgets. What hasn’t changed much since Flash 3.0 is the set of graphics creation tools that the package provides. While Flash MX now supports the creation of complete Web sites that can interact seamlessly with both the user and server-side scripts, the tools that the Flash authoring environment provides for creating slick, animated vector graphics to accompany these interactive elements have remained largely unchanged over two major revisions. This has been a surprising trend, since the demands of Web designers who use Flash to create slick, animated vector graphics for their Web sites have been growing steadily all the while.

One big trend that I was surprised to see Macromedia miss the boat on was the increasing use of 3D elements in Flash-based designs. Until the release of Swift 3D v1, designers who wanted to add a 3D design element like a spinning logo to a Flash movie had to be very creative and patient in finding a way around the 2D focus of the Flash authoring environment. Usually this meant rendering an animation in a dedicated 3D software package such as 3D Studio MAX, then importing the series of rendered frames into a Flash movie. Of course, a Flash movie consisting of a series of rendered images is going to be huge in terms of file size (and, consequently, download time), so the next step was to laboriously trace the rendered images using the vector graphics tools provided by Flash. As a result, the beautifully rendered images produced by the 3D graphics program became mere guides for the hand-drawn replicas that could take many hours to produce. If you were a designer seeking to maximize your billable hours, then a customer asking for 3D graphics on their site was a godsend; however, I’m willing to bet that most designers out there have better things to do with their time.

Enter Swift 3D v3

Billed by many as a revolutionary advance in Flash content creation (and I would tend to agree), Swift 3D bridges the gap between the 3D worlds of programs like 3D Studio MAX and the 2D canvas provided by Macromedia Flash.

Figure 1 - 3D Flash design process with Swift 3DAs shown in Figure 1, the process of designing a Flash movie containing 3D elements begins in a specialized 3D program. Using that software, you create the 3D models of the elements you want to use in your Flash movie, and then save the scene as a .3DS (3D Studio format) file. You are free to use any 3D software that can produce 3DS files, and most do. In my testing, I used a free 3D graphics and animation package called Blender to produce a .WRL (VRML format) file, and then converted that file to .3DS format using another free utility called Crossroads. I also tested with Carrara Studio 2, which can export directly to .3DS format.

When you create a new file in Swift 3D, you can either choose a .3DS file to import or start with a blank scene and use Swift 3D’s built-in modelling tools to build a scene from scratch. The modelling tools available in Swift 3D v3 range from basic geometric shapes to more complex objects generated from 2D shapes, but more on those later.

Either way you choose to create your scene elements, Swift 3D then allows you to work with those objects by moving, rotating, and scaling them to produce the animated effect you are looking for. Swift 3D also lets you define the lighting and materials for your 3D scene. When everything is set up just the way you want it, Swift 3D allows you to render your animation into a Flash-compatible format. This is the really unique part of the program, as the RAViX III rendering engine meticulously produces a 2D vector image of each frame of your 3D animation, using gradient fills to mimic the surface colours and lighting effects in your 3D scene (with new supprt for reflections in v3!), balancing rendering accuracy against file size according to the options you choose in the Export dialog.

New in Swift 3D v3 is an entirely new rendering engine called EMO that can render non-vector image formats by ray tracing. Again, more on that later.

You can actually use an SWF file exported from Swift 3D without further modification if you want (meaning you don’t even have to own Flash to produce 3D Flash animations with Swift 3D), but in most cases you’ll want to add some 2D elements to your movie as well. With the new Swift 3D Importer for Flash MX that comes with Swift 3D v3, you can export a .SWFT file from Swift 3D and then import it into the Library of Flash MX. This new import method keeps different elements of the rendered output (i.e. fills vs. outlines, moving vs. stationary objects, translucent vs. solid objects) separate so you can work with them separately inside Flash MX. If you own an earlier version of Flash or use some other tool such as Adobe LiveMotion to create Flash movies, however, Swift 3D can export a plain SWF file as well.

In either case, when you import the animation into Flash (or LiveMotion, etc.), the 3D animation just becomes a series of key frames in your movie. Using Flash, you can add whatever 2D or interactive elements you like, or you can even place the 3D animation into a Movie Clip symbol in your Library and use it in several places throughout a given Web design project (as an animated button, for example).

The Program in Detail

The Swift 3D interface (Figure 2) is logically laid out to cater to users familiar with both Flash and 3D design packages. Unfortunately, despite a few innovative elements, I found the interface rather cumbersome and just different enough from the packages they attempt to emulate to make the transfer of skills problematic.

The Swift 3D v3 interfaceFigure 2 — The Swift 3D v3 interface

Get Your Copy of Kevin Yanks Book NOW!The main window provides a view of the 3D world where you can directly manipulate elements of the scene by clicking and dragging them about. Holding the SHIFT key lets you constrain movement to one axis, though copying objects is still a multi-step affair (rather than a simple CTRL-drag-and-drop). You can also make precise adjustments to an object’s position in the scene via text input, though snap-to-grid functionality is vexingly absent.

Object scaling is accomplished in similar fashion, except that you must click a toolbar button before making each adjustment. Non-proportional scaling along the three axes of an object, which opens up a lot of possibilites for interesting animations, must be accomplished using text inputs. I would have preferred sizing handles for direct manipulation within the 3D scene.

The ability to create floating cameras and position them anywhere in your scene provides fine control over camera movement; however, if you’re accustomed to your 3D package allowing you to switch between a perspective (WYSIWYG) view and an orthogonal (flattened) view that is good for lining things up, you will unfortunately find no such facility in Swift 3D.

Rather than handling object rotation by a similar combination of direct manipulation and text inputs, the makers of Swift 3D elected to place this functionality in a separate interface component called the object trackball. In the bottom left of the Swift 3D window is what looks like a 3D sphere, with a miniature version of the currently selected object(s) floating in it. By clicking and dragging, the user can spin this sphere and the selected objects along with it. Buttons to the left of the trackball let you constrain rotation to a single axis and/or to fixed angular increments (5, 10 15, 22.5, 30, 45, 60, or 90 degrees at a time). While still not as accurate as offering a manual entry option, these controls do afford significant control over the rotation of your scene elements. Still, one is left to wonder why it was necessary to move the rotation features to their own section of the application window. Since movement and scaling can be performed directly on objects in the 3D view, I constantly found myself trying to rotate an object in that view and being surprised when it didn’t work as expected.

The Rotation and Lighting TrackballsFigure 3 — The Object and Lighting trackballs

Light sources are added and positioned with the lighting trackball, just to the right of the object trackball. Operating in similar fashion, this trackball has the light sources for the scene floating on its surface. By selecting a light and then dragging on the surface of the sphere, the user may place the light at any angle relative to the centre of the scene. In my testing I found this control to be highly intuitive, but the results it produced where at times unpredictable. The reason for this is explained in the manual: the sphere of the lighting trackball represents an actual sphere that is centred about the objects in the scene, and is automatically sized so that it is just large enough to contain all of the scene elements. The side effect of this arrangement is that if your scene contains a single object that moves from one position to another, the light hitting the surface of that object will not change as the object moves, because the lighting sphere will move right along with it. To compensate for this, Swift 3D allows you to create "Free Lights" within the 3D scene, where they may be positioned just like any other scene element. I was more satisfied with the results I obtained by placing all my lights right in the scene, which made me again question the reasoning behind the trackball interface. It’s obvious a lot of work went into creating these unique interface elements, but I wonder if the program as a whole might have benefited if these features had been supported by a more mundane (and familiar) interface.

The Swift 3D Animation TimelineFigure 4 — The animation timeline

Aimed as it is at users of Flash, Swift 3D lets you create animations using a timeline that looks a lot like the one in Flash itself (see Figure 4). Rather than layers, however, it has a number of timelines for the position, rotation, scale and other properties of whatever object you have selected. Swift 3D’s timeline even provides controls for animating things like the pivot point and surface materials of an object.

The key frame and tweening systems provided by Swift 3D will take a little getting used to, since it creates a key frame automatically whenever you move an object while in animation mode, and all key frames are tweened by default. Once you’ve become accustomed to this way of working, however, the timeline provides just enough functionality to get things done without being overly complicated. The ‘stretchable’ handles around keyframes that let you pause the animation for several frames (see the red area in Figure 4) are extremely convenient, and I found myself missing a similar feature in Flash MX!

If you don’t have any experience with a 3D modelling package such as Blender or 3D Studio MAX, don’t worry! Simple 3D objects may be created directly inside Swift 3D. The program offers facilities for creating spheres, cubes, cones, cylinders, tori (doughnut shapes), and 3D extruded text. In addition, there are two powerful modelling systems — the Extrusion Editor and Lathe Editor — which let you plot out points on a 2D surface to create a 3D object. All this means that Swift 3D will handle the modelling for all but your most demanding 3D scenes.

Aside from a few small (but nice) conveniences, such as the Swift 3D Importer for Flash MX, or the ability to arrange elements in a scene hierarchically in order to make possible more complex animations, the new features in Swift 3D v3 are mainly in the area of rendering.


A sample render using all the bells and whistles of RAViX IIIThe primary renderer for Swift 3D, RAViX is the engine responsible for converting your 3D landscape into 2D vector images.

In its 3rd version, the RAViX engine now adds support for reflections, transparent objects, multiple shadow-casting lights, and better specular (shiny) highlights.

In short, your 3D Flash movies can now look more realistic than ever. Of course, all these new bells and whistles will increase the size of your movie file, but judicious use can produce some very nice effects without too much overhead.

The image shown at right is only a simple example of the kind of effects you can get with a couple of shadow-casting lights and a reflective surface.

The EMO Renderer

A raster image generated by EMOThis all new ray tracing renderer in Swift 3D v3 certainly produces eye popping results compared to RAViX; however, the images it produces are fixed-scale raster images. That is, this renderer produces a standard image file for each frame of your animation. It can bundle them together into an SWF movie file if you like, but you won’t be getting any of the benefits (small file size, scalability, etc.) of the Flash vector animation format produced by RAViX.

A strange omission from EMO is the ability to create AVI movies and animated GIF images (though you can always create these by passing through Macromedia Flash).

Effects made possible by EMO include bitmapped and procedural textures and refraction (distortion) of light passing through transparent objects. Although output from this new renderer is perfectly nice, there are better ray tracers (with more powerful modellers) out there that support a lot more in the way of special effects for free. The benefit of EMO is really just having all the tools in one place.

Summing it up

Overall, the Swift 3D interface suits the purpose it was built for: creating simple 3D animations. While I did miss many of the powerful features offered by complete 3D modelling and animation packages, once you start putting this program to practical use you’ll quickly find that simple animations are usually more effective than any of the complicated ones you might have imagined at first. Besides, complicated animations lead to large file size, which is what you’re trying to avoid by using Flash, right?

This new version of Swift 3D provides a wealth of refinements, mainly in the form of new rendering capabilities. RAViX III adds support for improved realism with reflections, multiple shadows, and better specularity, while the new EMO renderer takes realism to extremes by ray tracing each frame as a (sadly non-scaleable) raster image. Other little touches make Swift 3D more powerful and more convenient than any prior version.

The tools Swift 3D provides are well suited to quickly producing simple and effective animations for use on the Web. Seeing your 3D model quickly and painlessly rendered as a 2D Flash animation with flawless lighting is incredibly impressive. Unfortunately, there is no demo of Swift 3D available. You’ll just have to take my word that the program is worth the price of admission. Take my word, and the example animation at right that I was able to create in 10 minutes using Swift 3D, and then adding the 2D elements in Flash MX. The size of the file is just over 35KB. And if that’s not impressive enough, drop by and check out what some intrepid designers were able to do with slightly more time on their hands!

Swift 3D v3 from Electric Rain (Windows / Mac OS 8.1+)

Available from for US$169.00.

Upgrade from previous Swift 3D versions for US$89.00 (US$79 for a limited time).

Educational and volume discounts also available.


BUY IT: If you use Flash in your Web designs and want to add a splash of 3D.

FORGET IT: If you can’t justify the cost.

Free book: Jump Start HTML5 Basics

Grab a free copy of one our latest ebooks! Packed with hints and tips on HTML5's most powerful new features.

No Reader comments

Comments on this post are closed.