Michael Kargas portfolio

Professional Work
Demoscene Productions
Personal Experiments
Retro Coding

A simple raytracing engine
This engine was developed for the graphics coursework for my MSc in CGVI at UCL. I would like to stretch that while in the original coursework we were just asked to add support for reflection and shadows in an already existing source code, I've decided to take the different root of writting my own engine from scratch in C++ for learning purposes. Programming a proper raytracer with all standard stuff was something I hadn't done before and I prefered to fullfill this dream with my own project instead of adding few lines of code in an existing framework. It was also a good opportunity to improve my C++ OOP knowledge (using inheritance or operators). Source is included in the download link.

Links: download
OpenGL robots
This is my code for the graphics coursework to learn object hierarchical animation in OpenGL. It uses GLU and GLUT for opening a window and other common functions. I have used a lot of GLUT objects, even the classic teapot as the head of the robots :). Instructions of how to control the camera, add more robots or see wireframe and other stuff are included in the dos text window behind the rendering window when one starts the programm.

Links: download, youtube
3D Particles
Another coursework for the graphics courses for my master at UCL. This time it was about particle effects. While I had already some experience with particles in my demoscene hobby and past projects, in this coursework I have added some interactivity like the chance to change two vectors with left/right mouse clicks, one for the gravity and another for the flow of the particles. A third option was to use the mouse wheel click for changing the spread angle of the particles.

Links: download
GPU voxel rendering
This archive with different pieces of scattered source code are various parts of code that assisted me in my final thesis on volume rendering. There are different examples of rendering a volume cube using either pure OpenGL1.1 (with slices), GLSL volume raymarcher, OpenCL or even slow CPU code. In the archive one can also find the PDF of my dissertation among other things. The rendering engine was also ported later as a collaboration project in a Java port with a more convenient GUI and added options.

Links: download, Java port, youtube
Software rendering 3d engine for gamepark handhelds
This engine was originally developed in need for my gamepark demos and similar handheld devices at the time that don't have a 3D GPU. At one point I've decided to release the source code to the public as GPL (initially for the GP2X handheld and later a PC compiled version too). This version let's you cycle through various high poly count objects and change between different shading types. I have tried in one case to load a 70000 polygon object on GP2X and much higher polygon models on the PC executable. Additional code was written to generate surface and vertex normals once from 3d vertex/polygon information in faster ways than in the past, which was essentialy critical for the high polygon objects.

Links: download, youtube
Graphics benchmark for gamepark handhelds and other devices
After coding so many demos for the gamepark handhelds, I've decided to create something more useful with the technology I had accumulated. I thought it would be a good idea then to create a benchmark application. As I acquired the sucessors of GP2X at the time, like the GP2X Wiz and it's brother, the Caanoo I decided to write this benchmark for these devices at first (a later port for GP2X and Dingoo A320 came next). The benchmark tests common stuff, from blitting very fast to the screen to more cache intensive stuff (rotozoomer far away, radial blur) and finally the highlight is using my software 3D engine for a very high polygon model, the Stanford bunny with roughly 70000 of polygons. It's not really what the machine can handle but it was interesting to see how it performs. At the end, a nicely designed screen with result bars appears.

Links: download, youtube
Luna Lu game prototype
During 2008, I started working on a game prototype based on an idea I had along with my colleagues at Dot Red Games. I was dreaming of a game with lot's of 2D physics and metaballs connected with strings that you should break, something like a more modern version of Pang. Of course, because we wanted to keep the casual style, some things in the initial idea changed and we ended up in this concept. The whole 2d graphics/physics engine was written in pure C code, using the SDL library for mode initialization, input, image loading, and there was a lot of 2d particles action happening on the screen. A solid 2d zooming sprite routine was coded with clipping, alpha channel and filtering support. The physics engine supports sphere to sphere collision, spring physics, particles, gravity so far. There is a config file where one can change some parameters too.

Links: download, youtube
glsl sandbox experiments
When I discovered the GLSL sandbox gallery site I was so enthousiastic with this idea that I started experimenting with various effects. The concept is that the site provides the means for you to write a single fragment shader which automatically maps on a quad (or two triangles :) that fit exactly the screen area. So, basically one has some kind of 2d framework to either write classic 2d effects or 3d raytracing/raymarching algorithms. Apart from some other simple tests I haven't included here, one night I thought of writting a very big fragment shader that renders several effects in a single screen, like specific parts of demos I used to watch in the older times. The fragment shader would separate the screen area in smaller regions where I would decide to render a different effect for each region. Later I added the ability that one of the regions recursively renders the whole screen area again and quite later I used the feedback function at the sandbox to get back the frame and add additional effects like motion blur, bump mapping and radial blur. I was so much impressed that this thing could run on a single shader that I've ported the shader in an old C++ OpenGL framework running on PC. This was because heroku didn't allowed much interactivity, like the option to zoom and rotate the screen with the mouse (this might have changed now) and so I wanted to have more control in a PC application. It's included in the download link among with source code.

Links: view (first test), view (recursive), view (motion blur), view (bump mapping), view (bump & radial blur), download (PC app port), youtube