C:/development/RenderTools/src/factory/viewcontroller/RendergroupEAGLView.mm

Go to the documentation of this file.

#ifdef RT_IOS
#ifdef __OBJC__

#include "IOSApplicationDelegate.h"
#include "RendergroupEAGLView.h"
#include "RendergroupIOSGLView.h"
#include "Renderbuffer.h"
#include "Framebuffer.h"

using namespace RenderTools;

RendergroupEAGLView * s_instance = nil;

void rendergroupEAGLViewDrawView( void ){
        [s_instance drawView];
}

void rendergroupEAGLViewSetNeedsDisplay( void ){
        [s_instance setNeedsDisplay];
}

void rendergroupEAGLViewStartTimer( void ){
        [s_instance startAnimation];
}

void rendergroupEAGLViewStopTimer( void ){
        [s_instance stopAnimation];
}

void rendergroupEAGLViewSetContext( void ){
        [ EAGLContext setCurrentContext:s_instance.m_context ];
}

void rendergroupEAGLViewSaveFramebufferToPhotosAlbum( void ){
        [ s_instance saveFramebufferToPhotosAlbum ];
}

void rendergroupEAGLViewSaveFramebuffer( void ){
        [ s_instance saveFramebufferToDefault ];
}

UIImage * rendergroupEAGLViewGetFramebufferImage( void ){
        [ EAGLContext setCurrentContext:s_instance.m_context ];
        return [ s_instance createFramebufferImage ];
}

RendergroupEAGLView * getRendergroupEAGLView( void ){
        return( s_instance );
}

GLuint rendergroupEAGLViewGetDefaultFramebufferID( void ){
        return( s_instance.m_defaultFramebuffer );
}

GLuint rendergroupEAGLViewGetDefaultRenderbufferID( void ){
        return( s_instance.m_defaultRenderbuffer );
}

@implementation RendergroupEAGLView

@synthesize m_animating;
@dynamic        m_animationFrameInterval;
@synthesize m_context;
@synthesize m_animationTimer;
@synthesize m_defaultFramebuffer;
@synthesize m_defaultRenderbuffer;
@synthesize m_framebufferWidth;
@synthesize m_framebufferHeight;

+ (Class)layerClass {
        return [CAEAGLLayer class];
}

- (id)initWithFrame:(CGRect)frame {    
        
        m_defaultFramebuffer = 0;       
        m_defaultRenderbuffer = 0;      
        m_animating = FALSE;
        m_displayLinkSupported = FALSE;
        m_animationFrameInterval = 1;
        m_displayLink = nil;
        m_animationTimer = nil;

        if( ( self = [ super initWithFrame:frame ] ) ){
        
                if( s_instance != nil ){
                        Error::error( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                }

                s_instance = self;
                                
                CAEAGLLayer * eaglLayer = (CAEAGLLayer *)self.layer;
                
                eaglLayer.opaque = YES;
                eaglLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys:
                        [NSNumber numberWithBool:FALSE], kEAGLDrawablePropertyRetainedBacking, kEAGLColorFormatRGBA8, kEAGLDrawablePropertyColorFormat, nil];
#ifdef RT_GLES2
                m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
#elif RT_GLES1
                m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
#endif

                if( ! m_context || ! [EAGLContext setCurrentContext:m_context ] ){
                        [self release];
                        return nil;
                }

        // A system version of 3.1 or greater is required to use CADisplayLink. The NSTimer
        // class is used as fallback when it isn't available.
                NSString *reqSysVer = @"3.1";
                NSString *currSysVer = [[UIDevice currentDevice] systemVersion];
                if( [ currSysVer compare:reqSysVer options:NSNumericSearch ] != NSOrderedAscending ){
                        m_displayLinkSupported = TRUE;
                }

                m_holdingTouches = [[NSMutableArray alloc] init];
                
                if( glIsBuffer( m_defaultFramebuffer ) == GL_FALSE ){
                        glGenFramebuffers( 1, & m_defaultFramebuffer );
                }
                if( glIsBuffer( m_defaultRenderbuffer ) == GL_FALSE ){
                        glGenRenderbuffers( 1, & m_defaultRenderbuffer );
                }
                
                glBindFramebuffer( GL_FRAMEBUFFER, m_defaultFramebuffer );
                glBindRenderbuffer( GL_RENDERBUFFER, m_defaultRenderbuffer );

                glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_defaultRenderbuffer );

                [m_context renderbufferStorage:GL_RENDERBUFFER fromDrawable:eaglLayer ];
                
                glGetRenderbufferParameteriv( GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, & m_framebufferWidth );
                glGetRenderbufferParameteriv( GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, & m_framebufferHeight );

#ifdef USE_MULTISAMPLING
                if( glIsBuffer( m_msaaFramebuffer ) == GL_FALSE ){
                        glGenFramebuffers( 1, & m_msaaFramebuffer); 
                }
                if( glIsBuffer( m_msaaRenderbuffer ) == GL_FALSE ){
                        glGenRenderbuffers( 1, & m_msaaRenderbuffer);
                }
                
                glBindFramebuffer( GL_FRAMEBUFFER, m_msaaFramebuffer); 
                glBindRenderbuffer( GL_RENDERBUFFER, m_msaaRenderbuffer );

                glRenderbufferStorageMultisampleAPPLE( GL_RENDERBUFFER, 4, GL_RGBA8_OES, m_framebufferWidth, m_framebufferHeight );
                glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_msaaRenderbuffer );
                glGenRenderbuffers( 1, & m_msaaDepthbuffer ); 
                glBindRenderbuffer(GL_RENDERBUFFER, m_msaaDepthbuffer );
                glRenderbufferStorageMultisampleAPPLE( GL_RENDERBUFFER, 4, GL_DEPTH_COMPONENT16, m_framebufferWidth, m_framebufferHeight );
                glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_msaaDepthbuffer );
                
                Framebuffer::setDefaultFramebufferID( m_msaaFramebuffer );
                Framebuffer::setDefaultDrawbufferID( m_msaaFramebuffer );
                Framebuffer::setDefaultReadbufferID( m_defaultFramebuffer );
                Renderbuffer::setDefaultColorbufferID( m_msaaRenderbuffer );
                Renderbuffer::setDefaultDepthbufferID( m_msaaDepthbuffer );
#else
                Framebuffer::setDefaultFramebufferID( m_defaultFramebuffer );
                Framebuffer::setDefaultDrawbufferID( m_defaultFramebuffer );
                Framebuffer::setDefaultReadbufferID( m_defaultFramebuffer );
                Renderbuffer::setDefaultColorbufferID( m_defaultRenderbuffer );
#endif          
                
                [ EAGLContext setCurrentContext:m_context ];

                getRendergroupIOSGLViewInstance()->setSize( m_framebufferWidth, m_framebufferHeight );


        }
        return self;
}

- (void)holdTouch:(NSTimer *)timer {
    UITouch * to = [ timer userInfo ];

        CGPoint location = [to locationInView:[to view]];
        CGPoint previousLocation = [to previousLocationInView:[to view]];
        
        TouchPoint tp = getRendergroupIOSGLViewInstance()->getTouchPoint( (unsigned long)to );
        tp.setHolding( tp.getHolding() + 0.05f );

        if( tp.getHolding() > 1.0 ){
                [ m_holdingTouches removeObject:timer ]; 
                [ timer invalidate ];
        }
        else{
                [ EAGLContext setCurrentContext:m_context ];
                getRendergroupIOSGLViewInstance()->touchHolding( (unsigned long)to, tp );
        }
}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
        if( getRendergroupIOSGLViewInstance() ){
                vector< TouchPoint > myTouches;
                vector< TouchIndex > myIndices;
                for( int i = 0; i < [[touches allObjects] count]; i++ ){
                        UITouch * to = [[touches allObjects] objectAtIndex:i];
                        CGPoint location = [to locationInView:[to view]];
                        CGPoint previousLocation = [to previousLocationInView:[to view]];

                        myIndices.push_back( (unsigned long)to );
                        myTouches.push_back( TouchPoint( Vec2( location.x, location.y ), Vec2( previousLocation.x, previousLocation.y ), [to tapCount], [to timestamp] ) );
                        
                        vector< NSTimer * > deleteTimers;
                        for( NSTimer * t in m_holdingTouches ){
                                if( [ t userInfo ] == to ){
                                        deleteTimers.push_back( t );
                                }
                        }
                        
                        for( unsigned int j = 0; j < deleteTimers.size(); j++ ){
                                NSTimer * t = deleteTimers[ j ];
                                [ m_holdingTouches removeObject:t ]; 
                                [ t invalidate ];
                        }
                        
                        NSTimer * timer = [NSTimer scheduledTimerWithTimeInterval:0.05f
                                                                target:self
                                                                selector:@selector(holdTouch:)
                                                                userInfo:to
                                                                repeats:YES];

                        [m_holdingTouches addObject:timer];
                }
                [ EAGLContext setCurrentContext:m_context ];
                getRendergroupIOSGLViewInstance()->touchesBegan( myIndices, myTouches );
        }
}

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event{
        if( getRendergroupIOSGLViewInstance() ){
                vector< TouchPoint > myTouches;
                vector< TouchIndex > myIndices;
                for( int i = 0; i < [[touches allObjects] count]; i++ ){
                        UITouch *to = [[touches allObjects] objectAtIndex:i];
                        
                        CGPoint location = [to locationInView:[to view]];
                        CGPoint previousLocation = [to previousLocationInView:[to view]];
                        myIndices.push_back( (unsigned long)to );
                        myTouches.push_back( TouchPoint( Vec2( location.x, location.y ), Vec2( previousLocation.x, previousLocation.y ), [to tapCount], [to timestamp] ) );

                        vector< NSTimer * > deleteTimers;
                        for( NSTimer * t in m_holdingTouches ){
                                if( [ t userInfo ] == to ){
                                        deleteTimers.push_back( t );
                                }
                        }
                        
                        for( unsigned int j = 0; j < deleteTimers.size(); j++ ){
                                NSTimer * t = deleteTimers[ j ];
                                [ m_holdingTouches removeObject:t ]; 
                                [ t invalidate ];
                        }

                        NSTimer * timer = [NSTimer scheduledTimerWithTimeInterval:0.05f
                                                                target:self
                                                                selector:@selector(holdTouch:)
                                                                userInfo:to
                                                                repeats:YES];

                        [m_holdingTouches addObject:timer];
                }
                [ EAGLContext setCurrentContext:m_context ];
                getRendergroupIOSGLViewInstance()->touchesMoved( myIndices, myTouches );
        }
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event{
        if( getRendergroupIOSGLViewInstance() ){
                vector< TouchPoint > myTouches;
                vector< TouchIndex > myIndices;
                for( int i = 0; i < [[touches allObjects] count]; i++ ){
                        UITouch *to = [[touches allObjects] objectAtIndex:i];
                        CGPoint location = [to locationInView:[to view]];
                        CGPoint previousLocation = [to previousLocationInView:[to view]];
                        myIndices.push_back( (unsigned long)to );
                        myTouches.push_back( TouchPoint( Vec2( location.x, location.y ), Vec2( previousLocation.x, previousLocation.y ), [to tapCount], [to timestamp] ) );

                        vector< NSTimer * > deleteTimers;
                        for( NSTimer * t in m_holdingTouches ){
                                if( [ t userInfo ] == to ){
                                        deleteTimers.push_back( t );
                                }
                        }
                        
                        for( unsigned int j = 0; j < deleteTimers.size(); j++ ){
                                NSTimer * t = deleteTimers[ j ];
                                [ m_holdingTouches removeObject:t ]; 
                                [ t invalidate ];
                        }
                }
                [ EAGLContext setCurrentContext:m_context ];
                getRendergroupIOSGLViewInstance()->touchesEnded( myIndices, myTouches );
        }
}

- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event{
        if( getRendergroupIOSGLViewInstance() ){
                vector< TouchPoint > myTouches;
                vector< TouchIndex > myIndices;
                for( int i = 0; i < [[touches allObjects] count]; i++ ){
                        UITouch *to = [[touches allObjects] objectAtIndex:i];
                        CGPoint location = [to locationInView:[to view]];
                        CGPoint previousLocation = [to previousLocationInView:[to view]];
                        myIndices.push_back( (unsigned long)to );
                        myTouches.push_back( TouchPoint( Vec2( location.x, location.y ), Vec2( previousLocation.x, previousLocation.y ), [to tapCount], [to timestamp] ) );

                        vector< NSTimer * > deleteTimers;
                        for( NSTimer * t in m_holdingTouches ){
                                if( [ t userInfo ] == to ){
                                        deleteTimers.push_back( t );
                                }
                        }
                        
                        for( unsigned int j = 0; j < deleteTimers.size(); j++ ){
                                NSTimer * t = deleteTimers[ j ];
                                [ m_holdingTouches removeObject:t ]; 
                                [ t invalidate ];
                        }
                }
                [ EAGLContext setCurrentContext:m_context ];
                getRendergroupIOSGLViewInstance()->touchesCancelled( myIndices, myTouches );
        }
}

- (void)drawView {


        [ EAGLContext setCurrentContext:m_context ];


#ifdef USE_MULTISAMPLING
        glBindFramebuffer( GL_FRAMEBUFFER, m_msaaFramebuffer );
        glBindRenderbuffer( GL_RENDERBUFFER, m_msaaRenderbuffer );
#else
        glBindFramebuffer( GL_FRAMEBUFFER, m_defaultFramebuffer );
        glBindRenderbuffer( GL_RENDERBUFFER, m_defaultRenderbuffer );
#endif
        getRendergroupIOSGLViewInstance()->onRender();

        [ EAGLContext setCurrentContext:m_context ];

#ifdef USE_MULTISAMPLING
        glBindFramebuffer( GL_FRAMEBUFFER, m_msaaFramebuffer );
        glBindFramebuffer( GL_READ_FRAMEBUFFER_APPLE, m_msaaFramebuffer ); 
        glBindFramebuffer( GL_DRAW_FRAMEBUFFER_APPLE, m_defaultFramebuffer );
        glResolveMultisampleFramebufferAPPLE( );
#else
        glBindFramebuffer( GL_FRAMEBUFFER, m_defaultFramebuffer );
#endif

        glBindRenderbuffer( GL_RENDERBUFFER, m_defaultRenderbuffer );

        [ m_context presentRenderbuffer:GL_RENDERBUFFER ];

#ifdef USE_MULTISAMPLING
        GLenum attachments[] = { GL_DEPTH_ATTACHMENT_OES, GL_COLOR_ATTACHMENT0_OES }; 
        glDiscardFramebufferEXT( GL_READ_FRAMEBUFFER_APPLE, 2, attachments );
#endif

        UIWindow * external = getIOSApplicationExternalWindow();
        if( external ){
                UIImageView * imageView = [ external.subviews objectAtIndex:0 ];
                imageView.image = [ self createFramebufferImage ];
        }

        Error::assertNoErrors( __FILE__, __LINE__ );
        
}

- (void)layoutSubviews {
        [self drawView];
}

- (void)onTimer {
        getRendergroupIOSGLViewInstance()->onTimer();
        
        if( getRendergroupIOSGLViewInstance()->needsUpdate() ){
                getRendergroupIOSGLViewInstance()->clearUpdateFlag();
                [self drawView];
        }
}

- (void)startAnimation {
        if( ! m_animating ){
                if( m_displayLinkSupported ){
                        m_displayLink = [ NSClassFromString( @"CADisplayLink" ) displayLinkWithTarget:self selector:@selector(onTimer) ];
                        [ m_displayLink setFrameInterval:m_animationFrameInterval ];
                        [ m_displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode ];
                }
                else{
                        m_animationTimer = [NSTimer scheduledTimerWithTimeInterval:m_animationFrameInterval target:self selector:@selector(onTimer) userInfo:nil repeats:YES];
                }
                m_animating = TRUE;
        }
}


- (void)stopAnimation {
        if( m_animating ){
                if( m_displayLinkSupported ){
                        [ m_displayLink invalidate ];
                        m_displayLink = nil;
                }
                else {
                        [ m_animationTimer invalidate ];
                        m_animationTimer = nil;
                }

                m_animating = FALSE;
        }
}

- (NSInteger)animationFrameInterval {
        return m_animationFrameInterval;
}

- (void)setAnimationTimer:(NSTimer *)newTimer {
        [ m_animationTimer invalidate ];
        m_animationTimer = newTimer;
}

- (void)setAnimationFrameInterval:(NSInteger)frameInterval {
        // Frame interval defines how many display frames must pass between each time the
        // display link fires. The display link will only fire 30 times a second when the
        // frame internal is two on a display that refreshes 60 times a second. The default
        // frame interval setting of one will fire 60 times a second when the display refreshes
        // at 60 times a second. A frame interval setting of less than one results in undefined
        // behavior.
        if( frameInterval >= 1 ){
                m_animationFrameInterval = frameInterval;
                if( m_animating){
                        [ self stopAnimation ];
                        [ self startAnimation ];
                }
        }
}

- (BOOL) shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
        return YES;
}

- (UIImage *)createFramebufferImage {

    NSInteger dataLength = m_framebufferWidth * m_framebufferHeight * 4;
        GLubyte * data = ( GLubyte * )malloc( dataLength * sizeof( GLubyte ) );

        [ EAGLContext setCurrentContext:m_context ];
        glBindFramebuffer( GL_FRAMEBUFFER, m_defaultFramebuffer );
        glBindRenderbuffer( GL_RENDERBUFFER, m_defaultRenderbuffer );

    // Read pixel data from the framebuffer
    glPixelStorei( GL_PACK_ALIGNMENT, 4 );
    glReadPixels( 0, 0, m_framebufferWidth, m_framebufferHeight, GL_RGBA, GL_UNSIGNED_BYTE, data );

    // Create a CGImage with the pixel data
    // If your OpenGL ES content is opaque, use kCGImageAlphaNoneSkipLast to ignore the alpha channel
    // otherwise, use kCGImageAlphaPremultipliedLast
    CGDataProviderRef provider = CGDataProviderCreateWithData( NULL, data, dataLength, NULL );
        CGColorSpaceRef colorSpaceRef = CGColorSpaceCreateDeviceRGB();
        CGBitmapInfo bitmapInfo = kCGBitmapByteOrderDefault;
        CGColorRenderingIntent renderingIntent = kCGRenderingIntentDefault;
        CGImageRef iRef = CGImageCreate( m_framebufferWidth, m_framebufferHeight, 8, 32, 4 * m_framebufferWidth, colorSpaceRef, bitmapInfo, provider, NULL, NO, renderingIntent );
        UIGraphicsBeginImageContext( CGSizeMake( m_framebufferWidth, m_framebufferHeight ) );
    CGContextRef cgcontext = UIGraphicsGetCurrentContext();

    // UIKit coordinate system is upside down to GL/Quartz coordinate system
    // Flip the CGImage by rendering it to the flipped bitmap context
    // The size of the destination area is measured in POINTS
    CGContextSetBlendMode( cgcontext, kCGBlendModeCopy );
    CGContextDrawImage( cgcontext, CGRectMake( 0.0, 0.0, m_framebufferWidth, m_framebufferHeight ), iRef );

    // Retrieve the UIImage from the current context
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    // Clean up
    free( data );
    CFRelease( colorSpaceRef );
        
        return image;
}

-( void )saveFramebufferToPhotosAlbum {
        UIImage * image = [ self createFramebufferImage ];
        UIImageWriteToSavedPhotosAlbum( image, self, @selector(imageSaved: didFinishSavingWithError: contextInfo:), nil );
}

-( void )saveFramebufferToDefault {
        UIImage * image = [ self createFramebufferImage ];
        NSString * fileName = [ [ NSHomeDirectory() stringByAppendingPathComponent:@"Documents" ] stringByAppendingPathComponent:@"framebuffer.png" ];
        [ UIImagePNGRepresentation( image ) writeToFile:fileName atomically:YES ];
}

- (void)imageSaved:(UIImage *)image didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo {  
    NSString *message;  
    NSString *title;  
    if( ! error ){
                title = @"Image saved to Photo Library";  
                message = @"";  
    } else {
                title = @"Error saving Image";  
                message = [error description];  
    }  
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:title  
                message:message  
                delegate:nil  
                cancelButtonTitle:@"OK"
                otherButtonTitles:nil];  
    [alert show];  
    [alert release];  
}

- (void)loadImage:( NSString * )url {
        UIImage * image = [ UIImage imageWithData:[ NSData dataWithContentsOfURL:[ NSURL URLWithString:url ] ] ];
        CGImageRef cgImage = image.CGImage;
        NSUInteger width = CGImageGetWidth( cgImage );
        NSUInteger height = CGImageGetHeight( cgImage );
        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
        GLubyte * rawData = ( GLubyte * )malloc( height * width * 4 );
        NSUInteger bytesPerRow = 4 * width;
        NSUInteger bitsPerComponent = 8;
        CGContextRef context = CGBitmapContextCreate( rawData, width, height, bitsPerComponent, bytesPerRow, colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
        CGContextDrawImage( context, CGRectMake( 0, 0, width, height ), cgImage );
        
        
        RendergroupPtr group = Rendergroup::getRendergroup( 0 );
        if( group ){
                SamplerPtr sampler = group->findSampler( "ArtiFlyer" );
                if( sampler ){
                        GLubyte * row = ( GLubyte * )malloc( bytesPerRow );
                        for( int i = 0; i < height; i++ ){
                                memcpy( row, & rawData[ i * bytesPerRow ], bytesPerRow );
                                memcpy( & rawData[ i * bytesPerRow ], & rawData[ ( height - 1 - i ) * bytesPerRow ], bytesPerRow );
                                memcpy( & rawData[ ( height - 1 - i ) * bytesPerRow ], row, bytesPerRow );
                        }
                        free( row );

                        SamplerPtr sampler = new Sampler( width, height, rawData );
                        sampler->setName( "ArtiFlyer" );
                        group->addSampler( sampler );

                        rendergroupEAGLViewDrawView();
                }
        }
        CGColorSpaceRelease( colorSpace );
        CGContextRelease( context );
}       

- (void)dealloc {       
        [self stopAnimation];
        if( [EAGLContext currentContext] == m_context ){
                [EAGLContext setCurrentContext:nil];
        }
        [m_context release];    
        [super dealloc];
}

- (void)quit {          
        [self stopAnimation];
                
        getRendergroupIOSGLViewInstance()->stopTimer();
        getRendergroupIOSGLViewInstance()->onQuit();

        [self dealloc];
}

@end

#endif
#endif

---