Electric Rain Swift3D LW 2

Having tried the standalone version of Swift3D 1.0 back in the late summer of 2000, several problems immediately cropped up that led to me proclaiming the product not at all useful for my needs. As I was not writing product reviews at the time, that proclamation was pretty much heard only by myself. But now that I've gotten my hands on the LightWave plug-in version of Swift3D, now in its second iteration, I have the opportunity to explain just how nicely the Swift3D concept has evolved to an audience that probably, by now, could very well number in the double digits.

A little bit o' history

Swift3D, for all of its various incarnations, pretty much boils down to doing one thing: rendering out 3D content into SWF (or other vector-based) files. For that, it relies on Electric Rain's proprietary 3D-to-vector rendering engine, dubbed Ravix (now at version 3). It seems that between the time that Swift3D v1 was released and the myriad products that exist today under the Swift3D banner Electric Rain realized that the real product was the Ravix engine, and for folks like me, that shift turned Swift3D from an interesting novelty into a bona fide production tool. There are a couple of reasons why I was so down on Swift3D when I initially tried it out a while back. First, I'm pretty comfortable already with my 3D package of choice, LightWave. I don't mind learning new things in the 3D realm, but the standalone version of Swift3D wasn't (and by many accounts, still isn't) exactly the most full-featured of 3D tools, which made me long for the ability to use LightWave as the 3D content creation front-end for Swift3D output. Second, the Ravix engine was pretty capable of rendering out some nice and compact SWF files, but at the end of the day, they were still SWF files. If you wanted to bring them into Flash, you either had to do a LoadMovie command to bring the clips into movies on the fly, or import them into Flash and go through the tedium of deconstructing a series of frames to make them work the way you wanted, with neither solution being optimal. The long and short of it was that you really, really, REALLY had to want 3D content in Flash pretty badly for Swift3D to be worth the effort you invariably had to put into the product to get it to do any semblance at all of what you wanted.

Several things have happened to rectify this situation, at least for me. First, Electric Rain decided to offer Swift3D as a plug-in to LightWave (as well as 3D Studio Max), eliminating the need for users of those programs to learn another 3D application (or go through the convoluted process of getting pre-existing content from those programs into Swift3D) to get access to the Ravix engine. This was an Excellent Move. Second, the Swift3D LW 2 plug-in now takes advantage of the third-party file format support feature in Flash MX to offer very tight integration with the Flash authoring environment (which Electric Rain has dubbed "SmartLayer"), which gets rid of my other knock that Ravix-rendered content was very hard to work with inside of Flash itself. This was another Excellent Move. So now that Electric Rain offers the 'zact version of Swift3D that I was hoping for from the very beginning, let's take a closer look at Swift3D LW 2 and see what's going on.

What It Does

When you get right down to brass tacks, Swift3D LW 2 is just another rendering option in Lightwave, and as such, there really isn't a whole lot to cover as far as what it does: open up or create a LightWave scene, set your Swift3D rendering options, and render. That said, there are still three main components that make up the overall experience of using Swift3D LW 2 that are worth delving into at least a little bit of detail: the installation process, rendering options, and supported formats.

If you're familiar with LightWave at all, you already know that it's a program that is heavily dependent on plug-ins even for some of its core functionality. Now, there are some third-party plug-ins that, during the install process, will add themselves to your LightWave config files, effectively installing themselves into the LightWave environment. However, Swift3D LW 2 is not one of those plug-ins, and while it does offer an installer on both the Mac and Windows to get the plug-ins into the LightWave plug-ins directory, you'll have to manually add them yourself once in LightWave (fig. 1). Plus, if you want quick access to the rendering options and such, you'll need to modify the LightWave interface to create a place for them (fig. 2). Fortunately, Swift3D LW includes a handy-dandy install guide that auto-launches from the end of the installer which will guide you through this process, which, if followed, will give you access to the Swift3D rendering options right underneath LightWave's built-in rendering options (fig. 3). Why am I telling you all of this? Well, just consider it a heads-up: if you're new to LightWave, or just have never manually added plug-ins before, the install process may be a little daunting, but still totally in keeping with standard operating procedure for many LightWave plug-ins. Savvy LightWave veterans, well, I may have just wasted some of your time with this part, as you probably know all of this already. Sorry.

Figure 1: Installation of Swift3D LW 2 requires you to manually add the plug-in from LightWave.

Figure 2: You can add GUI buttons for Swift3D LW 2 through LightWave's Edit Menu Layout panel.

Figure 3: I put mine where Electric Rain wanted me to: right below LightWave's regular rendering options.

The rendering options in Swift3D LW 2 pretty much boil down to settings that control how your render is filled (fig. 4), whether you want your model outlined and how those lines should look (fig. 5), and a couple of level-of-detail choices (fig. 6). Really. That's all. The Ravix engine includes seven types of fills: Cartoon Single Color Fill, Cartoon Average Color Fill, Cartoon Two Color Fill, Cartoon Four Color Fill, Cartoon Full Color Fill, Area Gradient Shading, and Mesh Gradient Shading (fig. 7). Without getting too detailed, these seven fill options represent a sort of sliding scale for how accurately the Ravix engine is going to recreate your 3D content as vectors, with each offering what amounts to a tradeoff between rendering fidelity and file size. Let's look at the two extremes for a second, and I trust you can interpolate the middle options. On the low end, Cartoon Single Color Fill gives you a very flat representation of your image, but tends to render the most compact vector files. On the flip side, Mesh Gradient Shading attempts to recreate as many nuances as possible in your image through very liberal use of gradients, and in some cases can be indistinguishable from a raster-based render format. The downside is that each frame has the tendency to be somewhat large by vector standards, not to mention that it usually adds a fair amount of time to render over the simpler shading options. Regardless of the fill type you use, you can also add options such as shadows, specular highlights, and reflections to make your image a little more realistic, but of course the nuttier you choose to get can add to the overall file size and render time.

Figure 4: Swift3D LW 2's Fill options panel.

Figure 5: Swift3D LW 2's Edge options panel.

Figure 6: You can tweak how your geometry is rendered through these options.

Figure 7: The seven shaders accessible from the Fill options, with Cartoon Single Color Fill on the left all the way up to Mesh Gradient shading on the right.

For those of you who are more into the cartoon aspect of a tool like Swift3D LW 2, you can choose to add edges to your objects. Of course, you can also get some pretty cool wireframe effects going on by just rendering edges and leaving out fills altogether. There really isn't much to say here other than that -- the edge part of the tool is pretty self-explanatory from the earlier screenshot. So I might as well lump in the miscellaneous stuff that I showed back in figure 6, because there's an option there that combines edges and fills, making it possible to shave a little bit of file size off of your renders if you need to (or, conversely, lets you keep edges and fills separate so you can manipulate each in Flash). The lines/curves slider and level of detail options are there pretty much to let you do some additional tweaking should file size really become an issue, as these controls can manipulate the final rendered geometry enough to influence how the various color fills and gradients are rendered.

Now that we've covered how you control the way your stuff looks, let's get to the various types of file formats supported by Swift3D LW 2. You have to give Electric Rain credit here, as they have not skimped at all on format choices (fig. 8). You've got SWF, which I assume you expected. You've also got sequential EPS, which is key for users that are using certain non-Macromedia Flash tools (*cough* LiveMotion *cough*) that do not support SWF import. You've also got sequential EPS's cousin, sequential AI, and both are useful in single-frame renders that can be brought into drawing programs like Freehand or Illustrator, respectively. You've got SVG, and kudos on the somewhat early adoption and support of this developing standard. You've got USAnimation, for exporting files to be used directly with the Toon Boom product. You've even got standard raster output to SWF format, which bypasses the Ravix renderer altogether (it's accessed instead through LightWave's standard Render Option panel) and lets you save out your raster image sequences directly to a SWF file (fig. 9).

Figure 8: There are options aplenty when choosing an output file type.

Figure 9: You can even render raster sequences directly to SWF from LightWave's regular Render Options panel.

If you've been religiously following along with me using the list shown in figure 8, you are doubtless cursing my name for my omission of the Swift3D Flash Importer, or SWFT, output option. My humblest apologies for eschewing the order shown in that image, but I felt that the SWFT format (which, incidentally, is new to Swift3D LW 2) deserved it's very own shout out, since it's pretty much the mack daddy here. Swift3D LW 2 gives you a custom importer that looks for a Flash MX installation and then automatically stashes the SWFT format import plug-in into your Flash MX directory. Once it's there, SWFT files appear to Flash MX as just another importable file type, meaning that you can seamlessly use Ravix-rendered files directly in the Flash authoring environment (fig. 10).

Figure 10: The result of bringing a SWFT file into Flash MX. Notice how the importer automatically creates layers based on static and moving objects in the Timeline.

Limitations

Since there really anything inherently wrong with Swift3D LW 2 in how it performs its given task, this seems to be as good a place as any to throw out the few caveats that probably need to be mentioned when considering a product like this. First and foremost, Swift3D content is not true 3D, in the sense that Flash is doing any real-time rendering or manipulation of 3D content the way Shockwave 3D does. So think of whatever you get out of Swift3D as 2D elements that look 3D instead of having the potential for immersive worlds. I suppose it's possible for a combination of creative Ravix output and ActionScripting to simulate a true 3D interactive object or world, but just remember that each vector image you have adds to file size in your final movie.

Second, anyone thinking that any version of Swift3D is somehow a magic bullet that turns your 3D content into beautifully rendered, compact Flash files will be kind of disappointed. Swift3D LW 2 is very much a tweaker's tool, inviting trial and error at every point from original model optimization to experimentation with any one of the plug-in's controls to achieve acceptable results. Each choice you make has definite ramifications on file size, rendering speed, and ultimate image quality, so it's very possible that you'll need to render and re-render a sequence several times before you're able to find the right balance. Also be warned that depending on the amount of geometry and the settings you've selected, render times can sometimes be prohibitively long, so be cautious.

The last thing I'll mention is that since Swift3D LW 2 works with LightWave, you may be tempted to think that it's no problem to re-purpose any old pre-existing LightWave scene you may have lying around. While in theory this is true, I found that no LWS file, at least that I had, was really "ready to go" as-is with Swift3D. First, every model in the scene has to be prepped by tripling polygons, as Swift3D LW 2 can't handle polygons with more than three vertices. In some cases, this process results in some really heinous geometry, and this will definitely be a factor come render time. A good rule of thumb I learned while working with Swift3D LW 2 is that if your model looks good in wireframe mode, it'll probably look good when rendered with the Ravix engine. Conversely, if your model looks like it's had a rough day at the office in wireframe mode, you'll probably get pretty nasty results with Swift3D LW 2 regardless of how you tweak the controls (fig. 11).

Figure 11: Clean wireframe, clean Ravix render. Nasty wireframe, nasty Ravix render. The front of the blue object is supposed to be flat and smooth.

The Bottom Line

Overall, Swift3D LW 2 finally delivers on the promise of the original Swift3D, but it's still probably a better tool for delivering content specifically designed to take advantage of its inherent strengths rather than converting existing LightWave content originally destined for another medium. However, excellent results certainly are possible, and one only need visit the Electric Rain web site to see more than a few nice examples of what Swift3D can add to one's Flash movies. I'm of the opinion that Swift3D LW is a little pricey for what it does, and at $295 for the full version and $149 for an upgrade, it's not exactly pocket change to get on board. But despite the price and the need for constant tweaking during the production process, Swift3D LW 2 gives you a pretty nice vector rendering solution, one that's already integrated into an existing 3D package and that produces content that can be used directly within Flash, and as such it's definitely worth taking a serious look at to see if it's right for you.

Filed under: Review on February 7th, 2003

^ Top of Page

Got Feedback? to send an email. I'll do my best to answer. Really.