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/.