XBR Graphics: Quicksilver

As part of our XBR effort, we are completely reworking our viewport system, the first part of this was our metasl integration back in 3ds Max 2010. The next part of the effort is a new GPU-based rendering system that will first show up as a hardware-based rendering system in 3ds Max 2011. Our goal wasn’t so much to perfect yet another production rendering solution, as much as take something we were working on and release it as a feature that you can hammer on now and get some benefits from. Some of you will be able to use Quicksilver in your workflows and others will not because your needs don’t map to what Quicksilver is good at. Our orientation is to give you a better tool than viewport capture but not spend our resources trying to replace existing production rendering solutions. Basically, it is a very simplified workflow that is pretty identical to our mental ray workflow (whatever you set up in Quicksilver can be rendered in mental ray without much effort). Some people will use it for faster previews, and client sign-offs, some might use it for actual production purposes because their needs match Quicksilver’s capabilities and they gain a big advantage with its performance. It’s certainly not for everyone nor for any problem. We have measured 10X or more improvements at the same visual quality for many scenes over mental ray, but depending on your hardware and needs your results could be a lot different. If you have 8 or more CPU cores and not much of a GPU, you're going to likely be better off with a sw renderer. If you have 4 cores or less, and a relatively beefy GPU, then you might get the benefit depending on what you're trying to render.

What it is:

It uses both the GPU and CPU to perform the rendering. You can somewhat think of it as a game-engine for rendering since it uses DirectX 9c and the GPU to get the job done. This is driven using advanced shader technology from mental images (MetaSL) and some technology we've built. Because we're using these game engine techniques, you can render a 10M+ poly scene with just a 512Mb graphics memory since we use vertex buffers very efficiently. We’ve built Quicksilver from the ground up (except mental image’s MetaSL) and there is some magic sauce involved in generating adaptive shadow maps and our indirect lighting mode that I don’t believe you’ll find in any other generalized GPU rendering system. We use the CPU primarily to translate the scene data to the renderer. It will also be used to compile the shaders and generate data for the indirect lighting pass. Both systems are fully multi threaded, including the shader compilation. We have to compile shaders for specific GPU configurations – which helps future-proof this technology. When you first run Quicksilver, you’ll experience a pause on the first frame. The first frame can take a while due to the fact the shaders need to be compiled. This can be a light weight operation or costly. For example adding noise maps to a shade tree can add up to 3,000 instructions. This not only takes time to compile, but is also close to the limits of the shader model 3.0 standard. 3ds Max maintains a cache of these compiled shaders that effectively live forever. The more you use Quicksilver the faster it becomes – it will only rebuild a shader if the system detects a newer shader on the system. The user is free to flush the cache whenever they desire. Quicksilver only supports metasl-based shaders. The good news is that you now have “Slate” our new node-based material editor which lets you create shade trees directly with MetaSL and we’ve converted most of our legacy shaders in 3ds Max to MetaSL. This means a lot of existing materials will just work “as is”. It’s important to realize that the new MetaSL shaders are a one to one reproduction of the original 3ds Max procedural maps. This has one important benefit - the viewport can display the shader as it will render in Quicksilver or in mental ray or even in scan-line. Of course, making sure you have pixel-level detail for this requires lots of shader instructions – which requires more GPU resources to do it quickly.

Some of the key technology/features that you’ll find in Quicksilver includes:
- Use of MetaSL shaders
- Sophisticated shadowing system including adaptive shadow map creation (provides fine detail of shadows in large scenes)
- Photometric lights
- Indirect Lighting simulation (not screen space like 3ds Max 2010, emulates effects of indirect lighting)
- Reflections of dynamic objects (non-raytraced)
- Ambient Occlusion (screen-space)
- DOF (shader effect)
- Motion blur (from camera passes)
- Hardware and software based anti-aliasing and supersampling
- Alpha and Z-buffer render elements
- Larger-than-screen resolutions
- Hundreds of dynamic lights (if you have enough GPU for this)
- Floating point render pipeline with tone-mapping
- Support for Backburner (you better have the same GPU on each node or you'll get unpredictable results)
- Multi-threaded CPU optimization

What it isn’t:

It is not a ray-tracing approach. If you have those kinds of needs, use mental ray or the scanline renderer or your favorite renderer. You can’t throw everything at Quicksilver and still expect it to render faster than anything else you have. It is very, very good at a class of problems and that class of problems is bigger with more powerful GPU hardware. There are many limitations in Quicksilver that may prevent you from applying it in your workflow.

Limitations:

These are various bugs and issues with using Quicksilver. Some of these limitations are targeted for bug fixing while others require additional research and development (and we can't talk about future plans for features). We'll try to keep you all updated (and this doc) when the status of some of these change.

• You will sometimes see “black surfaces”. These are usually signaling to you that a material failed to compile – either because it is too complex or because it is not supported by Quicksilver. You will need to use a different rendering solution or replace these materials to get things to work properly.
• Quicksilver currently needs to have tiling enabled in the Bitmap Texmap - the shader currently doesn’t like it when these are unchecked
• No blend material, matte/shadow material, composite map or material
• 3ds Max's falloff node is supported to a degree - basic setups, the rest is baked. However, the new falloff metasl node is supported.
• No "ink n'paint" but there are some ways to use MetaSL to achieve some of these affects
• Doesn’t respect object properties (can’t hide reflection planes, etc.)
• Supports all 3 types of 3ds Max sky lights but without Image Based Lighting (IBL) - you'll see the mr sun/sky system - but without IBL
• No support for the self illumination shader in A&D nor the rounded corners shader (the shader would be too complex to compile/run)
• Only supports cube map reflections (no planar reflection at this time)
• No support for shadow patterns
• It does not support Render to Texture

Things that will kill performance:

• Noise maps are very expensive shaders
• Lots of transparent surfaces
• Too many things selected for dynamic reflection

Hardware considerations:

• We only use a single GPU at this point, either consumer boards or professional boards – we recommend professional boards as these are the ones we focused on certifying. See certified boards http://www.autodesk.com/max-hardware (will be updated for 3ds Max 2011 at some point)
• Quicksilver does not use CUDA or OpenCL at this time - it only uses DirectX 9.
• Quicksilver requires a minimum of 512Mb of dedicated graphics memory to get results, in practice you’ll want 1Gb+
• Both nvidia and ATI hardware are equivalent in feature support – performance-wise is impossible to state because it will depend on your scene and specific hw/driver configurations
• Use the GFX Checker app to help understand if your hardware has any obvious problems with running Quicksilver. Install and double-click on the .bat file - that will generate a log file.

Tips/Tricks:

• If you run into problems, try running QS in forward shading mode. In the Maxscript listener, type the following: renderers.current.lightingmode = #forward
• If you don’t care about the 2D Coordinate rollout of the bitmap texture, use the MetaSL node “Texture Lookup 2D” – you will be able to cram more into your shade trees.

Additional details:

Supported materials:

• Arch & Design material, including the new Autodesk Materials (but not ProMaterials)
• Standard material
• Double-Sided material
• Multi/Sub-Object material

Supported maps/shaders:

• All MetaSL shaders (no support for DirectX shaders at this point)
• mental ray shaders:
  • mr Physical Sky
  • Utility Gamma & Gain shader

Standard maps:

• All Standard maps are supported except for the following:
  • Cellular map (converted to baked map)
  • Gradient Ramp map (converted to baked map)
  • Output map (converted to baked map)
  • Vertex Color map

Examples:

Quicksilver in 3ds Max Design 2011 (above). Shows viewport versus Quicksilver render of the same scene. Here's a video (30Mb) of the workflow.

Quicksilver result (above)

mental ray result (above)

Quicksilver (above). Rendered at 1k x 563 in 7 seconds. HP 6400 with ATI 4870.

Quicksilver result (above). Click on this video to see an animation.

mental ray result (above)

Click on the image above to see a video of the setup. Click on this to see a video of just the output. Image from Autodesk developers. HP 6400 with ATI 4870.

Quicksilver, click on the image above to see a video of the animation. Roughly 11 secs/frame with reflections, 4 secs/frame without. Click on this to see a short segment with motion blur (rended in 1 hour 40 minutes). Animation courtesy of Primary Focus (aka Frantic Films team). HW: Nvidia FX 4800.