I’ve figured out how to make movies from my OpenGL animation, and I’ve posted a video on YouTube, here.
I’ll be giving a talk on the work on Monday, January 24th at CU Boulder, at the Astrodynamics and Satellite Navigation Seminar. It’s at 3:00 pm, probably in the Seebass Forum Room (ECAE 153).
My fans (yes, both of you! Or am I down to one? zero?) may be wondering where I’ve gotten to. I’ve been working up a visualization program for a conference in Nanjing, China.
Back in grad school, I was an aerospace engineer, working in spacecraft dynamics and control. Torque-free rotation of a rigid body is one of those basic physics topics that we studied, on the way to figuring out how to control rotational motion of satellites and such.
My PhD advisor has gotten a big award, to be presented at a conference in Nanjing, and they’d like to have his students and colleagues come to present. Not having worked in the aerospace business for a while, I don’t have any research results to present, but I thought it would be fun to use OpenGL to visualize some of the analytical solutions to the rigid body rotation problem.
Recall what a spinning football does. If you get it spinning exactly around the long axis (the “perfect spiral”), it just spins around that axis. More often, it gets that funny wobble. How do we figure that wobble out?
One way to visualize the motion is to think about the angular momentum and angular velocity vectors (not the same, unfortunately, unless you have a spherically-symmetric object, which footballs aren’t). The angular momentum vector is constant in inertial space (what you’d see outside the vehicle, if you could see angular momentum vectors), but isn’t in a body-fixed frame (what you’d see if you were strapped into the vehicle).
What’s the angular velocity vector? If you think of the object as spinning on an imaginary axle, the angular velocity vector points along the axle, and its length is proportional to the speed of rotation. This axle usually has to be imaginary, since its direction can change relative to the body.
So I’ve worked up a simulation of a rotating, rigid body, with angular momentum and angular velocity vectors added.
This is a frame of the animated image. The yellow arrow is the angular momentum vector, and the purple arrow is the angular velocity vector. The red and yellow ice cream cone thing is the “spotlight” that illuminates the scene.
More images and explanations to come as I make progress with the visualizations!
I’ve been having trouble getting the specular highlights to show up on translucent ellipsoids, so I decided to create a program to let me vary the material colors and light strengths with sliders. I partly based it on Spot, but started from scratch because I wanted to control the material properties and lighting intensities in detail. At first I couldn’t get anything to show up in the OpenGL view, it showed up only as a pure white rectangle. I only found the problem after an almost line-by-line comparison of the new code with Spot. At very end of drawRect:, I had forgotten glSwapAPPLE(), so all of that drawing I did never made it to the window.
At first it seemed that specular lighting wasn’t working, but eventually I realized the problem was that the ambient and diffuse components were overwhelming the specular component: apparently the color has maximum level, and once it reaches that, no additional components will make that part of the object brighter.
It was a great help to have the sliders controlling the lighting and material settings in real time, instead of having to go through the edit-compile-link-run cycle. I also had the settings saved in the ID field of the TGA files, so I can (theoretically, at least) refer to them later on. Actually doing it, though, will require me to create a TGA image reader app that will display the ID text along with the image. Yet another app to create, more practice!
I’ve been working through the OpenGL SuperBible, Fourth Edition, and in order to get to shaders and begin working in OpenGL ES on the iOS, I decided to pick up a copy of iPhone 3D Programming, by Philip Rideout, a Denver author, as it turns out. I’m moving on to this book because my goal is iOS development, and this book gets me there more directly than studying OpenGL and iOS separately.
This book jumps right into application development, with HelloArrow, which puts a sort-of Starship Enterprise symbol on screen, keeping it vertical as the device rotates. There are actually two implementations, one in OpenGL ES 1.1, for earlier iOS devices, and the second in OpenGL ES 2.0, the modern version that uses shaders, which are small C-like programs that are compiled to run directly on the graphics hardware instead of the CPU. Shaders replace the fixed-function pipeline originally used in OpenGL. They were introduced in OpenGL 1.4 as an extension, and became part of the OpenGL core in version 2.0.
The book makes extensive use of C++ to do the heavy lifting for rendering and associated computational tasks, with just enough Objective-C to interface the rendering with iOS. You’ll want to be up on C++ to make your way through the book. Knowing something about Design Patterns will be very helpful—having studied Head First Design Patterns let me recognize what was going on in chapter 1.
The payoff for using C++ is portability: it’s easier to use C++ on other mobile devices, since Objective-C is very much an OS X and iOS peculiarity. I’ve gotten fond of Objective-C since I’ve been using it regularly, but this book is reminding me how powerful C++ is, and how much I enjoyed learning and using it.
The first version of the app uses a C++ renderer based on OpenGL ES 1.1. The second version upgrades to OpenGL ES 2.0, with code that checks if 2.0 is available, and dropping back to 1.1 if necessary.
The errors I came across were all fairly trivial, although hard to find. I had mis-capitalized some variable names, turning the correct Modelview into ModelView, and that kept the symbol from displaying: all I got was the gray background.
Here’s the final result:
Chapter 8 covers texturing, the process of applying an image to a surface, instead of simply making it a solid color. This can improve an image by adding a lot of detail without adding a huge number of triangles with their attendant supply of vertexes, normals and color data.
The first sample program applies a stone pattern to a pyramid. I adjusted the proportions of the pyramid to match the Great Pyramid at Giza, and then modified it to look like the dollar bill pyramid, with the apex floating above the base, like this:
The basic pyramid has five points and six triangles (four faces and two on the square base), but the floating-apex pyramid requires a lot more effort. I wrote a triangle-drawing method that takes three vertex index values, which then set the normal to the triangle, calculated the texture coordinates for each vertex, and then drew the three vertexes. That made the drawPyramid method much clearer: it just had to draw triangles, and the heavy lifting got done behind the scenes. Here’s the code:
- (void)drawTrianglePointA:(int)iA
pointB:(int)iB
pointC:(int)iC {
M3DVector3f vNormal;
m3dFindNormal(vNormal, vCorners[iA], vCorners[iB], vCorners[iC]);
// NSLog(@"Triangle %i, %i, %i with normal (%f, %f, %f)",
// iA, iB, iC, vNormal[0], vNormal[1], vNormal[2]);
int sAxis, tAxis;
float sFactor, tFactor;
float sBias, tBias;
float s, t;
if (vNormal[1] > 0.8 | vNormal[1] < -0.8) { // top of apex
sAxis = 0;
tAxis = 2;
sFactor = tFactor = vNormal[1]/(2.0f*width);
sBias = tBias = 0.5f;
} else if (vNormal[0] > 0.7f) {
sAxis = 2;
tAxis = 1;
sFactor = -0.5f/width;
sBias = 0.5f;
tFactor = 1.0f/height;
tBias = 0.0f;
} else if (vNormal[0] < -0.7f) {
sAxis = 2;
tAxis = 1;
sFactor = +0.5f/width;
sBias = 0.5f;
tFactor = 1.0f/height;
tBias = 0.0f;
} else if (vNormal[2] > 0.7f) {
sAxis = 0;
tAxis = 1;
sFactor = +0.5f/width;
sBias = 0.5f;
tFactor = 1.0f/height;
tBias = 0.0f;
} else {
sAxis = 0;
tAxis = 1;
sFactor = -0.5f/width;
sBias = 0.5f;
tFactor = 1.0f/height;
tBias = 0.0f;
}
// NSLog(@"sAxis = %i, tAxis = %i, sFactor, sBias = %f, %f; tFactor, tBias = %f, %f",
// sAxis, tAxis, sFactor, sBias, tFactor, tBias);
glNormal3fv(vNormal);
s = vCorners[iA][sAxis]*sFactor + sBias;
t = vCorners[iA][tAxis]*tFactor + tBias;
// NSLog(@"s = %f, t = %f", s, t);
glTexCoord2f(s, t);
glVertex3fv(vCorners[iA]);
s = vCorners[iB][sAxis]*sFactor + sBias;
t = vCorners[iB][tAxis]*tFactor + tBias;
// NSLog(@"s = %f, t = %f", s, t);
glTexCoord2f(s, t);
glVertex3fv(vCorners[iB]);
s = vCorners[iC][sAxis]*sFactor + sBias;
t = vCorners[iC][tAxis]*tFactor + tBias;
// NSLog(@"s = %f, t = %f", s, t);
glTexCoord2f(s, t);
glVertex3fv(vCorners[iC]);
}
- (void)drawPyramid {
// bottom of apex
[self drawTrianglePointA:2 pointB:4 pointC:1];
[self drawTrianglePointA:2 pointB:3 pointC:4];
// faces of apex
[self drawTrianglePointA:0 pointB:4 pointC:3];
[self drawTrianglePointA:0 pointB:1 pointC:4];
[self drawTrianglePointA:0 pointB:2 pointC:1];
[self drawTrianglePointA:0 pointB:3 pointC:2];
// Top of base
[self drawTrianglePointA:6 pointB:5 pointC:8];
[self drawTrianglePointA:8 pointB:7 pointC:6];
// faces of base
[self drawTrianglePointA:8 pointB:12 pointC:7];
[self drawTrianglePointA:7 pointB:12 pointC:11];
[self drawTrianglePointA:5 pointB:9 pointC:8];
[self drawTrianglePointA:8 pointB:9 pointC:12];
[self drawTrianglePointA:6 pointB:10 pointC:5];
[self drawTrianglePointA:5 pointB:10 pointC:9];
[self drawTrianglePointA:7 pointB:11 pointC:6];
[self drawTrianglePointA:6 pointB:11 pointC:10];
// bottom of base
[self drawTrianglePointA:10 pointB:12 pointC:9 ];
[self drawTrianglePointA:10 pointB:11 pointC:12];
}
Here are the coordinates:
vCorners = {{ 0.000000, 280.000000, 0.000000},
{ -52.380951, 213.333344, -52.380951},
{ 52.380951, 213.333344, -52.380951},
{ 52.380951, 213.333344, 52.380951},
{ -52.380951, 213.333344, 52.380951},
{ -83.809525, 173.333344, -83.809525},
{ 83.809525, 173.333344, -83.809525},
{ 83.809525, 173.333344, 83.809525},
{ -83.809525, 173.333344, 83.809525},
{ -220.000000, 0.000000, -220.000000},
{ 220.000000, 0.000000, -220.000000},
{ 220.000000, 0.000000, 220.000000},
{ -220.000000, 0.000000, 220.000000}};
The apex really needs to be casting a shadow to make the image more believable.
Now I need to add an eye texture to one face of the apex, and maybe “Novus Ordo Seclorum” or “MDCCLXXVI” at the bottom of the base. Or I could add it to SphereWorld and make the apex rotate…
OpenGL exists in a variety of versions, and different vendors have created extensions that other vendors don’t support. So how do you tell what verions of OpenGL you have, and what extensions can you use?
OpenGL lets you query its capabilities via the function glGetString(), which returns a string you can examine. Set the argument to the function to determine what OpenGL will tell you. GL_VERSION and GL_EXTENSIONS are the ones we’re interested in right now.
The single line of code NSLog(@"OpenGL Version %s", glGetString(GL_VERSION)); will tell you the version of OpenGL you have. My machine returns OpenGL Version 2.1 NVIDIA-1.6.18, so I’ve got an NVIDIA graphics card.
Here’s the code to develop the list of extensions.
NSLog(@"Now checking extensions...");
NSString *extensionString = [NSString
stringWithCString:(const char*)glGetString(GL_EXTENSIONS)
encoding:NSASCIIStringEncoding];
NSArray *extensions = [extensionString componentsSeparatedByString:@" "];
NSString *extensionsInHTML;
extensionsInHTML = [extensions componentsJoinedByString:@"</li>\n<li>"];
NSLog(@"<ol>\n<li>%@</li>\n</ol>", extensionsInHTML);
Yes, I was in full nerd mode writing code to create HTML markup. My machine has 122 extensions, so I’ll spare you my list: you’re interested in your machine, of course.
Chapter 7 covers how to deal with bit-mapped images, used as textures that cover images. The first program, Bitmap, uses a small data array to create a 16 by 16 black and white image of a campfire, only one bit deep (each pixel is either on or off).
Next up was ImageLoad, which loads a TARGA or tga file. The TARGA format is fairly old, but it is simple to use, so the OpenGL SuperBible makes use of it.
I started off having a hard time getting my Cocoa programs to load the TGA files. I tried integrating the GLEE tools, but kept having compiling and linking problems, and eventually I gave up and found some code online to load PNG files. I had been doing this on my trip home to Michigan using my soft copy of the fifth edition. When I got home and looked in my hard-copy fourth edition, I found that it had the code to load the TGA files. It was almost complete—I simply had to find the definition for the TGAHEADER in the sample code files.
I started out just adding a loadTGA method to my view class, and when I got that working, I decided to design an Objective-C TGAImage class, capable of loading and saving TGA files. Wikipedia has a description of the file format, here, which proved useful in designing the class.
Rather than loading files using C FILE pointers, I used NSData’s dataWithContentsOfURL:options:error: method to load the file and writeToURL:atomically:, like a proper Cocoa class.
My class allows setting the image ID field, which is not available in the book’s code. The TGA standard does not require any information, but the Wikipedia article suggests that it’s common for it to hold the date and time the image was created, or a serial number. I plan on using it to store the name of the app that created the image, plus the date and time. Unfortunately, the book’s code can’t load a file with an ID field, so storing this commits myself to using my own code. Of course, “eating your own dogfood” is generally good advice when creating tools, so if my class has any bugs, I will find out about them.
Here’s the header file, TGAImage.h:
//
// TGAImage.h
// ImageLoad
//
// Created by Norm Hecht on 10/2/10.
// Copyright 2010 Scamp Dog Software. All rights reserved.
//
#import <Cocoa/Cocoa.h>
@interface TGAImage : NSObject {
NSURL *fileURL;
NSString *IDInformation;
GLbyte *pixelData;
GLint xOrigin;
GLint yOrigin;
GLint width;
GLint height;
GLint components;
GLenum format;
}
-(id)initWithURL:(NSURL *)name;
-(id)initFromOpenGLContext;
-(BOOL)saveToURL:(NSURL *)name;
-(GLvoid *)bitmapData;
-(NSString *)IDInformation;
-(void)setIDInformation:(NSString *)theInfo;
-(GLint)xOrigin;
-(GLint)yOrigin;
-(GLint)width;
-(GLint)height;
-(GLint)components;
-(GLenum)format;
-(GLbyte *)pixelData;
@end
Here’s the implementation file, TGAImage.m:
//
// TGAImage.m
// ImageLoad
//
// Created by Norm Hecht on 10/2/10.
// Copyright 2010 Scamp Dog Software. All rights reserved.
//
#import "TGAImage.h"
#import <OpenGL/OpenGL.h>
@implementation TGAImage
-(id)initWithURL:(NSURL *)name {
if (!self) {
return self;
}
fileURL = name;
[fileURL retain];
unsigned char header[18];
NSData *tgaData = [NSData dataWithContentsOfURL:fileURL];
NSRange headerRange = NSMakeRange(0, 18);
if (!tgaData) {
NSLog(@"TGA file %@ not found", fileURL);
return NULL;
}
[tgaData getBytes:header range:headerRange];
int iCount;
for (iCount = 0; iCount < 18; iCount++) {
NSLog(@"Header byte %2i = %i", iCount, header[iCount]);
}
if (header[1] != 0) {
NSLog(@"TGA file uses a color map, which this method can't handle");
if (fileURL) {
[fileURL release];
}
return NULL;
}
char imageType = header[2];
if (imageType >= 8 ) {
NSLog(@"TGA file uses run-length encoding, which this method can't handle");
if (fileURL) {
[fileURL release];
}
return NULL;
}
switch (imageType) {
case 0:
NSLog(@"TGA file has no image data, what's up with that?");
if (fileURL) {
[fileURL release];
}
return NULL;
break;
case 1:
NSLog(@"TGA file has color-mapped image data, aborting");
if (fileURL) {
[fileURL release];
}
return NULL;
break;
case 3:
NSLog(@"TGA file has black and white image data");
break;
default:
break;
}
int IDLength = header[0];
if (IDLength > 0) { // Then read the ID information
NSLog(@"TGA file has an ID area");
NSRange IDRange = NSMakeRange(18, IDLength);
char *IDInfoCString = (char *)malloc(IDLength+1);
if (IDInfoCString == NULL) {
NSLog(@"Couldn't allocate memory for TGA file's ID information");
if (fileURL) {
[fileURL release];
}
return NULL;
}
[tgaData getBytes:IDInfoCString range:IDRange];
IDInfoCString[IDLength] = 0; // make last byte zero so it's a string
IDInformation = [NSString stringWithCString:IDInfoCString
encoding:NSUTF8StringEncoding];
free(IDInfoCString);
} else {
NSLog(@"TGA file has no ID area");
IDInformation = NULL;
}
xOrigin = header[9]*256 + header[8];
yOrigin = header[11]*256 + header[10];
width = header[13]*256 + header[12];
height = header[15]*256 + header[14];
NSLog(@"TGA image's origin, width and height are (%i, %i), %i and %i",
xOrigin, yOrigin, width, height);
int pixelDepth = header[16];
switch (pixelDepth) {
case 24:
format = GL_BGR_EXT;
components = GL_RGB8;
break;
case 32:
format = GL_BGRA_EXT;
components = GL_RGBA8;
break;
case 8:
format = GL_LUMINANCE;
components = GL_LUMINANCE8;
break;
default:
NSLog(@"TGA pixel depth invalid for OpenGL");
return NULL;
break;
}
int imageDescriptor = header[17];
NSLog(@"TGA image's pixel depth is %i, with descriptor of %i",
pixelDepth, imageDescriptor);
unsigned long lImageSize = width*height*pixelDepth/8;
NSLog(@"Image size in bytes should be %i", lImageSize);
pixelData = (GLbyte *)malloc(lImageSize*sizeof(GLbyte));
if (pixelData == NULL) {
NSLog(@"Failed to allocate memory for image data");
if (fileURL) {
[fileURL release];
}
return NULL;
}
NSRange pixelRange = NSMakeRange(18+IDLength, lImageSize);
[tgaData getBytes:pixelData range:pixelRange];
NSLog(@"Successfully read TGA file!");
return self;
}
-(id)initFromOpenGLContext {
GLint iViewPort[4]; // viewport in pixels
glGetIntegerv(GL_VIEWPORT, iViewPort);
unsigned long lImageSize = iViewPort[2]*iViewPort[3]*3;
pixelData = (GLbyte *)malloc(lImageSize);
if (!pixelData) { // couldn't allocate memory, so quit
return NULL;
}
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
// Get the current read buffer setting and save it. Switch to
// the front buffer and do the read operation. Finally, restore
// the read buffer state.
GLint lastBuffer; // storage for the current read buffer setting
glGetIntegerv(GL_READ_BUFFER, &lastBuffer);
glReadBuffer(GL_FRONT);
glReadPixels(0, 0, iViewPort[2], iViewPort[3], GL_BGR,
GL_UNSIGNED_BYTE, pixelData);
glReadBuffer(lastBuffer);
xOrigin = 0;
yOrigin = 0;
width = iViewPort[2];
height = iViewPort[3];
format = GL_BGR_EXT;
components = GL_RGB8;
return self;
}
-(BOOL)saveToURL:(NSURL *)name {
NSMutableData *tgaData = [[[NSMutableData alloc] init] autorelease];
unsigned char header[18];
header[1] = 0; // No color map
header[2] = 2; // Uncompressed, true-color image
header[3] = header[4] = 0; // offset into color map table, not used
header[5] = header[6] = 0; // number of color map entries, not used
header[7] = 0; // number of bits in (non-existant) color map entries
header[8] = xOrigin % 256;
header[9] = xOrigin / 256;
header[10] = yOrigin % 256;
header[11] = yOrigin / 256;
header[12] = width % 256;
header[13] = width / 256;
header[14] = height % 256;
header[15] = height / 256;
header[16] = 24; // bits per pixel
header[17] = 0; // image descriptor:
// bits 0-3 alpha depth, bits 5-4 direction
if (IDInformation) {
int IDLength = [IDInformation length];
if (IDLength < 256) {
header[0] = IDLength;
[tgaData appendBytes:header length:18];
NSData *IDData = [IDInformation
dataUsingEncoding:NSUTF8StringEncoding];
[tgaData appendData:IDData];
} else {
NSLog(@"Truncating IDInformation");
header[0] = 255;
[tgaData appendBytes:header length:18];
NSRange r = NSMakeRange(0, 255);
NSData *IDData = [[IDInformation substringWithRange:r]
dataUsingEncoding:NSUTF8StringEncoding];
[tgaData appendData:IDData];
}
} else {
header[0] = 0;
[tgaData appendBytes:header length:18];
}
NSUInteger imageSize = width*height*3;
[tgaData appendBytes:pixelData length:imageSize];
return [tgaData writeToURL:name atomically:NO];
}
- (void)dealloc {
[super dealloc];
if (pixelData) {
free(pixelData);
}
if (fileURL) {
[fileURL release];
}
if (IDInformation) {
[IDInformation release];
}
}
-(NSString *)IDInformation {
return IDInformation;
}
-(void)setIDInformation:(NSString *)theInfo {
if (IDInformation) {
[IDInformation release];
}
IDInformation = theInfo;
[IDInformation retain];
}
-(GLvoid *)bitmapData {
return pixelData;
}
-(GLint)xOrigin {
return xOrigin;
}
-(GLint)yOrigin {
return yOrigin;
}
-(GLint)width {
return width;
}
-(GLint)height {
return height;
}
-(GLint)components {
return components;
}
-(GLenum)format {
return format;
}
-(GLbyte *)pixelData {
return pixelData;
}
@end
