Tools library
While not much to look at, this library is some of my most current code and one of the few bits of coding I'm not totally ashamed of yet (personally I like to consider it a sign of growing experience to not be happy with your old code, simply because you learned many ways of doing it better or even not doing it yourself at all). Mostly small tools for everyday needs (factories, event handling, console menues, etc.). This will be of limited use if Boost is available to you, since most of it can be found there in a much more flexible and form and supporting most platforms. Some bits will look familiar if you read "Modern C++ Design".
--- | Source
JA2 Rewrite
The source code to one of the greatest games has been released and I've been late
for the party. I couldn't resist replacing the 2D blitting with OpenGL rendering, but soon
figured that a complete rewrite would be nice for practice. After all, much of the source
is a result of the time it was written. Currently
maps and sprites can be loaded. Animations work, but the full animation system begs to be
replaced. As a bonus, the ground layer and "structure matrices" can be rendered in 3D,
allowing to look at familiar levels from a completely new angle. No binary, since the required
data can't be redistributed.
--- | Diary
Avatar
Contract work. The avatar is used to visualize facial expressions for other apps.
The actual project is a server application, while this reduced version is mostly about
adding natural looking eye and head movement and
transitions between expression based on selectable interpolation functions. The model is taken
from the FaceGen Website. Morph targets
are converted to a file collecting vertex differences, allowing multiple morphs to be blended
together with separate weights. The eye textures were replaced with adjusted versions of
a texture taken from here. This was
necessary to get around technical limitations of the way FaceGen handles eye movement.
No source, but a version with added shadow mapping (showing the opening beneath the eyes).
Binary (normal) | Binary (shadow)
DSA Route
Somewhat inspired by Google Maps this is essentially a route finder. To make it
semi-useful it comes with an editing mode to use
your own maps and specify the necessary data. Controls for editing
are geared towards working fast and comfortable while creating datasets. While nominally it is
intended for use with the German roleplaying game DSA, it can easily be adjusted for generic use.
Route finding allows finding the shortest or fastest way, based on speed modifiers for
different connections between places. Various means of travelling can be included or excluded
for a search. Created in about 8 days, so there are only interim datasets.
Binary | Map pack
Jumpstart Framework
Starting as a framework for OpenGL/OpenAL applications, this was mostly taken
over by the terrain renderer. GeoMipMapping optimized for memory usage to allow large height
maps of up to 4096x4096 at 67MB for geometry + 32MB for redundantly stored height map.
Graphical profilers can easily be added anywhere in the code as begin/end markers.
Download uses a 1024x1024 map taken from the Farcry demo and shows a particle system with
1000 particles, switchable between using point sprites and a custom shader.
An older version was using the world of Oblivion as a 4096x4096 map. x,z coordinates are
stored for only one patch (one patch is up to 128x128 vertices). Each patch uses x,y,z offsets,
the final position and texture coordinates are created in a shader.
Water needs to be changed to use actual displacement.
Binary | ---
RPG Ambient
A tool to create sound events, from simple background music to complex arrangements
to be used during role playing sessions. Using the basic idea of SMIL to combine parallel and
sequential tracks, expanded by random selection, to allow for all possible kinds of
combinations and loops. Using FMOD, many effects and filters can be applied on any level
(including custom filters), so an echo effect can be applied to the entire "scene" instead of
every sound effect. Drag and drop allows to comfortably add a large number of effects, for
example different birds to a looping random selection. Fades and cross fades are possible, as
well as manually advancing sequences. The player is a simple console app for notebook
friendliness.
Binary | ---
SW D6 tool
Intended as a tool to create and manage characters as well as handling combat on
floor plans for the P&P RPG, this is more of an experiment in UI. Drag and drop is key,
allowing to add skills, items or penalties to characters, characters to factions or other
lists. For example dragging a PC on the NPC list creates a duplicate of the PC for use as NPC.
Right click opens and closes edit dialogues for whatever is editable. Using specialization of
derived template classes is making it relatively easy to add new types of objects with little
work. The "game board" is moved with the right mouse button, zoomed with the wheel and rotated
with the middle mouse button, using the pointer position as pivot point. Supposed to support
different map formats (square, hex) with varying cell heights and at some point entire meshes
as 3D-playing fields. Characters can be dropped on the map, combat rules are only partially
implemented, path finding using vanilla A*.
Binary | ---
OpenGL MiniGUI
The first attempt at an OpenGL UI library. Mistakes include trying to avoid
more complex signal/slot mechanics or message handling in favour of a Callback class
as member function wrapper. Later GUIs included support for external XML-files describing
forms and linking events to exported functions, as well as overrideable stylesheets. Being
tailored towards games there is nothing like sizers or other elements for dynamically
adjusting the layout. Also, this version still required textures for all elements, later
versions would allow regular fonts for button labels.
Binary | ---
Graphplan
A one week assignment was to implement graphplan. Obviously I couldn't just do that,
but had to come up with my own format for domain descriptions, add every optimization I
could think of and try to outperform every other implementation I could get my hands own. When the
assignment was extended to two weeks I wanted to actually visualize the resulting graph and added
one of my quick and dirty OpenGL UIs. The result displays the domain information, operator instances
(with various options to minimize the number of pointless operations), the graph and the interference
table. The result is counterintuitively displayed under Log. A* is implemented to double check the
resulting plans, but very slow.
Binary | ---
Terrain editor
Using a special way to mix base and detail textures, the base texture could "drown
out" the details for larger R,G,B values (indicated by lines in the color selector). That way
it was possible to paint on the terrain without any extra effort, like the cave entrance
in the screenshot. Became obsolete when the terrain texturing was changed to use four detail
textures and fragment programs instead of nVidias register combiners.
No binary | No source
Terrain
The updated version of the old terrain renderer. Using GeoMipMapping, crude occlusion
culling, blended detail textures, moving sun, normal map and potentially infinite terrain.
Loading a whole sector requires to drastically limit the view distance to hide the process.
Disabling fog and increasing the view distance makes this visible. Not a good approach for
large worlds. One day I will find time to implement GeoClipMaps or come up with something
completely new.
Binary | ---
EmoSettlers
A side product of my diploma thesis, this is a severely stripped down version of
Settlers of Catan. Enough to be no longer recognizable. A client/server game using emotional
bots as a test scenario for the emotion module that was created for the thesis. The goal is
building a palace to win the game. Each player is dealt random ressources each turn to construct
different buildings, which in turn offer new options (stealing, trading, etc.) or otherwise
affect the game (more actions or ressources per turn). A much more indepth description of the
game can be found in the thesis.
Binary | ---
Camera class
Extended, revamped and stripped down many times. The standalone version does not
rely on specific vector or matrix classes, making the code more messy looking. Handles the
projection matrix as well to use a left handed coordinated system in OpenGL, includes
a project/unproject function for convenience and what ended up being called "radar based
frustum culling". Common culling for spheres is included as well as the option to draw the
current frustum for debugging purposes. On this screen a cube mapped quad is used instead of
a skybox.
No binary | ---
Particle System Editor
A very simple editor for a very simple particle system. While this is rather old
and can't be compared to the system implemented for the JSFramework, it is one of the few
remaining programs using D3D instead of OpenGL. Everything can be adjusted, usually by
specifying a value and a range for random variance.
Binary | ---
Proof of concept for RPG skill system
A test of a skill advance system for RPGs. Unlike in most games
this is supposed to not just award successful skill use with a fixed increase or XP, but
instead consider the challenge of a task and the fact that failure can teach as much or
more than success. The increase of a skill depends on the difficulty, but skills only improve
on succeeded tests following failed tests. That means failure sets you
up for potential improvement, but success is needed to confirm that "the lesson was learned".
Different speeds for different skills compensate for some skills being used more often than
others. Multiple skills can be combined for an action and receive different weights,
depending on how relevant they are to the task. In this test, the number of shots required to
reach a certain skill level can be tested. Using "appropriate" difficulties are causing
the most increases (50/50 success rating). Harder challenges yield less yet larger increases.
Overengineering.
Binary | ---
Parallex bump mapping tweak
The day somebody posted his newly developed form of bump mapping I added minor
changes to the shader. Using only negative heights and killing fragments if the adjusted
texture coordinates were outside [0;1] results in "correct" silhouettes. Unfortunately this is
of limited use in most real applications, especially when using tiled textures. Image is
showing the edges of two walls, both consisting of a simple quad.
No binary | No source