Ever tried to render something with openGL on a linux server that has no x11 installed nor has a physical gpu connected? I searched for a long time for a solution that would work almost out of the box and the first solution i could find was actually installing x11, mesa3d and a dummy x-display. Via putty that has x11-forwarding enabled it is possible to run x-applications just fine and even render with openGL thanks to mesa in software mode!

But as soon as you close the ssh connection x11 stops and after that x-applications and openGL won't be able to connect to a display! So after every server restart openGL won't work anymore...

So why do you need a display or x11 if you want to render offscreen?

I made a little tool which allows me to download tiles from bing maps and puts them together.

The next updates will add a proper thread for the stiching process which currently blocks the Ui till it's done. Anyways grab it from github.

Gamma correction in openGL is very easily to achieve, but why do you need gamma correction? Let's keep it simple... First of all your textures you use as input for your openGL renderer are most likely in non linear color space. Your renderer on the other hand is probably calculating light under the assumption of linear color spaced color values in your loaded textures. So you might be working in two different color spaces. After your renderer is done it writes the colors to the screen, which uses non linear color space like your textures do! So what happens is, that your calculation might be visually wrong...

So how can you solve this?

The answer is very easy:

Why post processing antialiasing ? Because of two reasons. A good and fast post processing filter like fxaa or cmaa can achieve almost the same visual output like the usual multisampling counter part (msaa) and costs way less on the GPU because you dont need multiple samples per fragment/pixel! Another restriction is the rendering pipeline you might choose. A deferred renderer uses multiple framebuffers to achieve multiple different effects and using multiple samples on each of those framebuffers might have a really big impact on performance. Additionally it is practically impossible to use mxaa in a deferred renderer, because multisampling the position framebuffer results in wrong values around objects!

Let's have a look on the code:

The 2012 engine was built for OpenGL ES on Symbian. Symbian died in 2013, so I ported everything to desktop OpenGL and started again from scratch. The new renderer got the name Quark. This post collects the notes from August 2013 until March 2015.

Added post processing anti aliaising. Still tweaking it a bit.

The idea behind this shader: NFAA

Switcher is a task manager for Symbian S^3 that showed running processes as tiles. The 3D part of the app ran on my OpenGL ES engine. The app went into the Ovi Store in 2012, and Symbian died in 2013. Everything below is history.

These two projects came out of my studies at university. I study media informatics, and the semester projects allowed any object oriented programming language. Neither project became a long running hobby project, so the whole story sits in one post.

This post collects the development notes of my first C++ 3D engine. The engine ran on my notebook under Windows and on my Nokia N8 under Symbian S^3 Belle. It used OpenGL ES 2.0, and the Qt framework provided the application shell. The engine became later the base of a 3d rewrite for the Switcher task manager.

On 2012-07-25 I destroyed my notebook by mistake. The BIOS got fried during an update and the damage was not repairable. Development stopped for two weeks, because I had no machine that could compile and test my projects. I managed to back up all projects before the loss.