PSNB's Programming

Book Rant: OpenGL Programming Guide - 7th edition

2012-01-05T03:01:00.000-08:00

As I mentioned in my first post "A Bit of History...", I ended up reading through the "OpenGL Red Book" when I first started studying OpenGL. However, I neglected to mention just how infuriated it made me.

You see, the "OpenGL Red Book" is just a nickname that was given to the "OpenGL Programming Guide". It has a reputation of being the book to read if you're planning on learning OpenGL. While this may have been true in the past, it sure as hell isn't the case anymore.

The most up-to-date edition of the book covers OpenGL 3.0 and 3.1. Admittedly, this is a little out of date as the current version of OpenGL is 4.2, but it is still new enough to remain largely relevant. Since the introduction of shaders with OpenGL 2.0, the focus of the API has gradually veered away from fixed-functionality, and into a programmable pipeline. With the introduction of OpenGL 3.0, much of the original API was marked as deprecated, namely immediate-mode rendering and fixed-functionality.

Deprecating old features gives way for new and improved features to come in and supersede them. In the case of OpenGL, immediate-mode rendering would be replaced by buffers stored on the GPU, and fixed-functionality would be replaced by programmable shaders. Surely these topics would be the primary focus of the book, right?

Unfortunately, the answer is resounding no. A large portion of the book focuses on deprecated components of the API, only to tell you not to use any of it afterwards. This would have been more than acceptable if they just skimmed over what had been deprecated and moved on, but this is far from the case. There is a single chapter dedicated to shaders, and a section within a chapter dedicated to Vertex Buffer Objects.

Save yourself the trouble of reading through this and just skip directly to "The OpenGL Shading Language: 3rd Edition", nicknamed "The Orange Book". While not perfect, it is infinitely better than this garbage, and actually covers topics relevant to modern versions of OpenGL.

Tutorial: Creating an LWJGL window with a Canvas

2012-01-04T21:15:00.000-08:00

One of the more difficult things to do with LWJGL is getting a rendering context setup. Most tutorials make you create a DisplayMode and create a native window, which limits you to resolutions that are supported by your monitor, which can be somewhat annoying if you plan on running your game in windowed mode. Luckily, there is an easy work around that will allow you to set your window to whatever size you want.

The first thing that we need to do is create a new window and add a canvas to it. Typically, I would create a new class that extends JFrame as it makes the code much more manageable, and allows me to separate the window from the engine. However, for the purposes of this tutorial, I'll just use an instance of a JFrame since it requires much less setup.

JFrame frame = new JFrame();

//Set JFrame properties here...



Canvas canvas = new Canvas();

//Required to set the size of the window.

canvas.setPreferredSize(new Dimension(desiredWidth, desiredHeight));



//Add the canvas to the frame.

frame.add(canvas);



//Prepare and display the frame.

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

If we run the program now, we'll get a basic Swing window with a canvas added to it.

Now we need to bind the window to an OpenGL context. This is incredibly easy to do, and only takes a few lines of code to accomplish.

try {

    Display.setParent(canvas);

    Display.create();

} catch(LWJGLException e) {

    //Handle the exception as you see fit.

}

Now our window is bound to an OpenGL context, and can be drawn on just like normal. If your program hangs, make sure that you're calling Display.update() constantly, and that you're not running the engine on a Swing thread.

Beginning C++

2012-01-03T22:58:00.000-08:00

A couple of days ago I decided to try picking up C++. This is not my first attempt at learning the language, but it is the most official. Previous attempts at learning the language failed because I simply jumped into things without setting things up first.

This time around, I'm using Visual Studio instead of Code::Blocks, as it seems to be a much more well developed and featured IDE. I've also managed to get my hands on a copy of "The C++ Programming Language: Special Edition" by Bjarne Stroustrup, the language's designer.

I'm currently only on the second chapter, which is basically an overview of the language and it's features. I have yet to really delve into much code, but I'm looking forward to it. Here's to hoping things go smoothly, cheers!

A Bit of History...

2012-01-03T21:45:00.000-08:00

Ever since I was a little kid I've been interested in computers. My first experience with any sort of programming was when I was 10 and received a book on JavaScript from my parents. I remember looking through the first few chapters and how accomplished I felt when I wrote my first clock script. However, my excitement was short lived as I quickly became frustrated and gave up once the concepts started to get complex.

A few years later, I decided - for whatever reason - that I wanted to give programming another try. At this point, I had really no understanding of programming languages, all I knew was that I wanted to work on applications. After a bit of studying, I narrowed my choices down to Java and C++, eventually going with Java because it had a very well written, and very well documented tutorial series available for free on it's website. I picked up the language quite easily and stuck with it exclusively for a few years.

Around a year ago, I started to become bored and wanted to learn something new. By this time I had wanted to try getting into game development and decided to compile a list of tools and concepts that are used in game engines.

Initially, I looked at scripting languages that could be used alongside Java. The first language I looked at was Clojure, a dialect of Lisp that was developed to run specifically on the JVM. However, the language syntax was different from anything I had seen before, and I was immediately turned off from the language. Afterwards, I decided to take a look at some Ruby and Lua libraries that were available for Java. Unlike Clojure, the libraries weren't made for the JVM, and were instead just ported and linked to native libraries in C++. I ended up learning both of these languages, though I'm still not incredibly familiar with them.

Next on my list was 3D graphics. I knew that OpenGL & DirectX were the two main 3D APIs, and decided to pick up OpenGL because DirectX is windows only, while OpenGL is cross platform. I ended up reading through the Red Book for learning OpenGL, and am now reading through the Orange Book for learning GLSL. Though I'm still pretty new to both, I can still create some pretty interesting things.