Assets and Dynamics Computation for Virtual

Worlds

Assets and Dynamics Computation for Virtual

Worlds

Scalable City Architecture

• The Scalable City project has required larger, more interactive environments than previously practical.

• Its development has resulted in many novel techniques.

Overview of Dynamics

• Scalable City software built to handle large, temporally coherent environments efficiently.

– Incremental processing methods

– Minimize required work

• Example: Physics performance

– Resting objects do not affect run-time

– Overhead proportional to level of activity, rather than environment scale

Spatial Proximity Determination• Sweep and Prune: O(un⅔ + (i + r)n + e + o)

Spatial Proximity Determination

• Hybrid S&P: O(u + (i + r) + e)

Incremental Physics Pipeline

• Novel method for processing resting bodies and potential activations caused by collisions.

• Again, asymptotically superior performance.

Incremental Physics Pipeline

Increasing bodies at rest (not being interacted with) in the simulation

Parallelizing Physics

• Multi-threaded physics engine• Parallelized traditional physics engine

components without altering algorithms

Client/Server Data Synchronization

• Due to high interactive object count, determining minimum data set to synchronize a client is challenging.

• What we could not do due to performance constraints:– Clients could not retain knowledge of all objects– Server could not traverse object set for sake of

client updates– Server could not efficiently track client knowledge

Client/Server Data Synchronization• Our solution utilized:

– Spatial proximity detector producing player/object mapping to zones.

– Each state change associated with a rule that determined the set of clients to update without explicit object-level knowledge of client state.

– All events placed in order-dependent queue with common format.

• Result: No measurable overhead for synchronization.

Rendering Optimizations

• Roads and fences consist of many simple objects that require animation.– Drawing many simple objects is sub-optimal.– Animation updates constrain solutions

• New system treats all roads in a city as a single, large mesh with subset of vertices animating– Single draw call, geometry retained on GPU

Example: Rendering Optimizations

• We mirror vertices in CPU memory and transfer changes to GPU each cycle.

• Transferring updates to GPU has trade-offs

– Each operation incurs an overhead that is a “constant plus bytes” transferred.

– Optimal for full update is a single, continuous transfer.

– Optimal when no updates are necessary is “do nothing”!

– Our case is an unknown subset of updates requiring transfer.

CPU Buffer

GPU Buffer

Example: Rendering Optimizations• Goals:

– Ideal performance on full updates

– Ideal performance on few updates

– “Graceful degradation” in between

• Set of updates will have clusters

– Many associated vertices animating together

• We want to minimize cost of updating GPU

– Divide-and-conquer algorithm

Example: Rendering Optimizations

• Accumulate update positions into ranges:– if # updates significant % of range

• transfer whole range

– else• split ranges on largest gap and recursively call for both sides

• Algorithm provides good performance for conditions in which there’s a trade-off between transferring contiguous bytes and limiting total data transferred.

CPU Buffer

GPU Buffer