Accurate Real-time Physics Simulation for Large Worlds

Lorenzo Schwertner Kaufmann, Flavio Paulus Franzin, Roberto Menegais and Cesar Tadeu Pozzer

Universidade Federal de Santa Maria, Santa Maria, Brazil

Keywords:

Real-time Physics Simulation, Physics Engines, Large-scale Simulations, Floating-point Imprecision.

Abstract:

Physics simulation provides a means to simulate and animate entities in graphics applications. For large envi-

ronments, physics simulation poses signiﬁcant challenges due to the inherent known limitations and problems

of real number arithmetic operations. Most real-time physics engines use single-precision ﬂoating-point for

performance reasons, limiting simulation with a lack of precision that causes collision artifacts and positioning

errors on large-scale scenarios. Double-precision ﬂoating-point physics engines can be used as an alternative,

but few exist, and fewer are supported in game engines. In this paper, we propose an efﬁcient solution capable

of delivering precise real-time physics simulation in large-scale worlds, regardless of the underlying numeric

representation. It implements a layer between high-level applications and physics engines. This layer subdi-

vides the world into dynamically allocated sectors which are simulated independently. Objects are grouped

into sectors based on their positions. Redundant copies are created for objects crossing sectors’ boundaries,

providing seamless simulation across sector edges. We compare the proposed technique performance and

precision with standard simulations, demonstrating that our approach can achieve precision for arbitrary scale

worlds while maintaining the computational costs compatible with real-time applications.

1 INTRODUCTION

Physics simulation plays a fundamental part in many

virtual scenarios across a broad range of applications,

including games, ﬁlms, and simulations. Physics are

simulated using physics engines —low-level middle-

ware that provides support to physical behaviors, such

as ﬂuids, soft and rigid bodies simulation. Games and

simulations rely on real-time physics engines to pro-

vide dynamic, immersive scenarios. For performance

reasons, most of these engines operate with single

ﬂoating-point precision, enough to cover a wide range

of applications. However, for large-scale scenarios,

these engines present a limitation due to the low ac-

curacy of the ﬂoating-point numbers, especially when

representing big numbers. Simulations for objects far

from origin might use imprecise values, causing fail-

ure in the collision detection algorithms, varying from

small intersections that do not compromise the over-

all simulation to big intersections that spoil the simu-

lation (e.g., vehicles falling off a terrain). Moreover,

nowadays, it is noticeable that 3D games and graph-

ical simulations, used for training or amusement, are

dealing with constantly expanding scenarios, thus re-

quiring solutions to enable proper visualization and

simulation of moving entities.

Floating-point imprecision occurs because com-

pressing inﬁnite real numbers into a limited amount of

bytes requires an approximate representation (Gold-

berg, 1991). IEEE-754 ﬂoating-point represents real

numbers as δ × β

, where δ is a signiﬁcand, β is

a base, and ε is an exponent, thus rounding error

increases proportionally to value magnitude. Most

arithmetic operations using values represented with

ﬂoating-point precision produce results that cannot be

represented using a ﬁxed amount of bits, thus requir-

ing rounding.

In physics simulations, the rounding error in-

creases proportionally to objects’ distance from the

origin on which the simulation is continuously per-

formed, and error accumulates over error. Empiri-

cal experiments suggest that single-precision ﬂoating-

point limit is 10

units (Unity Community, 2018);

while others deﬁne it at 5×10

units (Unity Commu-

nity, 2017), or within the range of 4 ×10

to 8 ×10

units (Burk et al., 2016). Thus, applications with sce-

narios larger than these dimensions are susceptible

to numerical inaccuracy and may present problems

throughout the physics simulation.

In terms of accuracy, some physics engines are

designed to support double (e.g., Bullet and New-

ton Dynamics) instead of single-precision to repre-

sent the physics components and provide more accu-

racy in calculations. Double-precision math (and thus

Kaufmann, L., Franzin, F., Menegais, R. and Pozzer, C.

Accurate Real-time Physics Simulation for Large Worlds.

DOI: 10.5220/0010194501350142

In Proceedings of the 16th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP 2021) - Volume 1: GRAPP, pages

135-142

ISBN: 978-989-758-488-6

135

double-precision matrix and vector APIs) cannot take

as much advantage of SIMD instruction sets (Ericson,

2005), which are generally sized to support and vec-

tors that have 32-bit wide components. Few physics

engines support double ﬂoating-point precision and

game engines, such as Unity, Unreal Engine 4, Cry

Engine 3 and Godot do not natively support them.

An alternative to increase numerical precision is

the origin shifting approach. This approach estab-

lishes a real-time center point (e.g., the observer po-

sition), and 1) physics simulation considers the cen-

ter point as the Cartesian origin or 2) the objects are

shifted to the Cartesian origin, having a center point

as a reference, maintaining the same layouts of ob-

jects’ position. In an efﬁcient and precise way, this

approach guarantees the physical simulation for any

dimension of the scenario. However, physics objects

must be close to an arbitrary center point. Otherwise,

inaccuracy errors remain. For sparsely distributed

simulations, e.g., multiplayer games, origin shifting

does not work.

We present a solution compatible with real-time

simulations that expands state-of-the-art physics en-

gines, ensuring physics simulations enough precision,

regardless of the world scale and underlying numeric

representation. Our solution is implemented as a layer

between high-level applications and physics engines.

This layer split the world in sectors and adds re-

dundancy to each sector, ensuring each part has all

the required information to, independently, be sim-

ulated without inconsistencies close to the Cartesian

origin. Furthermore, our solution beneﬁts from how

large-scale worlds application must implement world

streaming due to memory and processing limitations,

amortizing space partitioning cost. The main con-

tribution of our work is a novel solution that pro-

vides arbitrariness in sparse simulations precision,

enabling ﬂoating-point engines to increase precision

and/or scale.

This paper is organized as follows: Section 2 pro-

vides background and related works on the subject.

Section 3 discusses all the steps of the proposed so-

lution in-depth. Section 4 discusses the effects of

the sector size choice. Results are evaluated and dis-

cussed in Section 5. Finally, Section 6 presents con-

clusion and directions for future work.

2 RELATED WORK

Many works explored the distribution and paral-

lelization of simulations to provide simulation at

an individual level, i.e., without relying on group-

generalized properties. Each agent must have the re-

quired information for its correct simulation —this

requirement is termed awareness. Different tech-

niques focus on partitioning their agents into groups

while keeping a low number of overlapping between

regions of interest of objects in different partitions

—this problem is termed communication level. Be-

sides it, the distribution of simulations introduces

other problems, such as well-balancing the simulation

load across the available processing nodes and how

to operate efﬁciently since the partitioning algorithms

themselves might not scale well.

(Lozano et al., 2007) explores a complete frame-

work for scalable large-scale crowd simulations.

Their solution successfully provides scalability while

providing awareness and time-space consistency.

This is achieved using rectangular grids and dividing

the agents according to their position in the grid.

(Vigueras et al., 2010) improves efﬁciency of pre-

vious methods by employing the use of irregular

shapes regions (convex hulls). Their results show that

irregular shapes outperform techniques with regular

ones, regardless of the crowd simulation.

(Wang et al., 2009) proposes a technique for parti-

tioning crowds into clusters, minimizing communica-

tion overhead. Their work achieves great scalability

through the application of an adapted K-means clus-

tering to efﬁciently partition agent-based crowd sim-

ulations.

Newer techniques explore further performance

improvement, either minimizing communication

costs, equalizing balancing, or both, while efﬁciently

doing so. For example, (Petkova et al., 2016)

uses community structures to group related agents

among processors, reducing communication over-

head. (Wang et al., 2018) explores parallelizing

the simulation per agent using the Power Law in

CUDA architecture to ensure behavior synchroniza-

tion across threads. Their solution explores minute

model details while improving efﬁciency.

(Brown et al., 2019) propose a solution applying a

partitioning solution for physics servers with horizon-

tal scalability. In their work, the scenario is parti-

tioned in regions using Distributed Virtual Environ-

ments modeling, and each partition is assigned to

a server for physics simulation. Objects interacting

across partition boundaries are handled by projecting

objects in overlapping regions to guarantee a seamless

simulation.

These solutions propose and improve the simula-

tion of a massive number of elements through par-

titioning and parallelization techniques while solv-

ing problems such as communications between agents

in different partitions. (Brown et al., 2019) apply

said methods showing that physics simulations per-

GRAPP 2021 - 16th International Conference on Computer Graphics Theory and Applications

136

formance could beneﬁt from partitioning.

However, none of the solutions consider scalabil-

ity in terms of virtual world size. In fact, to the best of

our knowledge, no paper explores the physics simula-

tion of large-scale environments - prone to error be-

cause the inherited physics simulation ﬂoating-point

precision issues increased by the types of arithmetic a

physics engine must calculate.

It must be noted that when we mention large scale

physics simulations, we are not referring to a ‘large

number of objects’ simulation, but rather to the sim-

ulation of an arbitrary number of objects with large

scale positions.

Several commercial examples managed to address

the physics simulation precision limitations. Kerbal

Space Program is a space ﬂight exploration and sim-

ulation game praised for accurate orbital mechanics.

Internally it uses Unity-PhysX (single ﬂoating-point

precision) and an origin shifting approach for near

player simulations combined with numerical models

for distant orbit calculations. This solution is sim-

ple and efﬁcient but is not capable of simulating far

objects using the physics engine. Therefore, the so-

lution works for applications centered in one entity,

and which objects far from this entity does not require

simulation. For sparse simulations, e.g., multiplayer

games and military simulators, the solution is insufﬁ-

cient.

Outerra (Outerra, 2012) is a 3D planetary engine

which uses the JSBSim Flight Dynamics Model li-

brary for high ﬁdelity simulation of aircraft, and Bul-

let physics engine for simulation of vehicle physics.

The Bullet physics engine supports single or double-

precision ﬂoating-point arithmetic (Guo, 2013). With

the double precision option, simulation calculations

are more precise and can be performed in a larger sim-

ulated volume.

Star Citizen is an upcoming multiplayer space

trading and combat simulator with explorable star

systems. It has been developed in an extended ver-

sion of CryEngine 3 (Star Engine) with 64-bit arith-

metic (Burk et al., 2016) to support a vast playable

volume of 200 ×10

(Burk et al., 2016).

These solutions are limited to speciﬁc use cases.

Origin shifting only supports large-scale simulations

if the physics simulation is concentrated around a

unique center point (e.g., camera position). Also,

physics simulations far from this center point must

tolerate low precision simulations or be disabled.

Double precision requires physics engine support

while few engines support it and fewer game engines.

Furthermore, except for Outerra-Bullet, these solu-

tions are proprietary, and the used techniques are not

described in scientiﬁc papers.

We use a partitioning system, along with ob-

jects’ relocation relative to their partition center (ori-

gin shifting), and a cloning system similar to Brown’s

Aura projection to achieve large-scale precise real-

time physics simulations for sparsely distributed ob-

jects.

3 ACCURATE PHYSICS

SIMULATION

This section describes the Large Physics Sectoriza-

tion System (LPSS), our layer-based proposal to per-

form physics simulation on large-scale scenarios with

sparse objects, ensuring numerical accuracy (Figure

1). Our solution can be used with any physics engine

that supports distinct concurrent simulations, such as

PhysX, Bullet and, Open Dynamics Engine.

Application

LPSS

Physics Engine

Invokes simulation

Collision Callbacks

Sector Size

Environment

Boundaries

Invokes individual

simulations per sector

Figure 1: Overview of the architecture. Sector size is de-

ﬁned by the application prior to the simulation start. The

physics engine runs the sector simulations concurrently.

The world is subdivided into regular partitions,

similarly to (Wang et al., 2009). During the execu-

tion, before each physics simulation, the Sectoriza-

tion process (Sec. 3.1) assigns each physics object

to one sector based on its center position. Each ob-

ject is relocated relative to its sector. In the sequence,

the Cloning Manager (Sec. 3.2) ﬁlters potential col-

lisions between objects in distinct sectors and creates

Clones with redundant physics information only for

these objects, similarly to (Brown et al., 2019). Fi-

nally, the Simulation process invokes one physics sim-

ulation instance per sector.

3.1 Sectorization

Any system can be employed to partition objects.

Using an adapted K-Means algorithm, for instance,

would partition objects more efﬁciently than a grid

Accurate Real-time Physics Simulation for Large Worlds

137

partitioning one. Using K-Means, however, would

not allow a satisfactory implementation of partition

size constraint, and the simulation would suffer from

the ﬂoating-point arithmetic issues.

The reason above was key in our decision to use

a grid partitioning system. Although its performance

is far from sophisticated partitioning techniques, it al-

lows us to deﬁne hard-boundaries which ensure ob-

jects’ coordinates are inside a pre-deﬁned volume

and, thus, coordinate errors are inside an acceptable

range. Speciﬁcally, our partitioning system works as

follows.

The world is logically subdivided into three-

dimensional partitions. Each partition might have a

sector assigned to it depending on the existence of ob-

jects inside that partition. A sector is an abstract struc-

ture in which objects can be assigned and revoked.

Since the solution aims for an arbitrary scale, we map

each sector into an auto-resizing hash table. Thus,

sectors are created when an object is placed within its

volume and destroyed when no object is inside. Sec-

tors that contain at least one dynamic object are sim-

ulated per physics step. Each sector has an index to

localize them in space. During sectorization, physics

objects are assigned to one sector based on their posi-

tion as:

(i, j, k) =



(x, y, z)



(1)

where (i, j, k) is the sector hash index, (x, y, z) is the

object position, and L is the sector’s edge size.

After sectorization, object position is the sum of

its sector center and the displacement to it:

(x, y, z) = d

+ (s

, s

) ∗L (2)

where (x, y, z) is the object position, (i, j, k) is the sec-

tor hash index, d

is the object’s displacement to its

sector center and L is the sector’s edge size.

Representing the position in this format guaran-

tees that the object’s coordinate is within the sector

boundaries, and the associated error has a stipulated

limit.

3.2 Cloning Manager

During the Sectorization process, each object gets as-

signed to one sector based on its position. Further-

more, each sector is simulated independently, and ob-

jects from different sectors do not interact in the Sim-

ulation step. Consequently, this can cause inconsis-

tency in the simulation when objects intersect adja-

cent sectors. As an example, in Figure 2, object

B only collides with C when its position is within

the sector S

boundaries. To handle these cases, the

Cloning Manager identiﬁes probable interactions that

would cause inconsistency and creates Clones to en-

sure a correct simulation.

Figure 2: Simulation situations and how cloning manager

handles them. Dynamic objects are represented by vehicles,

static objects by walls, and Clones are transparent.

A Clone is a copy of the physical components of a

physics object created to other objects react correctly

when assigned to different sectors. The procedure to

create a clone is:

1. Create a deep copy of the original object. Game

engines already provide methods for this (e.g.,

Unity’s Instantiate and Unreal Engine’s Duplica-

teObject).

2. Remove all non-physics components related to

physics.

Static clones send physics callbacks to their origi-

nal objects. Dynamic objects physics properties, such

as velocity and position, are copied from the original

object to their Clones before each physics simulation

step (Figure 3).

The Cloning Manager considers pairs of objects

from different sectors that might collide, using Axis-

Aligned Bounding Box (AABB) intersection algo-

rithms. For those pairs, three cases are possible:

• Static: static object intersecting with two or more

sectors;

• Dynamic-Static: a probable collision between

static and dynamic objects in different sectors;

• Dynamic-Dynamic: a probable collision between

dynamic objects in different sectors.

Figure 2 illustrates the cases handled by the

Cloning Manager. Static overlapping cases (e.g., wall

F) are solved when the object is created. For each sec-

tor intersected by the object, a clone is created and as-

signed to it. It remains active during the object’s life-

time. For Dynamic-Static cases (e.g., B-C), a clone

GRAPP 2021 - 16th International Conference on Computer Graphics Theory and Applications

138

Physics Properties

Sync

Rigid Body

Renderer

. . .

Movement Behavior

Collider A Collider B

Rigid Body

Collider A Collider B

Dynamic Clone

Dynamic Object

Physical Components Other Components

Before Physics

Simulation

During Physics

Simulation

Rigid Body

Renderer

. . .

Collider A Collider B

Rigid Body

Collider A Collider B

Static Clone Static Object

Physics Callbacks

Sync

Position,

Rotation,

Velocity

OnCollide,

OnTrigger

Figure 3: Original objects have miscellaneous components, e.g., renderer and movement behavior, while clones have only

physics related ones. Both share a component to sync state (physics properties and collision events).

of the static object is created and assigned to the dy-

namic object’s sector. For Dynamic-Dynamic cases

(e.g., D-E and G-H), both objects should be cloned.

In the D-E case, both objects overlap the adjacent sec-

tors; and, in the G-H case, vehicle G does not overlap

sector S

, but is in imminent collision with vehicle

H. Vehicle A is far from the sectors’ border and the

Cloning Manager ignores it.

For every physics step, the Cloning Manager con-

siders all pairs of objects and generates a collection

with required clones. For performance and memory

segmentation reasons, each object manages a pool of

clones to avoid continuous object creation.

4 SECTOR SIZE

The sector size is an arbitrary value, but if it is too big,

the simulation might be imprecise. In this section, we

deﬁne the sector size’s limit to ensure precision. Our

solution has the following design choices:

• The solution does not offer support for objects

with AABB larger than the sector size;

• Clones share their original object position while

being placed in another sector. Consequently their

position is outside their assigned sector.

Consider Figure 4. The pink sector might contain

clones from adjacent sectors. To guarantee clones are

simulated inside the precision range, sector size must

be such that all neighbor sectors stay inside it. The

sector edge L must be L ≤

√

, where r is the preci-

sion limit.

Original

Clone

Figure 4: Sector and its neighbors inscribed in precision

range (sphere with radius r. For better viewing drawn as a

circle).

5 RESULTS

Physics are sensitive to initial conditions, i.e., small

changes in one state can result in more signiﬁcant dif-

ferences in later ones. As discussed before, ﬂoating-

point physics simulations are also susceptible to ac-

cumulating rounding error, varying the error in many

degrees of magnitude with slightly different distances

from the Cartesian origin, which increases the sam-

pling error. Thus, computing a physics simulation er-

ror is not trivial, and results might differ signiﬁcantly

under slightly different conditions.

We compare the PhysX physics engine and our

solution running on top of PhysX, both in the Unity

game engine. Our tests run in a Quad-Core i3-9100F,

GTX 1050 Ti, and 8GB of DDR4 RAM clocked at

2400 MHz.

Our precision test consists of two spheres, im-

Accurate Real-time Physics Simulation for Large Worlds

139

pulsed towards each other to collide. The spheres’

radii are 0.5 units, and in the best conditions, a col-

lision is expected when spheres are one unit apart.

Running the test at origin (ground truth) results in a

collision detection when spheres are 0.479 units apart

due to simulation discrete time steps. All tests execute

using the same time step value, thus canceling any

disturbance on the results. We calculate the error for

each object as the Euclidean distance between its ﬁnal

position after the simulation and its ﬁnal position after

the ground-truth simulation. The simulation error is

the aggregation of all objects errors using a Least Ab-

solute Deviations loss function. Figure 5 compares

collision detection error over origin distance. Since

our implementation uses a sector grid centralized at

the origin, it offers the same precision until half sector

size (with minor differences). After half sector size,

PhysX error increases until 8 ×10

distance from the

Cartesian origin. After this distance, spheres would

not collide due to imprecision even when using so-

phisticated and expensive collision detection methods

available in Unity-PhysX, e.g., Speculative Continu-

ous Collision Detection (Unity, 2020). In contrast,

our solution maintains the error in an acceptable range

since objects are kept near the origin. When objects

are assigned to the next sector, their position becomes

local to the new sector, approximating and distancing

from the Cartesian origin, conﬁguring an error peri-

odic wave pattern.

Origin distance

Error

0.000001

0.00001

0.0001

0.001

0.01

0.1

10 1000 100000 10000000

LPSS 128 LPSS 1024 PhysX

Figure 5: Collision detection error over simulation distance

to the Cartesian origin using PhysX and our solution (LPSS)

with 128 and 1024 sector size.

The sparse positioning of objects generates more

sectors and, consequently, more instances of physics

simulation are demanded. As the number of instances

increases, more physics invocations are needed, di-

rectly impacting the application’s performance. Fig-

ure 6 demonstrates the time consumption relative to

the number of physical instances. The test starts

with 128 objects assigned to one sector, and these

objects are progressively distributed in more physics

instances until reaching one object per sector (end-

ing with 128 sectors). As an example of the impact

caused by the number of physics instances, simulat-

ing 128 instances with one object is ≈ 80 times more

expensive than one instance with 128 objects. Since

simulations are independent, the problem can be miti-

gated by splitting simulations across processing cores.

Simulation Instances

0 ms

5 ms

10 ms

15 ms

20 ms

0 25 50 75 100 125

Figure 6: Processing times to simulate 128 physics objects

over physics simulations instances.

The third experiments focus on the sectorization

and cloning management overhead for each physics

simulation step. As seen in Figure 7, objects sec-

torization cost is proportional to the number of ob-

jects and is negligible compared to simulation cost.

Cloning management, however, has a considerable

cost over object count, which can be minimized us-

ing faster broad-phase collision detection algorithms.

Clones must be simulated as physics objects, which

translates in increasing simulation time.

Objects

0.0ms

0.5ms

1.0ms

1.5ms

2.0ms

25 50 75 100 125

Clones Checking Simulation Sectoring

Figure 7: LPSS overhead per physics simulation.

Furthermore, we visually explored the difference

between using our proposal and not. Figure 8 demon-

strates how our solution scales well with large envi-

ronments. Right stacks use LPSS while left stacks do

not.

Top stacks are simulated at origin and bottom are

displaced 2

units from origin. This tests shows that

simulation works as expected at the origin regardless

if the simulation uses or not or solution, but at high

coordinates using PhysX is so inaccurate that the sim-

ulation fall apart while our solution remain stable and

GRAPP 2021 - 16th International Conference on Computer Graphics Theory and Applications

140

Figure 8: Visual comparison between physics simulations

of stacks.

correct. In this test, LPSS sectors are 1000 units in

length. A minor difference can be perceive between

using or not our solution without displacement from

the world origin. This discrepancy is due to a physics

frame gap in our system initialization. While the

PhysX test is completely disrupted when simulating

with big coordinates, LPSS error is kept acceptable.

6 CONCLUSION

In this paper, we present a low computational cost

system to increase simulation precision in physics en-

gines, supporting larger or inﬁnity scenarios regard-

less of the utilized physics engine and its numeric rep-

resentation. This is achieved by dividing the world

into logical sectors and simulating objects with sector

local coordinate systems. Coordinates are restricted

to half sector size. Ergo, ﬂoating-point values have a

well-deﬁned max error. Objects redundant copies are

created to handle correctly interactions across sector’s

edges.

Smaller sectors guarantee more precision but

cover a small volume, which may require more sec-

tors and physics simulation, compromising the appli-

cation performance. Hence, a trade-off can be deﬁned

between precision and performance without depend-

ing on physics engines’ implementations.

Our research focuses on achieving arbitrary pre-

cision with simulation consistency and low process-

ing cost per simulation step. As future work, we will

explore acceleration structures to minimize overhead,

especially in cloning management. Furthermore, we

will look to merge our solution with (Brown et al.,

2019), to provide an efﬁcient cloning system and

we will explore more complex partitioning systems

to minimize communication overhead while maxi-

mizing load balancing, supporting large-scale virtual

worlds with horizontally scalable parallelism.

ACKNOWLEDGEMENTS

We thank the Brazilian Army and its Prg EE AS-

TROS 2020 for the ﬁnancial support through the SIS-

ASTROS project.

REFERENCES

AdoredTV (2015). Citizen spotlight - Star Cit-

izen - Roberts Space Industries. https:

//robertsspaceindustries.com/community/

citizen-spotlight/1599-Star-Citizen-How-Big.

Baraff, D. (1989). Analytical methods for dynamic simula-

tion of non-penetrating rigid bodies. In Proceedings

of the 16th Annual Conference on Computer Graph-

ics and Interactive Techniques, SIGGRAPH 1989, vol-

ume 23, pages 223–232.

Boeing, A. and Br

aunl, T. (2007). Evaluation of real-time

physics simulation systems. Elsevier.

Brown, A., Ushaw, G., and Morgan, G. (2019). Aura pro-

jection for scalable real-time physics. In Proceedings

- I3D 2019: ACM SIGGRAPH Symposium on Interac-

tive 3D Graphics and Games.

Burk, S., Coleman, A., and Tracy, S. (2016). Sean Tracy

on 64-bit Engine Tech & Procedural Edge Blending.

https://www.youtube.com/watch?v=OB

AI9ukSp8.

Ericson, C. (2005). Real-Time Collision Detection, vol-

ume 1. Morgan Kaufmann.

Goldberg, D. (1991). What every computer scientist should

know about ﬂoating-point arithmetic. ACM Comput-

ing Surveys (CSUR), 23(1):5–48.

Guo, S. (2013). Double & Single Precision in Bullet. http:

//guoshihui.net/double-single-precision-in-bullet.

Kavan, L. (2003). Rigid body collision response.

https://www.cs.utah.edu/

∼

ladislav/kavan03rigid/

kavan03rigid.html.

Liu, H., Bowman, M., Adams, R., Hurliman, J., and Lake,

D. (2010). Scaling virtual worlds: Simulation require-

ments and challenges. In Proceedings - Winter Simu-

lation Conference, pages 778–790.

Lozano, M., Morillo, P., Lewis, D., Reiners, D., and Cruz-

Neira, C. (2007). A distributed framework for scal-

able large-scale crowd simulation. Lecture Notes in

Computer Science (including subseries Lecture Notes

in Artiﬁcial Intelligence and Lecture Notes in Bioin-

formatics), 4563 LNCS(May 2014):111–121.

Lui, J. C. and Chan, M. F. (2002). An efﬁcient partitioning

algorithm for distributed virtual environment systems.

IEEE Transactions on Parallel and Distributed Sys-

tems, 13(3):193–211.

Accurate Real-time Physics Simulation for Large Worlds

141

Outerra (2012). Outerra: Outerra Tech Demo re-

leased! https://outerra.blogspot.com/2012/02/

outerra-tech-demo-released.html.

Petkova, A., Hughes, C., Deo, N., and Dimitrov, M.

(2016). Accelerating the distributed simulations of

agent-based models using community detection. In

2016 IEEE RIVF International Conference on Com-

puting Communication Technologies, Research, Inno-

vation, and Vision for the Future (RIVF), pages 25–30.

Seugling, A. and Rolin, M. (2006). Evaluation of physics

engines and implementation of a physics module in a

3d-authoring tool. Umea University, page 89.

Tracy, D. J., Buss, S. R., and Woods, B. M. (2009). Efﬁcient

Large-Scale Sweep and Prune Methods with AABB

Insertion and Removal. Technical report, University

of California San Diego.

Unity (2020). Manual: Continuous collision de-

tection (CCD). https://docs.unity3d.com/Manual/

ContinuousCollisionDetection.html.

Unity Community (2017). Making an open

world map. Could use some input. - Unity

Forum. https://forum.unity.com/threads/

making-an-open-world-map-could-use-some-input.

484643.

Unity Community (2018). Floating Point Errors and Large

Scale Worlds - Unity Forum. https://forum.unity.com/

threads/ﬂoating-point-errors-and-large-scale-worlds.

526807/.

Vigueras, G., Lozano, M., Ordu

na, J. M., and Grimaldo, F.

(2010). A comparative study of partitioning methods

for crowd simulations. Applied Soft Computing Jour-

nal, 10(1):225–235.

Wang, J., Mao, T., Song, X., Liu, S., Jiang, H., and Wang, Z.

(2018). Parallel crowd simulation based on power law.

In 2018 International Conference on Virtual Reality

and Visualization (ICVRV), pages 78–81.

Wang, Y., Lees, M., Cai, W., Zhou, S., and Low, M. Y. H.

(2009). Cluster based partitioning for agent-based

crowd simulations. In Winter Simulation Conference,

WSC ’09, page 1047–1058. Winter Simulation Con-

ference.

GRAPP 2021 - 16th International Conference on Computer Graphics Theory and Applications

142