This
talk will
feature a
collection of
senior
research
projects,
presented by
DigiPen
students:
Templatized
Lua Binding by
Lux Cardell:
In order to
integrate Lua
scripting into
a C++ project,
each function
accessible to
Lua must have
a binding
function. For
a custom game
engine
project, I
bound Lua to
allow our
design team to
iterate and
design more
efficiently.
To this end I
wrote a set of
templates that
generated
binding
functions
automatically
based on the
data types the
functions
required.
These
templates were
designed to
encapsulate
the entirety
of
the binding
process, from
popping
arguments off
the Lua stack
to
returning an
arbitrary
number of
values. I used
variadic
templates to
allow the
template to
handle any
function
signature. In
order to
interface
between
dynamic and
strict typing,
I wrote a
generic class
that wrapped
the basic
types from Lua
and the
user-defined
types commonly
used
throughout the
engine.
TypeRT by
Michael-Paul
Moore:
In order to
develop a
complex C++
simulation,
many
collections of
data
must be
authored to
control
behavior
during
execution.
Much of this
is
driven by the
creation of
different
classes that
will each
require
similar sets
of utilities
in order to
effectively
function.
Utilities
such as:
Points of
Access,
serialization,
classification, etc. While
engineers can
facilitate
this
functionality
on a per class
basis, this
is time
consuming and
can often
result in
duplicated
logic.
Furthermore,
while native
representation
is required
during
execution, by
allowing
the class
definitions to
reside outside
of code we can
gain the
following
benefits:
•
Accessibility
to
non-engineers
without
compiler
access
• Easily
extend feature
set on data
usage inside
and outside
the main
toolset
• Since
these class
definitions
are outside
the toolset,
they do not
require code
to be built
• Further
ensures
abstraction
from your data
from different
functionalities
To solve these
problems we
want to
utilize a
single
flexible
wrapper
class,
referred to as
TypeRT, to
centralize
interactions
for game data.
This creates
an environment
in which a
given
functionality
only needs to
be implemented
once and then
gained across
multiple data
types. In the
actual talk
details will
then be given
on the TypeRT
implementation.
Process by
which existing
classes can be
ported will be
explained.
Experiences
of a Technical
Director and
Gameplay
programmer by
Samuel
Schimmel:
Discussing of
my experiences
both as the
technical
director and
gameplay
programmer of
a UE4 C++
project, and
as the UE4 C++
gameplay
programming
TA. The slides
for my
workshop,
footage of the
game, and
commentary on
various
gameplay
features I've
implemented
using UE4 C++,
can be found
here:
https://www.samuelschimmel.com/unreal/.