Christian Buttner | Things I've made

Tracking obstacles for a humanoid robot

For a university project in 2016 I worked on computer vision for a humanoid robot named LOLA, which had already been in development for several years at the Chair of Applied Mechanics at TU Munich. For environmental perception and navigation around and over obstacles, an Asus Xtion PRO LIVE Kinect-like RGB-D camera had been installed on LOLA’s “head”. This type of camera outputs a 3D image of surfaces in the field of view, also referred to as a point cloud. My task was to detect and track obstacles in real time from the point cloud and fit primitive SSV1 collision volumes around them, as well as to estimate a velocity vector from moving obstacles.

A lightweight 3D visualization library for robot-vision research

Alongside my work on “Tracking obstacles for a humanoid robot”, I wrote a visualization tool from scratch in collaboration with fellow student Tamas Bates. The project was made open source by the chair and is available here: https://github.com/am-lola/ARVisualizer.

Triangle Mesh Simplification

The objective of the mesh simplification problem is to reduce the number of vertices in a triangle mesh while retaining the original shape and appearance of the mesh as closely as possible. Generally you can think about the problem in terms of removing unnecessary or redundant triangles until the desired vertex count is attained. The purpose of this kind of algorithm is to increase rendering performance, either by generating LODs for relatime applications such as video games, or by reducing the size of meshes generated by 3D scanning or high-res sculpting applications, where meshes containing millions of triangles are not uncommon. In 2014 I evaluated and implemented serveral such algorithms for my bachelors thesis.

Optimal Reciprocal Collision Avoidance

In 2013 I implemented Optimal Reciprocal Collision Avoidance and created a visualization/debugging tool. The actual paper “Reciprocal n-body collision avoidance” suggests using a linear programming algorithm, but I figured that it was easier to compute optimal velocity vectors using simple and fast 2D geometric calculations without formalizing it into a convex optimization problem. I integrated my implementation into the Source Engine NPC locomotion system for NPC-NPC, NPC-player and NPC-obstacle avoidance together with Recast/Detour nagivation meshes.

Navmeshes in the Source Engine

In 2013 I implemented Recast/Detour into the source engine for Zeitgeist (a game that has never seen the light of day), replacing the Nodegraph for NPC navigation. Recast/Detour comes with a demo program that already works fine as a standalone toolset. I just needed to extend the demo with my own code to import BSP maps (including displacements) and collision meshes of all static objects (prop_static). The navigation mesh could then be generated from the imported geometry and exported into a file.

Working with Unreal Engine 4

Between 2014 and 2015 I was the only programmer in a small group of friends who worked on games in their spare time. Previously, we worked on Zeitgeist (I also made a post about it here), but after that didn’t work out, our plan was to make a medieval-swordfighting multiplayer game in Unreal Engine 4. Unfortunately, this game also went nowhere, but what can you expect when you have zero funding and no way to make game development your full-time job. Anyways, during the development of this game I became quite familiar with UE4, so I’m just going to present some more or less interesting things here.

Some older Source Engine gamedev things

Around 2011-2013 I worked on Zeitgeist, a HL2 full conversion mod (basically a game that was never finished). During this time I was fairly new to game development/game programming, so I worked with the Source Engine a bunch and became familiar with the Half-Life 2 codebase and all the tools and processes for content creation. Anyways, I found some old stuff on my hard drive, so here it is. You can also check out my post on navmeshes in the Source Engine.

Some graphics and game programming from scratch

My first contact with proper graphics and game programming from scratch was in 2012. Using C++ and DX11, I implemented random terrain generation, layered terrain texturing, a skybox, basic shaders with directional lighting, loading textured meshes and particles. Eventually it became a very basic mech-shooter where you shoot enemy ships flying in random directions over the map. If you think “sounds like a university class”, you would be correct; it’s basic stuff. For some extra challenge, I also added things like “godrays”, instanced mesh rendering, and a data oriented (I already knew about DoD back then), fully SIMD-ified particle system that had some basic emitters and movement types and such.

A C++11 header-only library for calling Julia functions

For some projects (such as this one) I used to protoype maths-heavy stuff in the Julia Programming language, but have my main program with visualization and more written in C++. The neat thing with embedding Julia in your C++ program is that you have a powerful script-like math-heavy language that you can hot-reload instantly. This allowed me to do rapid protoyping and experimentation without the agony of recompiling and restarting the C++ program.

A mechanical keyboard

I built my own keyboard, which some people like to do because it’s fun or educational. My design decisions included getting rid of things I didn’t like or didn’t need and compacting everything to neatly packed 36x11 cm monolithic slab with a custom keymap.