Tessellation gives way to some crazy new graphic implementations. I was pointed to Hughes Hoppe's Geometric Images while playing around with the new DirectX11. I decided to attempt tessellating a basic mesh, like a quad, and displace it according to a Geometric Image. As you can see, using Geometric Images and tessellations, we can create arbitrary mesh data from very basic structures. Imagine a world of quads that transforms into any static mesh needed!

[video]

Using the new hardware tessellation feature in the new DirectX11 graphics pipeline, I've tessellated a low-poly mesh and displaced it using a high-quality displacement map. In this scene, you see a 200 poly monster mesh next to it's 2,000,000 poly counter-part. When I tessellate the low-poly mesh and interpolate its displacement, the low-poly mesh closely resembles the high-poly version. This illustrates the implications of tessellation.

[video]

I created a networked shooter game using the User Datagram Protocol (UDP). My game was created to use the m-net library, which is basically a wrapper for Boost ASIO. I created separate executables for my server and client, but both run on the same 2D engine library I developed. Each person joins the game with a separate name, which is displayed on screen.

[info]

Cloth Simulation using classical verlet integration. Each point in the cloth is actually a particle that is simulated using the verlet scheme, and held together using constraints. On every frame, after integration has been performed on the particle's position, all the constraints are resolved. This means that the two points per constraint move towards each other. This ensures that the cloth stays intact, assuming enough constraints have been built.

[video]

I wanted to get a better understanding of how a programming language works at a lower level. When in C++, there are things you assume just work, but you don't know why. So, I designed my own scripting language. I then had to build a Lexical Analyzer, Virtual Machine, and Compiler. I call it the "Gibberish Language"

I have been playing with tessellation more and more, and I'm having a blast. With this project, I decided to take the displacement part to a 3rd dimension! Instead of displacing it along the normal, I actually displace each tessellated vertex according to a vector displacement map. You can see that the new vertices are curving away from the first mesh. This allows for some useful dynamic geometry, depending on the amount of tessellation and displacement needed.

[video]

For my masters thesis, I am measuring the performance and memory advantages of hardware tessellation in DirectX11 using different scenes. In this scene, I will be simulating ocean waves using the Fast-Fourier Transform. In order to maintain speed, I will be generating my wave heightmaps entirely on the GPU. After that, I will be tessellating a quad that will displace the new vertices according to the real-time heightmap.

[heightmap]

It takes an absurd amount of time to load a large, detailed terrain, so I made it concurrent. I used my lockless queue to store each terrain chunk at separate detail levels, so that they could be loaded by multiple threads. At the moment, the terrain loader creates seven separate threads, and immediately renders the terrain when any of the threads has finished. As the terrain is rendering, higher level of details finish loading and are subsequently swapped into the terrain mesh.

[video]

I implemented a 3DSMax skinned mesh exporter plugin as well as a importer for my own engine. At the moment, I can successfully load my plugin in 3DSMax, export a skinned mesh, import it into my own 3D engine, and render it on screen. Each vertex in a skinned mesh holds bone weight information, so that it's position is determined on one or more bone positions. Therefore, if one bone moves, all vertices weighted with that bone will move along with it.

[info]

I implemented a distance-based terrain renderer. While updating, the terrain entity determines the level of detail for a single chunk based on the distance from the camera. If any of it's neighbors are not of the same detail, it will also perform a stitching algorithm that blends the polygons bordering the chunks together in order to avoid cracks. I also perform quad-tree and frustum culling.

[video]

One of my first projects in my 3D engine was implementing a Quake3 BSP map. Binary Space Partitioning breaks up a node of space into two separate nodes so that the BSP tree can be traversed from any viewpoint. Using Potential Visibility Sets (PVS), we can cull out areas of the map that cannot be seen from that viewpoint. I also employ frustum culling in order to not render any excess geometry.

Parallax mapping was one of the first hardcore HLSL and ASM DirectX/OpenGL rendering projects I attempted. In this scene, a cube is rendered with parallax mapping, specular highlights, and tangent-space normal-map lighting. The parallax mapping gives the illusion that the cobblestones on the surface of the cube are displaced geometry, much like normal mapping is meant to do. However, the surface is completely flat.

[video]

I created a lockless queue as my first dive into concurrent programming. A lockless queue container is an essential tool for multi-threaded systems. It guarantees thread-safe pushing and popping of elements in an atomic, volatile manner.

[info | download]

I decided to get down and dirty with the lower levels of C++ memory management. Therefore, I wrote my own memory allocator that overwrites new/malloc and delete/free using macro redefines. I then profiled my new memory allocator system against different allocation scenarios. I saw up to 10x speed increases! It was very interesting to learn and create and remove memory chunks on the fly when needed. All in all, it was a great learning experience.

[info]