Learning OpenGL. Log 1

This is the first, in what will be a series of posts on my journey in learning OpenGL (or as some say, modern OpenGL).

———————————————————————————————————————————————————————-

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 (Wiki link)

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.

GLFW (link)

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.

SFML (link)

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.

Closing

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!

List of tutorials

(in order of most favored):

List of libraries mentioned

(no particular order):

  • Freeglut
  • GLFW
  • SFML
  • SDL
  • Qt
  • nui3
  • CEGUI
  • glui2
  • AntTweakBar

Infinity Box and interactive graphics

A week or two back I’ve finally setup a blog for Infinity Box Studios using wordpress on the same host. Originally I thought it would had been too much work, so I actually considered embedding something like blogger or tumblr into the home page since I did the webpage using Adobe Muse. That would have meant that I won’t get 100% of the page hits (which, there is literally none at the moment…).

Anyway, I ended up finding out that it actually isn’t hard at all getting WordPress setup on my host. I spent more time choosing the right theme and customizing it than installing the blog. It was pretty much a one-click process.

Another thing that also held me back was that I didn’t really have anything to post about on that blog yet(still don’t have any) , so I thought it’s kinda pointless to set one up.

While we’re at it. I’ve also done some things to the structure of the website for Infinity Box Studio. Before I had basically the entire website inside a sub-directory called “InfinityBoxStudio/” and had htaccess redirect the main domain to the index.html file inside the sub-directory (I wanted to avoid cluttering the main directory).  This ended up giving very ugly web addresses like this one:

[code language=”html”]
http://www.infinityboxstudio.com/infinityboxstudio/index.html
[/code]

I’ve fixed this by setting up a “home” sub-domain and have htaccess redirect all main domain access to the “home” sub-domain. Now everything looks prettier like this:

[code language=”html”]
http://home.infinityboxstudio.com/index.html
[/code]

To be honest, I really hate this htaccess stuff. Confusing enough. Guess I just don’t have time to look into it yet. Eventually I might look into replacing the entire website with another WordPress blog.

Speaking of Infinity Box. My game project, Project-K has been going slow since Uni started. You can blame the interactive graphics unit that I’m taking this semester. It’s all about computer graphics, graphics pipelines and OpenGL. Because of that, I’ve started an experimental project with OpenGL. Right now it’s mostly just writing some classes to encapsulate window creation and handling. The project uses GLFW internally for that and input handling, so I’m also trying  to implement an Event system to further encapsulate stuff and make things look nicer when using GLFW. Originally I started with Freeglut, which is also what’s being used by the unit materials. The few posts on the internet seem to suggest that GLFW is a much better choice for game development as it gives more control over the main loop. I’m having kind of a hard time seeing the difference between the two yet, but I’m sure I will discover more as I dig more into it. With that, I’ve fallen into the dilemma of whether I should use my GLFW stuff to run the unit lab projects and examples or stick with Freeglut.

Rest assure, work is still being done on Project-K, it will just happen a lot slower with Uni happening. It’s good in a way. I can spend more time to think before I code, instead of just code and hope things work and play nicely together. We will see how that turns out. Hopefully by the end of the year the engine will be more complete, then I can start prototyping the actual game. Before that can happen, a small game will be developed along side and as part of the engine to make sure that it works.

I had more to tell but I think this is enough for today. Bye for now!