Game Development Reference
In-Depth Information
optimization, attempting to correct some of the areas mentioned at the end of a
game production can very well capsize the project. A game designed from the
outset with streaming as a focus can drive load times close to the zero horizon and
provide for an overall better player experience.
Solving the streaming equation involves collaboration from both technology and
design. On the technology side, you will need to have a flexible system to bundle as-
sets into separate packages. Final assets that appear in a game will most likely have
to be reconstructed from disparate bundles, some of which make use of temporary
assets as placeholders. To maintain good performance, threads or coroutines should
be used for requesting asset bundles asynchronously. Finally, bandwidth simulation
should be enforced throughout development so that the development team is always
aware of load times. On the game design side, designers must be actively involved
in designing the flow of the game with asset sizes in mind. Rigorous monitoring
of load times at different stages of the game and setting up encounters or events
to hide downloads are critical. Finally, determining which assets are required and
which can appear when available is necessary for prioritization. Having the right
tools in place can make this process much easier for everyone.
2.1.1 Game Asset Streaming Explored
To fully understand how to set up your asset pipeline to prepare for streaming,
first we'll explore streaming itself and define a simplistic calculus in the process.
Let's assume for now that there is a static set of assets,
S
, for the game and that
the game is deterministic in how those assets are loaded over time. At any specific
time,
t
, new assets may be requested. For this exploration, time will be handled
discretely. Let's declare a function
S(t)
that produces a set
S
t
that contains all the
assets that are currently loaded at time
t
. So, initially,
S(0)
produces the empty
set
S
0
=
∅.
If time
t
f
is the time when all game assets are loaded, then
S
(
t
f
)=
S
t
f
=
S
=
{a
0
...a
n
}.
When an asset,
a
, is requested, a check is made to see if it is already loaded in
memory. Let's define a set
R
t
that includes the assets being requested at time
t
.If
the assets are not in memory, then they need to be loaded from a disk store. Now,
let's define a function
L(t)
, which produces a set of what assets need to be loaded
at time
t
:
R
t
=
{a
i
, ...}
where
a
i
∈ S,
R
t
\ S
t
.
In the case where
R
t
is a subset of
S
,then
L(t)
=
L
(
t
)=
because the assets have
already been loaded. Let's declare a function
T(L)
that gives us the time it takes
∅
