RenderVolumeLODFactor - ApertureViewer/Aperture-Viewer GitHub Wiki

Technical Deep Dive: RenderVolumeLODFactor (Object Detail)

Abstract:

The RenderVolumeLODFactor setting is a pivotal user-configurable parameter within the viewer's rendering pipeline, governing the distance-based Level of Detail (LOD) transitions for general scene objects ("Volumes"). It allows users to balance visual fidelity against rendering performance. A higher factor maintains object detail further into the distance, enhancing visual quality at the cost of increased computational load, while a lower factor improves performance by simplifying objects sooner. This revised paper provides a detailed technical analysis of the setting's mechanism grounded in the codebase, clarifies its impact on transition distances using concrete examples, discusses performance implications, examines configuration constraints, prescribes a testing methodology, and offers updated recommendations for effective utilization.

1. Introduction

Rendering complex 3D virtual environments demands efficient Level of Detail (LOD) systems to manage performance. These systems dynamically reduce the geometric complexity of objects based primarily on their distance from the viewer, rendering distant objects with fewer polygons. The RenderVolumeLODFactor setting grants users control over this process for standard scene objects (LLVOVolume), enabling customization of the visual fidelity vs. performance trade-off. This paper clarifies how this factor precisely influences the distance at which LOD transitions occur.

2. Mechanism of Action: Code Analysis

The core logic resides in LLVolumeLODGroup::getDetailFromTan and the calculation feeding into it, primarily within LLVOVolume::computeLODDetail (when LLPipeline::sDynamicLOD is active).

2.1. Apparent Angular Size Calculation: The system determines an object's LOD based on its apparent angular size in the viewport, approximated by tan_angle:

// Simplified from LLVOVolume::computeLODDetail
F32 lod_factor = LLVOVolume::sLODFactor; // RenderVolumeLODFactor value
F32 distance; // Distance from camera to object
F32 radius;   // Object's approximate size

F32 tan_angle = (lod_factor * radius) / distance;

Here, lod_factor directly multiplies the object's radius, effectively scaling its perceived size for the LOD calculation.

2.2. LOD Thresholds: The calculated tan_angle is compared against predefined thresholds stored in LLVolumeLODGroup::mDetailThresholds. These thresholds dictate which LOD index is selected:

// From llvolumemgr.cpp
const F32 BASE_THRESHOLD = 0.03f;
static F32 LLVolumeLODGroup::mDetailThresholds[NUM_LODS] = { // Assuming NUM_LODS = 4
    BASE_THRESHOLD,         // 0.03f (Threshold for LOD 0 -> LOD 1 transition)
    2 * BASE_THRESHOLD,     // 0.06f (Threshold for LOD 1 -> LOD 2 transition)
    8 * BASE_THRESHOLD,     // 0.24f (Threshold for LOD 2 -> LOD 3 transition)
    100 * BASE_THRESHOLD    // 3.0f  (Potentially unused/max threshold)
};

// From LLVolumeLODGroup::getDetailFromTan
S32 LLVolumeLODGroup::getDetailFromTan(const F32 tan_angle) {
    S32 i = 0;
    while (i < (NUM_LODS - 1)) {
        // If tan_angle <= threshold[i], object is small enough for lower detail LOD 'i'
        if (tan_angle <= mDetailThresholds[i]) {
            return i; // Return LOD index i
        }
        i++;
    }
    // If larger than lower thresholds, return highest detail LOD index
    return NUM_LODS - 1;
}

A smaller tan_angle (object appears smaller/further) results in the function returning a lower LOD index (less detail).

2.3. RenderVolumeLODFactor Influence: By multiplying the radius in the tan_angle formula, a higher lod_factor inflates the calculated tan_angle. This makes the object seem larger/closer to the getDetailFromTan function, causing it to select a higher detail LOD index or, crucially, to maintain the current detail level out to a greater actual distance.

3. Transition Distances and Examples

There is no single, fixed "base distance" defined in meters within the code. The transition distances are dynamic and calculated based on the object's radius, the specific LOD threshold, and the user's RenderVolumeLODFactor.

3.1. Calculating Transition Distance: The transition from a higher detail level (e.g., LOD i+1) down to a lower detail level (LOD i) occurs precisely when tan_angle drops to equal mDetailThresholds[i]. We can solve for the distance at which this happens:

mDetailThresholds[i] = (lod_factor * radius) / distance

distance = (lod_factor * radius) / mDetailThresholds[i]

This formula gives the maximum distance (in meters) at which an object of a given radius (in meters) will maintain the higher detail level i+1 before simplifying to LOD i, given the current lod_factor.

3.2. Concrete Examples: Let's examine the transition from LOD 3 (highest detail) down to LOD 2. The relevant threshold is mDetailThresholds[1] = 0.06f (Correction: Threshold separating LOD 3 and LOD 2 is mDetailThresholds[2]=0.24f based on the getDetailFromTan logic returning index i if tan_angle <= threshold[i]). Threshold is mDetailThresholds[2] = 0.24f.

Object Radius lod_factor (RenderVolumeLODFactor) Max Distance for LOD 3 (meters) Calculation
1.0 m 1.0 ~4.17 m (1.0 * 1.0) / 0.24
5.0 m 1.0 ~20.83 m (1.0 * 5.0) / 0.24
0.1 m 1.0 ~0.42 m (1.0 * 0.1) / 0.24
--- --- --- ---
5.0 m 2.0 ~41.67 m (2.0 * 5.0) / 0.24 (2x distance)
5.0 m 4.0 ~83.33 m (4.0 * 5.0) / 0.24 (4x distance)
5.0 m 8.0 ~166.67 m (8.0 * 5.0) / 0.24 (8x distance)

Observations:

  • The distance at which LOD transitions occur scales linearly with RenderVolumeLODFactor. Doubling the factor doubles the transition distance.
  • Larger objects naturally maintain higher detail levels out to greater distances than smaller objects, even with the same factor.
  • Very small objects (radius=0.1m) simplify extremely quickly, even with a factor of 1.0.

4. Performance and Visual Impact Revisited

4.1. Visual Impact: The examples above quantify why low factors can cause visible issues. An object 5 meters wide simplifying at ~21 meters (factor 1.0) might be acceptable, but simplifying at ~4 meters (factor 1.0, radius 1.0m) or ~0.4 meters (factor 1.0, radius 0.1m) is extremely close and likely jarring. Increasing the factor pushes these transitions further away, mitigating close-range deformation, potentially at significant performance cost. The quality of the simplified LOD models remains a factor in how noticeable these transitions are.

4.2. Performance Impact: The non-linear performance cost remains crucial. While doubling the factor doubles the transition distance, the volume of space requiring high-detail rendering increases much faster. Rendering 4x or 8x the number of high-detail objects in the newly included distance range drastically increases GPU polygon count, VRAM usage, and potentially CPU draw calls.

5. Configuration, Clamping, and Recommended Ranges

5.1. Configuration & Clamping: The setting is read via gSavedSettings.getF32("RenderVolumeLODFactor") and clamped between 0.01f and MAX_LOD_FACTOR (value requires verification, but likely 4.0f based on historical context). Values set outside this range in preferences will be adjusted to the nearest limit internally.

5.2. Recommended Ranges (Revised):

  • Minimum Practical (0.5 - 1.5): Offers potential performance gains but may exhibit noticeable and potentially undesirable object deformation even at moderate distances for small-to-medium objects, especially if base LOD models are suboptimal. Use if performance is paramount and visual compromises are acceptable.
  • Balanced Range (1.5 - 3.0): A common starting point. Aims to balance performance with acceptable visuals for most objects at typical viewing distances, though close inspection of smaller objects might still reveal simplification.
  • Visually Focused (3.0 - 4.0): Significantly prioritizes visual fidelity by pushing simplification further out. Suitable for users with capable mid-to-high-end hardware who are sensitive to LOD transitions. Monitor performance, especially in dense scenes.
  • High-End / Compensatory (Above 4.0 up to MAX_LOD_FACTOR): Primarily for users with powerful modern hardware seeking maximum distant detail or needing to compensate for poor close-range visual quality caused by aggressive base LOD switching or low-quality simplified models. Expect significant performance costs and understand this pushes the engine beyond typical optimization points, potentially risking instability in edge cases.

6. Recommended Testing Procedure

Rigorous testing is essential to understand the real-world impact:

Hardware Diversity: Test across low-end, mid-range, and high-end GPUs/CPUs.

Scene Complexity: Use both simple scenes (for isolation) and complex, crowded scenes (for stress testing).

Metrics:

  • Average and Minimum FPS.

  • GPU Utilization (%) and VRAM Usage (MB/GB).

  • CPU Utilization (%).

  • Subjective visual quality assessment (distant object clarity, LOD transition noticeability, close-range deformation).

Methodology:

  • Establish baseline performance at various RenderVolumeLODFactor levels (e.g., 0.5, 1.0, 2.0, 3.0, 4.0, and potentially higher if MAX_LOD_FACTOR permits and hardware allows).

  • Compare performance and visuals in simple vs. crowded scenes.

  • Specifically observe object deformation at different distances for factors around 1.0-3.0.

  • Document findings meticulously, correlating performance metrics with visual observations across different hardware profiles.

7. Future Considerations

Base LOD Model Quality: Investigate and improve the quality of the lower-detail models generated by the engine to reduce visual artifacts during LOD transitions, potentially lessening the need for users to rely on very high LOD factors.

Adaptive LOD Factors: Explore systems that dynamically adjust the LOD factor based on real-time performance or scene complexity, offering a more automated balance.

Per-Object Type Tuning: Evaluate if finer-grained control beyond the existing categories (Volume, Avatar, Tree, Terrain) would be beneficial.

8. Conclusion

RenderVolumeLODFactor provides granular control over object simplification distance, directly impacting the visual fidelity vs. performance balance. It linearly scales the distance at which LOD transitions occur, calculated based on object radius and predefined angular size thresholds. While higher factors mitigate close-range visual artifacts (potentially compensating for suboptimal base LODs), they incur a non-linear performance penalty. Users must choose a value appropriate for their hardware and visual priorities, understanding the effective range is clamped between 0.01f and MAX_LOD_FACTOR (likely 4.0f), and that exceeding historically common limits demands capable hardware and careful performance monitoring.