Road Map

The general idea here is that the simplest iPhone template gives us a Window. We will add a special View subclass to that Window in Interface Builder, then at the appointed time, initialize OpenGL with an appropriate framebuffer that conforms to Apple’s implementation.

1. Open the app we started in part two, or just simply create a new iPhone Application using the Window-based Application template.
2. Double-click the MainWindow.xib file to launch Interface Builder.

3. 

   Double-click the xib file.

4. Drag the UIView element out from the Library and drop it on top of the Window in your app.

5. 

   Find the UIView choice and drag it onto the Window.

6. With the new View object selected, use the Inspector to change the class to a new name. This will be the name of your special subclass.

7. 

   Make sure the new view object is selected in the Window after dragging and dropping it.

8. 

   Edit the new view object to be an instance of a new class.

9. Now go to File – Write Class Files… to export the class definition to go with the new View subclass. Have it create the .h file, then check the check box to have Interface Builder add these files to your Xcode project.
10. At this point you can close Interface Builder, but your app won’t compile. Open up GLView.h and change the comment so that GLView actually inherits from a real class. Unfortunately, the comment is wrong. For iPhones, the View superclass is UIView, not NSView. The final file should look like this:


#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
@interface GLView : UIView {

}

@end

Now your app should compile and run like normal, although from a visual standpoint, we can’t tell that we’ve done anything.

Starting from Scratch

Last time, just to make sure our development environment was set-up, we used the OpenGL ES template. But I am more interested in seeing how that is itself built, so I am starting with the most basic iPhone Application possible.

Start a new Xcode project but this time, pick Window-Based Application.

Pick a Window-Based Application, the simplest template available.

Now when you run your app, you get a screen even less exciting than last post, but that’s the point. Now we’re going to add the elements we need to enable rendering to an OpenGL Context.

View Subclasses

All that is needed Interface-wise is to add a View to the Window. OpenGL is an API that needs to be implemented specifically for hardware, and Apple has done that implementation for us, encapsulated in a class of type EAGLContext. OpenGL is a C-based API so we just call OpenGL functions in the global namespace, not methods of any instance of a class. But internally, Apple’s implementation of all the OpenGL functions all end up operating on an instance of this class.  OpenGL renders graphics into a variety of blocks of memory, and one of those blocks of memory corresponds directly to the RGBA information of pixels on the screen. As part of their implementation, Apple’s engineers require this block of memory to be special, and it is our job to provide OpenGL with that memory space, but since it is special, we provide OpenGL that memory indirectly.

To OpenGL, the memory which contains RGBA information for what’s being drawn to the screen is nothing special. Apple’s designers and coders are the people that imposed the special requirements for this particular region of memory, encapsulated in an object of type CAEAGLLayer. For other types of memory that OpenGL draws into, we describe the layout of the memory using OpenGL function calls. But for this special memory used to store the framebuffer, we use Objective-C functions. But when in our program’s lifecycle to we call these Objective-C functions to configure our framebuffer’s memory? When do we tell OpenGL about this special memory? When do we instantiate the special OpenGL class that all the OpenGL functions operate on? I’ll talk about that next time.

The Baseline

I imagine that anyone who may be reading this probably knows how to get started, but for completeness, let’s start with the absolutely easiest thing. This is equivalent to Hello World, just a proof-of-concept to verify that everything works.

Start a new Xcode project by going to File - New Project.

Choose OpenGL ES as a new project

Pick a reasonable place to store your project like any other, then click the nice big Build and Go button.

Build the new project and run it in the Simulator.

If you click Build and Go (instead of just Building), and if you left everything else as the defaults, then Xcode will run your app in the iPhone Simulator right after it’s done compiling. You should see something exciting like this:

Standard output window for seeing compilation results.

Observe the template's content running in the iPhone Simulator

I know it’s not too exciting. Mostly this post is for me to build confidence in posting pictures and whatnot to these posts. Interesting (!) stuff starts next time.