Objective-C

Display an OpenGL image in Objective-C for Apple iPhone SDK.

// Display "myImage.png"
 
// ----------------------------------------------------------------------------
// OpenGLESTextureAppDelegate.m
// ----------------------------------------------------------------------------
 
#import "OpenGLESTextureAppDelegate.h"
#import "EAGLView.h"
#import "OpenGLESTextureViewController.h"
 
@implementation OpenGLESTextureAppDelegate
 
@synthesize window=_window;
 
@synthesize viewController=_viewController;
 
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
	// Override point for customization after application launch.
	self.window.rootViewController = self.viewController;
    return YES;
}
 
- (void)applicationDidBecomeActive:(UIApplication *)application
{
	/*
	 Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
	 */
	[self.viewController drawFrame];
}
 
- (void)dealloc
{
	[_window release];
	[_viewController release];
    [super dealloc];
}
 
@end
 
 
// ----------------------------------------------------------------------------
// EAGLView.m
// ----------------------------------------------------------------------------
 
#import <QuartzCore/QuartzCore.h>
#import "EAGLView.h"
 
@interface EAGLView (PrivateMethods)
- (void)createFramebuffer;
- (void)deleteFramebuffer;
@end
 
@implementation EAGLView
 
@synthesize context;
 
// You must implement this method
+ (Class)layerClass
{
    return [CAEAGLLayer class];
}
 
//The EAGL view is stored in the nib file. When it's unarchived it's sent -initWithCoder:.
- (id)initWithCoder:(NSCoder*)coder
{
    self = [super initWithCoder:coder];
	if (self) {
        CAEAGLLayer *eaglLayer = (CAEAGLLayer *)self.layer;
 
        eaglLayer.opaque = TRUE;
        eaglLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys:
                                        [NSNumber numberWithBool:FALSE], kEAGLDrawablePropertyRetainedBacking,
                                        kEAGLColorFormatRGBA8, kEAGLDrawablePropertyColorFormat,
                                        nil];
    }
 
    return self;
}
 
- (void)dealloc
{
    [self deleteFramebuffer];    
    [context release];
 
    [super dealloc];
}
 
- (void)setContext:(EAGLContext *)newContext
{
    if (context != newContext) {
        [self deleteFramebuffer];
 
        [context release];
        context = [newContext retain];
 
        [EAGLContext setCurrentContext:nil];
    }
}
 
- (void)createFramebuffer
{
    if (context && !defaultFramebuffer) {
        [EAGLContext setCurrentContext:context];
 
        // Create default framebuffer object.
        glGenFramebuffers(1, &defaultFramebuffer);
        glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebuffer);
 
        // Create color render buffer and allocate backing store.
        glGenRenderbuffers(1, &colorRenderbuffer);
        glBindRenderbuffer(GL_RENDERBUFFER, colorRenderbuffer);
        [context renderbufferStorage:GL_RENDERBUFFER fromDrawable:(CAEAGLLayer *)self.layer];
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &framebufferWidth);
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &framebufferHeight);
 
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorRenderbuffer);
 
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
            NSLog(@"Failed to make complete framebuffer object %x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
    }
}
 
- (void)deleteFramebuffer
{
    if (context) {
        [EAGLContext setCurrentContext:context];
 
        if (defaultFramebuffer) {
            glDeleteFramebuffers(1, &defaultFramebuffer);
            defaultFramebuffer = 0;
        }
 
        if (colorRenderbuffer) {
            glDeleteRenderbuffers(1, &colorRenderbuffer);
            colorRenderbuffer = 0;
        }
    }
}
 
- (void)setFramebuffer
{
    if (context) {
        [EAGLContext setCurrentContext:context];
 
        if (!defaultFramebuffer)
            [self createFramebuffer];
 
        glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebuffer);
 
        glViewport(0, 0, framebufferWidth, framebufferHeight);
    }
}
 
- (BOOL)presentFramebuffer
{
    BOOL success = FALSE;
 
    if (context) {
        [EAGLContext setCurrentContext:context];
 
        glBindRenderbuffer(GL_RENDERBUFFER, colorRenderbuffer);
 
        success = [context presentRenderbuffer:GL_RENDERBUFFER];
    }
 
    return success;
}
 
- (void)layoutSubviews
{
    // The framebuffer will be re-created at the beginning of the next setFramebuffer method call.
    [self deleteFramebuffer];
}
 
@end
 
 
// ----------------------------------------------------------------------------
// OpenGLESTextureViewController.m
// ----------------------------------------------------------------------------
 
#import <QuartzCore/QuartzCore.h>
#import "OpenGLESTextureViewController.h"
#import "EAGLView.h"
 
@interface OpenGLESTextureViewController ()
@property (nonatomic, retain) EAGLContext *context;
@property (nonatomic, assign) CADisplayLink *displayLink;
- (void) loadTexture;
@end
 
@implementation OpenGLESTextureViewController
 
@synthesize animating, context, displayLink;
 
- (void)awakeFromNib
{
    EAGLContext *aContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
 
    if (!aContext)
        NSLog(@"Failed to create ES context");
    else if (![EAGLContext setCurrentContext:aContext])
        NSLog(@"Failed to set ES context current");
 
	self.context = aContext;
	[aContext release];
 
    [(EAGLView *)self.view setContext:context];
    [(EAGLView *)self.view setFramebuffer];
 
	[self loadTexture];
 
    self.displayLink = nil;
}
 
- (void) loadTexture
{
	glEnable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
	glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 
	NSString *path = [[NSBundle mainBundle] pathForResource:@"myImage" ofType:@"png"];
    NSData *texData = [[NSData alloc] initWithContentsOfFile:path];
    UIImage *image = [[UIImage alloc] initWithData:texData];
 
    GLuint width = CGImageGetWidth(image.CGImage);
    GLuint height = CGImageGetHeight(image.CGImage);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    void *imageData = malloc( height * width * 4 );
    CGContextRef image_context = CGBitmapContextCreate( imageData, width, height, 8, 4 * width, colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big );
    CGColorSpaceRelease( colorSpace );
    CGContextClearRect( image_context, CGRectMake( 0, 0, width, height ) );
    CGContextTranslateCTM( image_context, 0, height - height );
    CGContextDrawImage( image_context, CGRectMake( 0, 0, width, height ), image.CGImage );
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageData);
 
    CGContextRelease(image_context);
 
    free(imageData);
    [image release];
    [texData release];
 
}
 
- (void)dealloc
{
	glDeleteTextures(1, &textureID);
 
    // Tear down context.
    if ([EAGLContext currentContext] == context)
        [EAGLContext setCurrentContext:nil];
 
    [context release];
 
    [super dealloc];
}
 
- (void)viewDidUnload
{
	[super viewDidUnload];
 
    // Tear down context.
    if ([EAGLContext currentContext] == context)
        [EAGLContext setCurrentContext:nil];
	self.context = nil;	
}
 
- (void)drawFrame
{
    [(EAGLView *)self.view setFramebuffer];
 
    // Replace the implementation of this method to do your own custom drawing.
    static const GLfloat squareVertices[] = {
        -0.5f, -0.33f,
        0.5f, -0.33f,
        -0.5f,  0.33f,
        0.5f,  0.33f,
    };
 
	static const GLfloat texCoords[] = {
        0.0, 1.0,
        1.0, 1.0,
        0.0, 0.0,
        1.0, 0.0
    };
 
 
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
 
	glVertexPointer(2, GL_FLOAT, 0, squareVertices);
	glEnableClientState(GL_VERTEX_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
    [(EAGLView *)self.view presentFramebuffer];
}
 
@end