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?