The first plugin, Set Material by Crease Angle, sets the materials of a model based on the crease angle of the mesh. For each selected area, the plugin creates a new color in the palette and “flood-fills” the area until the angle between the surfaces exceeds the crease angle of the mesh. The result is that contiguous areas are all set with the same palette material, and a new material is applied wherever a discontinuity occurs. This allows you to easily break a model into sections along its creases for easier texture mapping, or many other purposes.

The second plugin, Planar Map by Material, actually includes three new commands.

The first command is Fit UV Coordinates to Map. This command is essentially the same as the “max” button in the TCE, forcing all UV coordinates into the 0-1 range, but unlike “max” this scales the map proportionally instead of independently on each axis.

The second command is Adjust UVs for Bilinear Filter. This is useful for game developers. This command scales your texture coordinates by a ratio of 240/256. The purpose is to create a small seam along the edge of the texture map so that if your game is using mipmapping with a bilinear or trilinear filter, the texture won’t bleed into its neighbors in your texture cache nor will it bleed into itself if you haven’t clamped the edges.

The last command, Planar Map by Surface Material, is probably the most useful of the three. Planar Map by Surface Material applies a “best fit” planar projection to all surfaces grouped by material in the current selection. If you section your model by material, this will treat each material color as a contiguous group and apply whichever planar projection fits it best in the TCE. You’ll still need to do some manual adjustment after you map it this way–especially texture packing, as this leaves plenty of room between areas so the surfaces aren’t too difficult to select–but it can save a lot of time in laying down a base mapping before you manually refine each area.

More information about each plugin is available in the readme.

Download the Material by Crease Angle plugin. (Requires Windows XP, AC3D 6.2 or above.)

Download the Planar Map by Material plugin. (Requires Windows XP, AC3D 6.2 or above.)

Displacement maps can be painted with 2D art tools such as Corel, Photoshop or Gimp; or, they can be exported from 3D sculpting programs such as ZBrush or Mudbox. The AC3D displacement map plugin supports 8-bit grayscale and 16-bit red-green (POV-Ray format) displacement maps.

If you are new to displacement mapping, this tutorial explains the process in more detail.

Download the plugin. (Requires Windows XP, AC3D 6.2 or above.)

Here’s how to do it:

• Make sure all your surface normals are unified (facing outwards) and your polygons are set to 1-sided
• Make a copy of your object and resize it so it is ever-so-slightly larger than the original
• On the copy, set the surface material to black
• Invert the surface normals

That’s it! Nifty, eh? The method’s not perfect–for best results, stick to convex objects–but it’s great for quick renders and on limited hardware platforms where shaders aren’t an option.

Download the plugin. (Requires Windows XP, AC3D 6.2 or above.)

This video shows you how:

A QUICK SIDE NOTE: It is much faster to use the hotkeys (ctrl+shift+I and ctrl+shift+L) than it is to use the menus… the whole process can be completed in only a few seconds if you use the hotkeys. However, for the sake of clarity, I use the menus in the video so you can actually see what I’m doing.

Enjoy!

To render plasmas, there are two basic commands you need to know:

- Media
- Turbulence

Media is a material parameter in POV-Ray designed to mimic the way the interior of a substance reacts to light. You could think of it as similar to a volumetric texture–but a more visceral way to describe media would be to visualize it as a gelatin or poured acrylic. You can tint it, swirl it, and pour it into a container of any shape you like.

Media works essentially the same way as other textures and materials in POV-Ray: you can assign colors to it, you can apply patterns to it, you can warp it or bend it, and you can even use it in layers. However, unlike textures, media has volume. The amount of light that is transmitted through media is dependent on the thickness of the media you are viewing it through. It is this property that allows media to be used to simulate fog, deep water, clouds, plasmas and a variety of other effects.

You can read a tutorial on the media command here: Simple Media Tutorial

Turbulence is a “pattern modifier”. Pattern modifiers alter the appearance of your texture or material by deforming them it various ways. POV-Ray had several different types of pattern modifiers. The turbulence modifier adds “noise” or chaos to your texture. Typically it has a soft, cloud-like shape; although with various settings it can also take on the appearance of marble, rocky soil or aluminum foil.

You can read a tutorial on the turbulence command here: Advanced Texture Options

By combining media and turbulence, you can create clouds, fog, plasmas and many other effects. When turbulence is combined with media, it alters the density of the media in a random way. This causes the media to appear as if there were something suspended inside it. By changing the turbulence settings, you can choose the way the media clumps and flows.

In general, the trick to getting great results with media is to use several density layers. Nature tends to be very fractal-like, with lots of interesting things going on both at the macro and the micro level. You want to emulate that in your renders. You can accomplish this by creating layers that simulate the large things that are going on, and then additional layers rendered on top of that that simulate the tiny details. This does slow down your render, but good things come to those who wait.

Let’s walk through an example:

// global settings: here, we specify which version of
// POV-Ray this file was designed for, as well as our
// default gamma settings for the scene
#version 3.6;
global_settings {
  assumed_gamma 1.0
  max_trace_level 5
}

// camera: this simple camera looks at the origin from
// a slight angle. it is the same camera as used in the
// default POV-Ray scene template
camera {                        

  // this line allows us to create an animation. by
  // changing the camera angle around the y axis based
  // on the clock, the camera will orbit the origin
  rotate <0.0, 360*clock, 0.0>             

  location  <0.0, 0.5, -4.0>
  direction 1.5*z
  right     x*image_width/image_height
  look_at   <0.0, 0.0, 0.0>
}

// a simple, completely black sky sphere
sky_sphere {
  pigment {
    rgb <0.0, 0.0, 0.0>
  }
}

// fireball: let's simulate an explosion. to do this, we're
// going to use the media and turbulence commands to create
// a plasma effect inside of an ordinary sphere.
sphere {
    0, 2.0

    // it's important to make the outer shell of your
    // object transparent... if you can't see through the
    // outside of the object, you won't be able
    // to see the media inside it
    pigment { color rgbt <1, 1, 1, 1> }      

    // media is held within the interior of the object
    interior {

        // we're going to create a single media object, with
        // several different density maps inside it. this works
        // similar to building a layered texture. "density"
        // controls the thickness of the media at a particular
        // point. density can be controlled independently on
        // each color channel, allowing you to have colored
        // media by emitting or blocking certain colors of light.
        // density maps multiply--not add--the density of the
        // layers together. this means that if a point has a zero
        // value on any layer, that the total density for that
        // point will also be zero. this is extremely
        // useful for creating complex patterns and effects
        media {         

         // POV-Ray supports three types of media: emissive,
         // absorbing, and scattering. "emission" is self-illuminated
         // media. it will not cast light on other objects, but it
         // has the appearance of glowing. "absorption" blocks light
         // instead of emits light. absorbing media casts shadows on
         // other objects. "scattering" media is lit by other
         // light sources, and can scatter light. it is substantially
         // slower to render than the other two types, however, it
         // can be used with photons to create effects like
         // visible sunbeams
         emission 1.0
         absorption .2   

         //
         // LAYER 1
         //
         // for our first layer, we'll blend the edge of the sphere
         // to transparent. this will make edges less obvious and help
         // hide the fact that the media is contained inside a sphere.
         // we want it to look free-floating, so it's important to
         // disguise the edges
         density {
            spherical
            density_map {
                [0.0 rgb <0.0, 0.0, 0.0>]
                [1.0 rgb <1.0, 1.0, 1.0>]
            }
         }

         //
         // LAYER 2
         //
         // explosions usually have bright centers. for our second layer,
         // we'll give the explosion a "hot" core by multiplying past
         // the 1.0 range in the center... POV-Ray doesn't support HDRI
         // (the MegaPOV build does) but this trick works nonetheless
         density {
            spherical
            density_map {
                [0.7 rgb <1.0, 1.0, 1.0>]
                [1.0 rgb <8.0, 8.0, 8.0>]
            }
          }              

         //
         // LAYER 3
         //
         // now that we've blocked out the general shape of our media,
         // for our third layer we want to get it looking more cloud-like
         // and less like a ball. we'll do that by adding some soft, low
         // frequency turbulence
         density {
            spherical
            density_map {
                [0.0 rgb <0.0, 0.0, 0.0>]
                [0.2 rgb <0.5, 0.0, 0.0>]
                [0.4 rgb <0.8, 0.4, 0.0>]
                [0.9 rgb <1.0, 1.0, 1.0>]
            }      

            // here's where the magic happens... a low turbulence setting
            // causes our media to take on a soft, cloud-like shape
            warp {
                turbulence .6
                lambda 1.5  

                // low omega values create soft, blurry results;
                // higher values are crisp and wrinkly
                omega 0.25
            }

            // this warp causes the explosion to look like the particulate
            // is ejecting from the center by pulling in all of the color
            // toward the center... I haven't tried it, but I bet you
            // could do some nifty animations by adding a clock term to
            // one of these values
            warp {
                black_hole <0.0, 0.0, 0.0>, 2.0
                strength .95
                falloff 2.5
            }
          }

          //
          // LAYER 4
          //
          // explosions have lots of detail, with many fine swirls and
          // eddies. we can simulate this by using a high-frequency
          // turbulence value. again, we'll multiply past 1.0 to keep
          // the explosion "hot"
          density {
            spherical
            density_map {
                [0.0 rgb <0.0, 0.0, 0.0>]
                [0.1 rgb <1.0, 0.0, 0.0> * .75]
                [0.2 rgb <1.0, 0.5, 0.0> * .75]
                [0.8 rgb <1.0, 1.0, 1.0> * 2.5]
            }           

            warp {
                turbulence 1.5
                lambda 2.5
                omega 0.55
                octaves 7
            }
            scale .75

            warp {
                black_hole <0.0, 0.0, 0.0>, 2.0
                strength .8
                falloff 2.0
             }
          }

          // if you find that you have glitches or black spots in
          // your media, try turning up the number of samples.
          // more samples will cause it to render slower, so don't
          // turn it up more than you need to
          samples 20
          scale 1.25
        }
    }

    // THIS LINE IS VERY IMPORTANT! in order to hold the media, the object
    // needs to be hollow... if the object is solid, the default, then the
    // media won't show correctly. don't forget to include this command!
    hollow
}

As you can see, media is a very powerful tool that will let you create a variety of amazing effects! It does take some practice to get a feel for how it works, but the results are well-worth the time spent learning.

More POV-Ray media examples to explore:
- Kurt Bangert and Carola Blaesing-Bangert, Media Examples
- Media and Particle Systems by Jenny Orr
- Web Walking: Media by Mike Kost

Questions? Ideas? Amazing scenes you’ve created? Leave a comment!

Click for larger view, or download the high-res image.

This image was 3D modeled in AC3D using the box modeling method. The textures were hand-painted (no photographs) in Corel Photopaint. The final image was rendered with Poser using image-based lighting.

If you aren’t familiar with normal maps, normal maps are a way to make your low-polygon model look more detailed by encoding surface information from a high-polygon version of the same model into a texture map. Ben Cloward has an excellent tutorial where you can learn more.

This plug-in requires the free NormalMapper utility available from AMD in order to process the output files. The companion NormalMapperUI (Stand Alone) available at the same location is also helpful, but not required.

Download the plugin. (Requires Windows XP, AC3D 6.2 or above.)

After I took the quiz, I went back and documented all the things that made me think a particular image was real or fake. That way I could see what it was that clued me so that I might improve my own work. In almost all cases, it wasn’t that the CG images were obviously wrong in any way, it was simply that the real images had more “detail” in them.

For years, the limitation has been what the software could do, but I’m not so sure that’s true anymore. In games especially, production costs have gone up as graphics have become more realistic simply because making detailed images is very time consuming. The relationship between time, money and graphics detail is linear. The problem, of course, is that neither time nor money are infinite. Limited budget means limited production cycles, which means limited time to spend adding things like scratches, scrapes and nose hairs. Eventually, we’ll reach a point where we can’t add more detail not because we’re out of RAM–we can’t add more detail because we’re out of time! Truthfully, I think we’re on the horizon of that already.

While I’m certain that there are still numerous improvements to be made in traditionally researched areas such as lighting, I think technological improvements to workflow have more potential to improve the quality of computer graphics in the near future than virtually any other area. Automated procedural geometry, better methodologies and tools that allow for less restrictive workflow patterns–such as recent advancements in re-topology interfaces–can allow us to complete the same job in less time and with far less effort. We know the artists and software can do it; now we need to make it practical.

For the curious, here are my impressions from the Autodesk quiz:

** WARNING ** Spoilers follow. You might want to take the quiz yourself before you read my analysis of the images.

The Car: Fake

What Gave it Away: Ok, I have to admit I have an unfair advantage on this one. I’ve worked on a half dozen racing games in my career, and I’ve seen a heck of a lot of CG cars. This is a really good image. Interestingly, my first tip-off that it wasn’t real wasn’t anything with the rendering itself: it was the composition! I don’t know why, but over the years car-on-a-cobblestone street has become nearly as ubiquitous as chrome sphere on a checkerboard. The real give-away though was the distance between the fence and the background elements. I’d bet dollars to donuts the buildings behind the fence are a 2D photo.

The Coffee Mug: Fake

What Gave it Away: This image was the easiest of the bunch to discerne. It suffers from a very common problem with CG images: the “too shiny” effect. Reflections can add a lot of realism to your scenes, but its easy to over-do it. Fewer reflections and a tighter lighting setup would improve this image significantly.

The Corkscrew: Real

What Gave it Away: On the far right edge of the main cylinder, there is a raised imperfection in the metal. In addition, the brushed metal behind the corkscrew is very difficult to do well in CG because of the unusual way the tiny lines distribute the light. I figured this one had to be real.

In recent years artists and developers have made great strides in making things look more real by making them less perfect, but we still haven’t reached the point where most images have intentional defects on this scale. Again, it’s less a technology issue, and more a time and workflow issue… in a production environment, there just isn’t time to add scuffs to every screw. I wouldn’t be surprised however if we start seeing major advancements to add exactly those kind of details in a completely automated fashion in the very near future.

Diamonds: Fake

What Gave it Away: The lighting is too uniform for real diamonds. Real diamonds have very complex refractions. These only seemed to have one or two levels of internal lighting on the gemstones.

Gemstones are an absolutely fascinating subject when it comes to lighting techniques… real gemstones are all about light! If you’d like a deeper exploration of the math, Richard Hughes has written an interesting article about the phenomena of brilliance, window and extinction in gemstones.

Bolt: Real

What Gave it Away: This image was very hard to tell. The graininess of the focal blur implies CG, and there’s an almost identical render done by Jaime Vives Piqueres in POV-Ray, so I knew it could be done. But, something about the pitting on the head suggested this one was probably real. The top of the bolt is smooth on the edges and pitted in the middle. Again, while there’s no technical reason this kind of detail can’t be added to a CG image, the time requirement means it usually isn’t, which is why I figured this one must be real.

Egg Beaters: Fake

What Gave it Away: The “whiteness” of the reflections. I have this problem with my own images sometimes, aargh.

Car Hood: Real

What Gave it Away: Like the coffee mug, this is another one I just knew from my gut immediately. The micro-distortions in the reflections, the angle of the shot, and the material qualities of plastic-chrome all made this image seem unlikely to be CG. (So I guess I know now what I need to add to my images!)

Wood Monkeys: Fake

What Gave it Away: The wood grain seems unnatural, something is out of scale about it. The monkeys are too similar to each other.

Texture scale is a very important visual cue that a lot of artists miss. An otherwise flawless texture will look far less realistic if it is too large or small. This is a common problem in video games, particularly, where textures may be reused on different objects to save on memory. If you can’t scale the texture because of system requirements, a handy trick that sometimes works is to scale the UVs instead.

Glass Chips: Real

What Gave it Away: Wow, bubble mania! Even with macros, this shot would be difficult. The diffusion on the glass (gel?) also seems to have some sub-surface scattering and other complex lighting that most renderers would be hard-pressed to replicate with precision (yet).

Green Peppers: Real

What Gave it Away: This one was tricky, because I think a render of this quality could be achieved. I knew most CG artists would make at least some of the peppers identical, or at least morphs of each other, so I immediately started looking for repeats. After a moment of study, it was clear they were all unique, and even the bottoms had a lot of fine detail. I figured the image must be real.

Thoughts? Comments? Tips and tricks for adding realism? Leave a comment!