Today marks the first release of Overwatch Player Log. It’s a little utility program that allows you to record your favorite (or not!) players that you have met in Overwatch!
Recently I was working on a new desktop app for my new favorite game Overwatch. I got to the stage where I decided to add application icons to it.
After going through the trouble of creating the icon and adding it into the project, I compiled and had the new icon working on Windows pretty quick. Next, I moved to my Macbook and tested the new icon there as well but for the love of god the new icon would not show! Even after a new qmake, clean and rebuild…
Turns out I had to completely remove the app package itself then do another rebuild and voila! it’s there!
Timmmm from stackoverflow also had the same issue and discovered the same solution a few years ago.
It’s been 2 weeks since Uni started. As I am doing an Interactive Computer Graphics this semester, which uses OpenGL. I have therefore, started it.
Besides learning to draw the basic primitives and the usual rainbow colored triangles. Plus a little bit of shader programming. I’ve spent a lot of the time in the past 2 weeks just playing and experimenting with a couple of utility tool kits and graphics libraries for window creation and input handling. Namely Freeglut, GLFW, and SFML. Today, I will talk about my experience with them so far, and what not.
From a beginner point of view, getting started with learning how to setup a basic window and OpenGL context up was such a pain. Going from a C++ programmer to using libraries/API’s that are written in C also made me quite uncomfortable. To those who are a novice like me. Fear not, you will get used to it after a while. The hardest part is actually just getting the few concepts down. Specifically window and context initialization and the way OpenGL’s API is defined. This is not a tutorial, so I won’t go into the details, but I will provide a list of the online tutorials I’ve been using that are very good.
Freeglut is an API compatible clone of the now obsolete Glut. It is under active development, where as work on Glut halted back in 2005. All it does is providing means to create a window which an OpenGL context will be attached to. The reason I took a dip into Freeglut is because the Interactive Computer Graphics unit uses it (because the text book uses it…). It has been the de facto choice for tutorials and teaching materials, even though it should just die after the original project halted. now Just a quick rank: the lecturer seems like a nice guy, but he is just NOT lecturer materials. The textbook that he chose is also horrible. From what I’ve gathered, the same textbook has been used for the last couple years for this unit, which is sad. The text attempts to teach theories and concepts in computer graphics and tries to mix OpenGL into it.
The way Freeglut/Glut works is by providing a couple callbacks for different things while keeping completely control over it’s own main loop. This is good for making applications like interactive graphics render and model viewers, application which it was designed for developing. If you intend to develop applications such as games, that are much more interactive and resource intensive, then Freeglut is not for you. At first I wasn’t too sure why, but control over the main loop is very important.
To use Freeglut, you initialize the library and set your call backs, and then you begin Freeglut’s mainloop. At this point, Freeglut takes over control until it exits.
The next tool kit I tried is GLFW. It is a very minimal tool kit and does not do as much as what Freeglut give you, but it does give you control over your mainloop. Instead of entering Freeglut’s mainloop, you have something along the line of “pollevents()”, which it internally calls callbacks that can you set, just like Freeglut. GLFW and Freeglut are quite similar with their functions, in terms of initialization and configurating the window. I spent about a week on Freeglut. By the time I moved to GLFW, it wasn’t too hard picking it up.
What I did was I ended up wrapping the GLFW stuff into a RenderWindow class, and wrote a simple event queue and wrote custom callbacks to translate most of the call backs into my own events, which I then handled by polling my own event queue. I modeled it after SFML because I’ve been using it for a while now and the OOP aspect of it made it very elegant.
One thing that I do miss that Freeglut has and GLFW doesn’t is menu creation. Pop-up menus will be used extensively for this unit so I spent a lot of time investigating what alternative there is for GLFW besides writting my own. The problem is, there isn’t really any. I did managed to discover CEGUI, nui3, glui2 and AntTweakBar. The AntTweakBar library seems like the easiest to implement with the others looking quite complicated. I did not give any of them a try so I could be wrong. What bothered me is that they were GUI/widget tool kits and do not provide the ‘traditional’ menu.
Finally. I remember that SFML uses OpenGL internally. SFML (short for simple, fast, multi-media library). It’s popular for creating 2D games and applications. Bit of a rival to SDL. Best of all, it’s written in C++, and under active development. The library provides a lot to developers with 5 different modules. Providing classes for not just handling 2D graphics, but there are also classes for handling audio, network and other things. SFML allows you to use the OpenGL API directly, and it’s very simple to do some. What’s nice is that you can use it’s 2D graphics module along side of it. There are quite a few GUI libraries built for SFML but I havn’t look too deep into yet. The best thing yet is that I’ve been using SFML for the last couple dozen weeks on my 2D game engine project.
I spent the afternoon today and extended the engine enough to get some basic OpenGL primitive drawn. The engine is no where near completion. If I could use SFML for the interactive computer graphics unit then I will have the opportunity to develop and grow the engine along side the course project, instead of pausing work on my game project.
This blog has turned out to be a lot more formal and a bit more longer than I expected, but that’s cool. In closing, the libraries I mentioned today are not all there is out there. They are simply the ones that I’ve discovered and explored so far. There are many more out there that can be used for creating window and OpenGL context. The ones that I could think of on top of my head are Qt and SDL. I’ve used Qt before and it’s awesome for lots of things.
The next thing I will do is work a bit more on OpenGL with SFML for a bit more, and do so by extending my engine. I will also have to contatct my unit coordinator to accquire permission on developing on VS2012 with SFML on Windows (the project is meant to be done on a POSIX system with Freeglut). Lastly, I will continue learning OpenGL.
Stay tuned for the next log. Peace out!
(in order of most favored):
(no particular order):
[A little note first]. It seems it has taken forever for me to publish this post. In actual fact, it was actually finished back many moons ago. What happened was that, for some god forsaken reason, there appeared to have been a roll back. A little while after I published the article, the article was unpublished and the saved drafts rolled back to when I was only half way through writing this. This totally put me off, and so I basically went away from WordPress for some time, until now.
Any how, lets move on to the actual stuff.
Ever since I got my hands on the new Microsoft Visual Studio 2012 and all it’s goodies and junks, I’ve fallen in love with one thing. It’s dark theme!
It’s the next best thing for those who have super-uber-sensitive eyes. Besides chicken cooked in any possible yummy ways.
Now. Along side C++, I’m also a big fan of the Qt framework (its pronounced ‘cute’ apparently, but I like to call it Q.T.), and it’s ways, and I’ve been learning it with the book “An Introduction to Design Patterns in C++ with Qt” 2nd ed, by Ezust. A great read to add to my newbie C++ and design patterns knowledge, alongside the obvious Qt materials.
Moving back on topic. The default color schemes for the text editor’s syntax highlighting are pretty ugly if you ask me. Thanks to my mega laziness, I’ve never bothered to fiddle with it, right until a couple days when I’ve finally bite the bullet, and decided to have a go at it!
Now, here comes the hardest part. locating where the color scheme file is placed/stored was a massive pain in the buttock, especially on the Mac.
Windows users can find theirs in:
It’s a bit trickier for Mac users. You would have to first tell finder to show all the hidden files. Then you can go to here:
There’s a couple tutorial that you can find on Google on how to get finder to show hidden files, so i won’t post it here.
Now of course, if you look closely and compare it with VS2012’s dark theme, they are not 100% the same. Beside the different ways the 2 IDE’s identify different syntax elements, I’ve added some personal touch to give more highlight and avoided as much white as possible.
At last, here’s the link to the final XML file for the color scheme: [click me!]
My take on the Qt Creator’s color(or colour!) scheme. A direct imitation of the new Microsoft Visual Studio 2012’s dark theme for it’s editor.