So, to recap, I decided to revive an old piece of software, because corona-virus induced sheltering in place had left me a little bonkers. Last update I talked about how I got it at least limping along.
Before I went too far, I set out some goals:
- Cross-platform – has to run on both Mac and PC, Linux an added bonus. Maybe mobile.
- Modern C++ for new code – any significant new code will have to use newer patterns and styles. Though for a code base that at its core is all pointer manipulation, this might not always be possible.
- Don’t reinvent the wheel – use libraries and other projects where possible.
- Keep the original ‘spirit’ – try not to lose the look and feel that had attracted me in the first place.
OpenGL, for those who are not big dorks like myself, is a open graphics library that has support across all the major OSes (Mac, Linux, Windows). It too has a long history, though not quite as long nor as stable a history as X (as in X.11).
Anyway, there was an attempt to build a Cthugha for OpenGL, but it did not age well, did not get very far, and did not really keep to the original spirit of Cthugha.
Here are some example screen shots after I got it building on the Mac.
To be honest, it looks kind of like someone’s intro to 3d graphics project. I could see, looking at the code, what they were trying to do, but it was not complete. And learning 3d programming in addition to reviving this other code base was just not in the cards.
But, there was one thing that was compelling about the OpenGL version, unlike X.11 which was only supported on Mac and Linux, Windows had embraced OpenGL.
I hatched a plan, there was code in the OpenGL version for displaying a bitmap as a background, I could take the non-OpenGL rendering frontend (the part that made the pretty pictures) and just slam it in as a background.
Guess what? It worked. Took some serious digging into strange un-commented (of course) code that jumped from pointer arithmetic to array manipulation, sometimes in the same line of code. But, I got it working, and it preformed pretty well.
There were some issues with scaling and such, but over all, it was a lot less work than I expected.
An Aside on Pointer Arithmetic
A pointer is a low level construct that gives you access to a section of the computer memory directly. There is little or no structure, just the raw bits. In C (and C++, less so in modern C++)
Pointer Arithmetic is the black art of manipulating data purely by moving around a pointer usually by adding and subtracting values. It can lead to some lean, fast, completely indecipherable code. It also can crash your application and leave you with bugs that are impossible to track down.
Usually, in good production level code, you avoid Pointer Arithmetic, when you can. It is hard to write correctly, difficult to support, and can make things like porting to a new platform impossible without rewriting. Of course, you can’t avoid it in some places, video codecs I am looking at you.
About this time I was getting serious about how to take this cross platform, since OpenGL was giving me a rendering path, now I needed to figure out how to get the code to compile.
Enter CMake.
Building code is a pain. But, CMake is spectacular, when it works. CMake will not build your code, it builds a project for the IDE of your choice, or a commandline build if you don’t want an IDE. (IDE means integrated development environment, XCode for Mac and Visual Studio for Windows are two major ones.) This makes moving from one platform a snap. I had used CMake in the past, and felt like I could get Cthugha and CMake to play really quickly.
Next time: Windows and Mac conspire against me.
Leave a Reply