Textures are one of the most important components for realism, but it is important that users understand that larger textures bring with them increased memory consumption and rendering time. Nobody would ever consider wrapping an 8 inch birthday gift with 50 square yards of wrapping paper, but some users think nothing of using a 1024 x 1024 pixel image to map an object that may appear very tiny in a rendered scene.

Textures for RPC Content are automatically optimized by the RPC Plug-in. Depending on the location of RPC Content in a scene, textures are dynamically scaled to reduce memory consumption. This is just one more way that RPC Content makes life easier for the user. For Non-RPC textures you have to do the work. Following are some tips.

Rendering professionals all want realistic textures, but using too many pixels may result in adverse effects without improving the overall rendering quality. Rendering errors may include disappearing RPC objects, strange multi-colored artifacts and increased rendering times. Many of these memory errors can be eliminated by using textures wisely.

Below you will see an example of two different renderings. The renderings appear identical, but Image 1 requires approximately 4.2 MB of memory to render, while Image 2 requires only 66 Kb of memory. The difference comes from using correctly sized textures.

Image 1 (4.2 MB)

Image 2 (66 KB)

As you can see there is no visible difference between the two images, but I have saved 4 MB of memory just for this brick wall. In a larger scene where you are using hundreds of textures this technique can save you an incredible amount of memory.

In this simple scene I have created a wall that is 6 meters wide and 2 meters tall. To render the first image I used a 1024 x 1024 pixel texture that represents a 1 meter x 1 meter area. To make this image cover the entire wall I have tiled it 6 times along the width and twice along the height.

When I analyze the rendered image in Photoshop I can see that my wall is 465 pixels wide (530 - 65), and 155 pixels tall (200 – 45). Since the texture is tiled 6 times in the width the rendered resolution of my texture is 77.5 (465 divided by 6). For the height the texture is only tiled twice (2 times) so the vertical resolution of my rendered texture is also 77.5 (155 divided by 2). This means that a 78 x 78 pixel texture will look just as good as a 1024 x 1024 pixel texture in this rendering.

To generate Image 2, I went into Photoshop and scaled my brick texture to 128x128. I then created a new material in the material editor that used this smaller image and applied it to the wall.

Image was cropped to fit this web page.

Actual Size Shown.

It is not always necessary to use the full technique I described above. Often times a simple estimation will be good enough. If we are rendering 640x480 video, and the wall will fill most of the frame (640 pixels) and is tiled 6 times then 107 pixels (640 / 6) would be a large enough texture. But even estimating very conservatively and using a 256 x 256 pixel texture would only use 263 KB of memory compared to 4.2 MB for the full 1024 x 1024 image.

When selecting or resizing a texture always consider the geometry that it will be applied to. Objects that will render larger in the scene will require larger textures. Objects that will render smaller should use smaller textures.

People often concern themselves with the file size of a particular texture. What they should instead consider is the actual number of pixels. A bitmap file that is 3 Megabytes in file size, but only 512 x 200 pixels uses the same amount of memory during rendering as a 500 KB jpg file that has the same number of pixels.

Note: If you really want to know how we are calculating the memory usage it is (pixel height * pixel width * number of channels * 1.333). In our case the number of channels is always 3 (red, green, and blue), and the value 1.333 is the amount of extra memory required for Pyramidal filtering in Max. If you were using Summed Area filtering you should replace the 1.333 with 4.

Why RPC is Smarter

The development team at ArchVision had all of this in mind when they developed the RPC Plug-in. You may have noticed the RPC Preperation dialog, which appears before rendering each frame in a scene. During this phase, the RPC Plug-in optimizes the texture sizes for each RPC so that you get great looking renderings with maximum memory efficiency. An RPC that is a great distance from the camera will load a smaller texture, whereas an RPC very close to the camera will load the largest texture from the RPC to provide better render quality.

This is one more reason why RPC is a smarter choice than using traditional mapped texture techniques or costly high poly models. ArchVision's goal is to provide tools that make rendering easier and more efficent without you having to do a thing. Sit back and let the RPC Preperation dialog do all of the work.