LODManager

A framework for rendering multiresolution models in

real-time applications

J. Gumbau O. Ripollés M. Chover

Introduction

• LOD techniques are important on highly populated scenes.

• Continuous multiresolution methods reduce popping– But extracting a LOD has a cost (extracting overhead)

• Use of CLOD on massive scenes without control:– Is completely inefficient

– Drastically reduces interactivity

• Our aim: manage efficiently the LOD of those scenes.

Previous work

• Solutions to the LOD management problem:– Methods based on static heuristics:

• Static metric: distance or screen-space area

• Easy and cheap to evaluate

• Not adaptive and unstable frame rates

– Methods based on feedback algorithms:

• Good when there’s coherence between frames

• Present oscillations on discontinuous environments

– Methods based on predictive algorithms:

• Very accurate but has a great computational cost

• Scenes with lots of objects can become too slow

• They are inefficient solutions on massive scenes

Motivation

• Nowadays GPUs are extremely powerful but very delicate:– Overload the CPU can become a bottleneck– Change GPU data can cause a stall

• Our aim is to create a CLOD manager for massive scenes which:– Minimizes CPU time used to decide the LOD

for each object– Minimizes GPU data changes

Method overview

• We present a method which:– Is designed for massively populated scenes

• with thousands of dynamic objects

– Has very low CPU requirements• to keep the bottleneck on the GPU

– Provides frame rate feedback• to globally adjust the LOD of the scene

– Is based on sharing already calculated LODs• to minimize GPU data changes• minimize CPU usage

Method details

• The user defines a set of n LOD slots– This is called the LOD snapshots list– A slot i refers to an object with a certain level of detail.

• If an object must change it’s LOD:– If another object changed to a similar LOD:

• Borrow its already calculated level of detail– Otherwise, calculate its own level of detail

• And insert itself into the LOD snapshot’s list

Method improvements

• Use a non-linear distributed LOD snapshots list– So nearer objects will have higher LOD granularity– Makes less perceptible discretization artifacts

Feedback

• LOD factor is calculated using a static metric• Uses frame rate feedback to globally adjust LOD

– Uses a perturbation function

The perturbation parameter n depends on the difference between the real and the desired LOD

Test and Results

• Test scene: 3000 LOD objects

The graph shows a CPU bottleneck when the LOD Manager is disabled. time

Conclusions

• Efficient LOD management on massive scenes– Algorithm with very low CPU requirements:

• Cost of querying and borrowing a similar LOD is negligible• Drastically optimizes real changes in levels of detail

– LOD Borrowing minimizes GPU updating• reduces unnecessary GPU stalls• optimizes bus traffic

• Drawback: Dynamic LOD discretization of a multiresolution model, but:– Has less memory consumption– The number of virtual discretizations is user defined– The system can decide whether to borrow or not?

Any questions?