Hello, Sakari here, aka inDigiNeous. For the past 2 years I have been building my own 3D engine, from the ground up, using C++11 and modern OpenGL.
In this post I am going through the motivation to build my own 3D engine, technical details about the process and what is driving me to do this work. Work that is ultimately leading to the development of next version of GeoKone (“GeoKone 3D”) and later also to http://Geometrify.net.
The desire to see how things work
First some background on why I decided to create my own 3D engine, how I got here and why I ultimately didn’t just use a ready made solution like Unity or Unreal Engine, or any of the other more lightweight engines out there.
My personal goal has always been to understand things deeply, and to see behind things, how they operate on their core levels. I get satisfaction from understanding things thoroughly. I like to take apart stuff, build, re-build and see how the pieces fit together in different ways. This is where I get my kicks from.
To understand, to learn, to see what makes things tick.
My graphics background
When I started developing http://GeoKone.NET, I had some experience in programming graphics, but nothing on a really deep level. I first learned graphics programming back in the 90s in the MS-DOS days, doing some simple Turbo Pascal, assembler and C -based demo effects, but I never released anything or never did anything really cool.
Back in 2011 when I started working on GeoKone, and during the couple of years following that, there was no viable option to do hardware graphics processing in the browser, WebGL wasn’t really a viable option, and in a way it still even isn’t, although it is gaining popularity, stability and support now, but it is still limited to new powerful machines to get smooth frame rates and nice support.
Enter Virtual Reality
In December 2013 when the Oculus Rift DK1 became available to purchase for any developer, I could hear my intuition proclaiming loudly “Order!” “Do it!”.
I still remembered in the early 2000s when my intuition told me, as a engineering student, “purchase Apple stock” .. and I didn’t, so this time I decided to listen ;)
I ordered the first development kit, and the moment I first tested it, I knew that this is the environment where Geokone 3D has to be made.
Hello Androids :: Wearing the Oculus DK1
I decided to dedicate my time then to start learning C++ and OpenGL more and to get something showing with the DK1.
I had already prototyped core parts of GeoKone with C++, Java and even Objective-C, just to test out what would fit best for the case, so I had some code already to work on, but not much.
Development of libgeokone, very early stages, C++ & OpenGL
Back then there was no integrated support in Unity or Unreal Engine like now, so the only way to see something in stereo 3D, was to implement it using Oculus’s own C/C++ SDK.
Learning 3D basics
And I had no real experience in doing 3D programming, no understanding of how the math and the principles behind it worked. But I just decided, screw this, I’m gonna learn this while I go, and so I began.
Implementing and understanding basic 3D math and translations, projections and such took a while to understand, and matrix operations also still a bit difficult, but the more I program this stuff and really just teach it to myself, the more I start to see this geometry everywhere, how things are built, and understand the math and physics of space and light also while learning it, which is really interesting to notice.
Using a grid to verify 3D functionalities
Had one experience of walking outside after really grasping the 3D fundamentals and getting code working, I walked outside and could see their vector versions projected on top of the physical objects for a while there, like green matrixes of the physical objects, my mind mapping them out with the rules I just programmed for them. Woah! As Keanu Reeves would say.
Programming the Oculus Rift
It took me 4 months of work to get anything even showing properly with the DK1, mainly due to learning the basics of 3D programming, vectors, matrixes, projections, the whole third dimension and the complexity that comes with it. Luckily, for vector math I could use the great GLM library, which is really nice for working with OpenGL.
I had done simple 3D programming before this, but nothing that I could substantially understand, and this time I wanted to understand each thing I was doing, in order to really grasp what is going on here.
In these months of learning modern C++, OpenGL, GLSL, browsing the Oculus Forums to understand the SDK and just taking in all of this new information, I got to the state where I would get stereo rendering working properly finally, and man, it felt good at that point :)
One of the first stereo rendered scenes I did
Finally in beginning of May 2014 I had most of my geometry core from GeoKone ported to C++, with very simple GLSL shaders. This meant I could now draw recursive geometry in 3D space, with support for stereo rendering.
This would produce this kind of images:
Early stereo images
One of the very first scenes for verifying stereo rendering I did
Another stereo image
Developing the first Demo
I also got the DK1 rendering properly, so I now had this kind of images produced by my program, animated in 60 fps, zooming through the geometry:
Geokone geometry engine rendered in stereo with C++ & OpenGL
I continued from there to develop this demo, tested it with different music, and finally added music from my good friend Miika Kuisma. This lead to the development of the first demo of Geometrify, which we demoed together with Tommi Ullgren, Samuel Aarnio and many others helping us, ultimately us showcasing this potential of sacred geometry in VR at over 20 events and offering probably over a 1000 people their first VR experience ..
But that is a story for another blog post :)
From demo to engine
The first demo I did was just only a technical demo, made in a way that really didn’t support building flexible software around it, so I had to spend a lot of time figuring out how to get a proper framework of C++11 & OpenGL, built in a way that allowed configuration of a 3D world designed to render recursive geometry in a 3D space.
C++11 and OpenGL was chosen in order to support cross platform from the get go. No other language really offers bindings to all the libraries on all major three platforms, Mac Os X, Windows & Linux, and also mobile devices, and with the rock solid performance that this kind of experience would require to be really solid and feel smooth as silk.
Modern C++ practices
I spent lot of time in just learning OpenGL and C++11 best practices. C++11 is a very nice language, but to understand how to use it, you have to wade through maybe 15-20 years of legacy practices in order to find how things are done currently, and how to apply modern techniques.
Implementing beautiful line rendering
One of the key aspects of rendering recursive geometry, is how to get beautiful lines rendered. Turns out this is not as simple as just using a ready made library, as there really doesn’t exist such a thing.
I waded through different methods, read through many papers and found out people have implemented something already, like the VASE -renderer. Ultimately I decided to implement the line rendering method researched and implemented by Nicolas P. Rougier with python, described in his paper here: http://jcgt.org/published/0002/02/08/paper.pdf
Getting this to work I now had lines like this renderer in OpenGL:
First version of the antialiased polygon lines I implenented
Showing how these lines are tesselated from triangles
A More recent example of the line rendering method.
Need for a scripting language
One of the really annoying things about C++ is the need to compile the source code all the time even if you just change one number. Trying to implement program logic with this limitation was getting really on my nerves, as usually it took at least 2 – 3 seconds to compile the classes I was working on, and when doing this hundreds of times really takes a toll in the iteration times.
I reached the same conclusion that many others before me have done, and saw that I need to add scripting language support for my engine to really get anywhere in a reasonable time and not loose my mind while doing it.
I also looked at several other scripting options, but really the only other one that can be taken seriously is Lua, so I bit the bullet, learned yet another new language and bound my C++ engine to the Lua -side with the assistance of the great lua-intf interface.
Controlling scenes with Lua
Base work almost done
So finally I’ve reached a state of development in my engine, now named PSITriangle Engine™, where I can run program logic in scripts in Lua, and keep the parts requiring performance on the C++ side.
It’s been a long way to this state, to implement a very specific use-case 3D Geometry Engine, using modern C++11 and modern OpenGL + GLSL techniques, all the while learning how to do this while developing the actual engine.
The feeling of getting here, controlling all the pixels on the screen, using the power of math and geometry, and skills I had accumulated over the years to produce this virtual space, felt like pure creation coming into life.
I’m glad I didn’t know how much work implementing a 3D engine properly is, because I might have not chosen that path if I had known :D
Finally I can just quickly script and prototype ideas quickly. This brings development speeds up significantly and helps test and development massively easier from now.
From now on my plan is to finish this base of the engine and actually start implementing the program logic for what is going to become “GeoKone 3D” as the project name for now! :)