Finally, after wasting an hour hacking around inside my theme’s PHP code, I realize that discussions on all of my posts had been disabled in my WordPress Admin panel. I can only guess, but it appears that one of the last two WordPress updates screwed up my settings during the patch install and left my entire site in a disabled state.

Either way, it’s fixed, so if you have any replies you wish to leave, please do, unless, its questions about why you couldn’t post replies last week. I think we’ve already covered that!

Recently, I was struggling with an OpenGL feature that required me to research faster ways of reading pixel data back to the CPU from the GPU where I could perform some post processing on it. Typically, you should try very hard to keep your post processing on the GPU instead trying to read it back across the bus, but in this case I wanted to fetch the pixel data back so I could load it into a WPF app and I had no choice. It must come back and as fast as possible.

After much research, I settled on a solution that does an off-screen rendering to a FBO (frame buffer object) and then uses two alternating PBOs (pixel buffer objects) to perform an asynchronous read-back to system memory via DMA transfers. The beauty of this approach is that it disables the blocking behavior which is typically associated with calling glReadPixels, and this is always the prime culprit when it comes to bad read-back performance for pixel data that is being shuttled back across the bus. If you’re researching something similar, I hope this research sample proves useful.

The sample targets the regular desktop version of OpenGL and was coded and tested in Visual Studio 2005 and 2008 on both Windows Xp and Windows 7.

Therefore, I decided to create some really simple, stand-alone OpenGL ES 2.0 samples that can run on Windows through PowerVR’s OpenGL ES 2.0 emulator.

Yes, I know that the emulator is part of a SDK that has a ton of samples, but I like small, self-contained samples that stand on their own and do not rely on a massive common samples library that hides most of the detail. And, yes, I also know that all this abstraction is meant to help me, but somehow it makes things seem even more mysterious when certain aspects of OpenGL ES are tucked away out of sight. Anyway, I just like tiny, bare-bone samples that get straight to the point.

If that’s you, read on.

First off, you’ll need to download PowerVR’s OpenGL ES 2.0 emulator SDK since OpenGL ES is intended for mobile devices – not full-size computers that normally run regular OpenGL. The actual downland link is under the header of PC Emulation and is titled Windows Vista/XP – OpenGL ES 2.0.

Once you’ve installed their SDK you’ll be able to run all of the PowerVR samples right away because they all reference the SDK through relative paths, but the samples I offer do not use relative paths so you’ll need to add a few paths to Visual Studio to get to them to compile and link, and you’ll need to add one path to your system’s PATH environment variable to get them to run on the emulator. Here’s how you do it.

1. In the menu of Visual Studio select Tools->Options to launch the Options dialog.
2. On the Options dialog, open or expand the Project and Solutions category and select VC++ Directories.
3. In the Show directories for drop down box select Include files and add the following paths. Of course, your paths may vary depending on where you install the SDK and the version you downloaded.
   1. C:\Imagination Technologies\POWERVR SDK\OGLES2_WINDOWS_PCEMULATION_2.07.27.0484\Builds\OGLES2\WindowsPC
   2. C:\Imagination Technologies\POWERVR SDK\OGLES2_WINDOWS_PCEMULATION_2.07.27.0484\Builds\OGLES2\Include
4. Next, In the Show directories for drop down box select Library files and add this path:
   1. C:\Imagination Technologies\POWERVR SDK\OGLES2_WINDOWS_PCEMULATION_2.07.27.0484\Builds\OGLES2\WindowsPC\Lib

Finally, you’re going to add a path to your system’s PATH variable so you can run the samples on the emulator no matter where you run your samples from. This path will point to the .dlls for the emulator which are stored in the SDK’s lib directory.

1. To do this, hold down the Windows key on your keyboard and hit the Pause/Break key to bring up the System Properties dialog.
2. On the System Properties dialog select the Advanced tab and click the Environment Variables button.
3. Under System Variables double click the PATH variable and append this path to the end of the long list of other paths. Make sure to separate our new path from the last path with a semicolon.
   1. ;C:\Imagination Technologies\POWERVR SDK\OGLES2_WINDOWS_PCEMULATION_2.07.27.0484\Builds\OGLES2\WindowsPC\Lib

If you get all this right, you’ll now be able to download, compile and run the OpenGL ES 2.0 samples from my site. Now, to get the ball rolling, here are two samples to test out your new OpenGL ES 2.0 emulation environment.

This first sample is super simple and is focused on setting up and initializing OpenGL ES 2.0. I’m not going to elaborate much here since there are tons of blogs that discuss the basics of using of EGL to create an OpenGL ES 2.0 window from a system specific Window, so download the sample, read through the code, and start Googling if you have questions.

The second sample is a little more advanced and adds textured geometry to the mix which is pretty cool because it shows how to load a PNG image with transparency using the LodePNG library so we can create an OpenGL texture from it.

Here are the basics of using LodePNG library to create an OpenGL texture.

//
// Load and decode a PNG file so we can make a texture out of it.
//

std::vector< unsigned char > rawImage;
LodePNG::loadFile( rawImage, "test_alpha.png" );

LodePNG::Decoder decoder;
std::vector< unsigned char > image;
decoder.decode( image, rawImage.empty() ? 0 : &rawImage[0],
                (unsigned)rawImage.size() );

Unfortunately, OpenGL likes to load things completely opposite from everybody else, so you’ll also need some code to flip and invert the image data before loading it into an OpenGL texture array:

//
// Flip and invert the PNG image since OpenGL likes to load everything
// backwards from what is considered normal!
//

unsigned char *imagePtr = &image[0];
int halfTheHeightInPixels = decoder.getHeight() / 2;
int heightInPixels = decoder.getHeight();

// Assuming RGBA for 4 components per pixel.
int numColorComponents = 4;

// Assuming each color component is an unsigned char.
int widthInChars = decoder.getWidth() * numColorComponents;

unsigned char *top = NULL;
unsigned char *bottom = NULL;
unsigned char temp = 0;

for( int h = 0; h < halfTheHeightInPixels; ++h )
{
    top = imagePtr + h * widthInChars;
    bottom = imagePtr + (heightInPixels - h - 1) * widthInChars;

    for( int w = 0; w < widthInChars; ++w )
    {
        // Swap the chars around.
        temp = *top;
        *top = *bottom;
        *bottom = temp;

        ++top;
        ++bottom;
    }
}

Once that’s done, you can move forward and create an OpenGL texture out of the flipped over PNG data:

//
// Create the OpenGL texture and fill it with our PNG image.
//

// Allocates one texture handle
glGenTextures( 1, &g_uiTexture );

// Binds this texture handle so we can load the data into it
glBindTexture( GL_TEXTURE_2D, g_uiTexture );

glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, decoder.getWidth(),
              decoder.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE,
              &image[0] );

Well, that concludes my little introduction to setting up an OpenGL ES 2.0 emulation environment on Windows. I hope it helps you get a little further down the road of mobile 3D development with OpenGL.

Lua is a rather popular scripting language for game design. If you don’t believe me just check out this list of games that use Lua. Clearly, anyone serious about game programming and especially learning scripting for level design, which is where Lua shines brightest, should take a moment out of their busy schedule and get too know Lua.

Ok, enough with the sales pitch.. let’s just jump in and gets this party started!

Installing Lua for Windows

The first thing I need you to do is download Lua and get it installed on your system and the fasted way to do this is to simply install the Windows for Lua binaries which not only contains Lua already compiled and ready to go but includes  numerous other libraries that you may find helpful in the future. The version that I downloaded was LuaForWindows_v5.1.4-40.exe. Other than downloading it, the install is the standard fare… click next, next, next, etc… you know the drill.

Install the ConTEXT editor

Next, we need a text editor (preferably free) aimed at programmers which will make coding and running our Lua scripts a bit more organized. The text editor I use for my Guildhall course is ConTEXT which allows me customize the highlight of my Lua code and execute scripts from the editor with a simple push of a button. The version of ConTEXT that I downloaded was ConTEXTv0_986.exe. If there is another text editor you would prefer to use, please feel free to use it, but keep in mind that these tutorials will be written as if you were using ConTEXT.

Once you’ve downloaded and installed both Lua and the ConTEXT editor please follow these steps to finish the setup.

1. First off, we need to setup ConTEXT to execute our Lua scripts by pressing the F11 key.
   1. Open ConTEXT and select from the menu Options->Environment Options.
   2. On the Environment Options dialog select the Execute Keys tab.
   3. Click the Add button and add a new extension called “Lua”
   4. Select the new Lua extension in the tree view and set the Execute path to “C:\Program Files (x86)\Lua\5.1\lua.exe” This path maybe different on your computer depending on your OS version where you installed Lua For Windows.
   5. Set the Parameters edit box to “%n”.
   6. Click the Apply button and close the Environment Options dialog.
2. Finally, add my custom Lua highlighter file to ConTEXT. This is optional, but it makes the code look really sweet instead of plain ol’ black-on-white and who doesn’t want that? Further instructions are included in the zip file.

When done, the Environment Options dialog of ConTEXT should look like this:

Testing Our Development Setup

The last thing we’re going to do is test our development setup by creating a new Lua script and attempting to execute it from ConTEXT. To accomplish this, follow theses steps:

1. Open ConTEXT and create a new file by selecting from the menu File->New.
2. In this new file type the following line: print( “Hello Lua!” )
3. Save the file by selecting from the menu File->Save and name it “hello.lua”. You can save it anywhere you want.
4. Finally, hit the F11 key to execute the script.
5. If everything works, you should see the the words “Hello Lua!” printed out in ConTEXT’s Output Console.

When done, ConTEXT should look something like this:

In the next tutorial, we’ll start leveraging our new development setup to learn the basic syntax of Lua. If you have any troubles getting any of this working, please feel free to reply below.

Now, while the site undergoes this incredible metamorphosis into something even cooler, all the code from the old site can still be accessed under the Code tab of the navigation bar.