Render - Advanced Tab

From Terragen Documentation from Planetside Software
Revision as of 03:55, 4 March 2014 by Jo (talk | contribs)
Jump to: navigation, search

Render - Advanced Tab

The Advanced Tab holds some advanced settings for managing the rendering process. There are settings related to the number of threads used during a render, certain blocks of memory used during rendering and how some render information is generated.

Managing render threads
TG2 can render different sections of the image at the same time. These image sections are known as buckets. Many computers have multiple processors or cores and on computers which do rendering can be completed faster if each processor/core renders a bucket at the same time. The buckets are assigned to render threads. A thread is a section of a computer program which can do work at the same time as other parts of a program.

When TG2 starts up it automatically detects the number of processors or cores your computer has. This number is displayed on the Splash Screen. By default TG2 creates one render thread for each processor/core it detects. For example, if your computer has 4 cores then TG2 will create 4 render threads during rendering. This means TG2 can render 4 buckets at the same time. It is possible to override the core detection in the Startup panel of the preferences.

The render node gives you more control over this. You can use the Minimum threads and Maximum threads params to influence how many render threads TG2 creates. These params set the the upper and lower limits of the number of render threads created. The Maximum threads param is really the most useful of the two and the param you are most likely to want to change.

Let's say your computer has 4 cores and you only want it to use 3 cores for some reason. To do this you would set the Maximum threads param to 3. You could use the Minimum threads param to force TG2 to create more render threads than it normally would, although this is not recommended.

Managing the subdivison cache
As TG2 renders it subdivides scene geometry into small pieces. It can store these small pieces in a subdivision cache to save having to recalculate them so often for things like ray traced shadows, reflections and GI rays, which can make rendering faster. There are two settings you can use to control the subdiv cache. You can set the maximum size of the subdiv cache using the Size of subdiv cache in MB param. This controls the maximum amount of memory TG2 can dedicate to the subdiv cache. The subdiv cache is divided up between render threads. If 4 render threads are created each thread will get 100 MB of the subdiv cache.

If you set the subdiv cache so small that less than 50 MB would be used per render thread TG2 will automatically increase the subdiv cache size to the minimum of 50 MB per thread.

Normally TG2 will use up the subdiv cache on an as-needed basis. The size param limits how can much be used but it may not use that much. There may however be times when you want the subdiv cache to be created in it's entirety when rendering starts. You can use the Preallocate subdiv cache param for this. One situation where you might want to do this if you are having problems with running out of memory during rendering. By preallocating the subdiv cache you might help these sorts of errors become apparent sooner, which can save time in trying to figure out what is going wrong.

You may be tempted to set the subdiv cache to quite a large size. While increasing it a bit can be helpful in some scenes we don't recommend that you increase it a lot, particularly if you also check the preallocation option. When running in 32 bit mode TG2 may only have 2 to 4 GB of memory available. If you were to set the subdiv cache size to 1600 MB (1.6 GB) then that could mean only 400 MB of memory is left for other purposes. In this case you are likely to experience render errors or other problems. Even if you are using the 64 bit version setting the subdiv cache size too large can unnecessarily use up memory and may cause rendering to become slow or cause errors to occur.

If you want to experiment with the subdiv cache size 100 to 150 MB per render thread is a good place to start. As with many advanced settings the best results will probably vary between different scenes.

Note that the 64 bit version has different default settings for the subdiv cache size than the 32 bit version. This is because memory is not quite so restricted in the 64 bit version and so TG2 bases the default size on the number of cores detected.


  • Minimum threads: Sets the minimum number of threads TG2 creates during rendering.
  • Maximum threads: Sets the maximum number of threads TG2 creates during rendering.
  • Size of subdiv cache in MB: This param controls how many megabytes of memory the subdivision cache can use.
  • Preallocate subdiv cache: If this is checked TG2 will allocate the entire subdivision cache when rendering starts.
  • Ray detail region: The ray detail region is the area in the scene where polygons are fully subdivided by the ray tracer. Polygons outside this area are only coarsely subdivided. Sometimes you might have problems like shadows cast by objects outside the the camera view not seeming accurate. This could be corrected by changing the ray detail
    • No detaIl: TBC
    • Detail in crop region: TBC
    • Detail in camera: TBC
  • Ray detail region padding: This value sets the amount of extra detail around the camera or crop region area. 0 means no padding. 1 adds a border around that area which is the same as the width or height of the area. This will make the ray detail region 3 times as wide and 3 times as tall.
  • GI prepass padding: This setting does a similar thing to the ray detail region padding, but it works on GI samples. The padding can help to resolve problems with GI differences around the edges of crops or images. These might be apparent if you're stitching images together. Small values are recommended. 0.1 might be a good starting point.

Example Movies

GI prepass padding

Back to: Render

When Terragen renders, it divides the image up into buckets or tiles. Each bucket is rendered separately, allowing multiple buckets to be rendered at once. It also allows memory to be used more efficiently.