OS X Layered View: Use pbuffer method (pbuffer w/ dbl buffer)

- attributes +NSOpenGLPFANoRecovery +NSOpenGLPFAAccelerated
- use SurfaceUpdateListener() to notify layer
- swapBufferImpl() adapt to 0038e2d41825c22bdd18a7b86a8229a3fab674a3
- pbuffer: don't enforce POT tex-size to surface size, but pbuffer only
- FIXME: Check POT pbuffer/tex-size for X11/Win32/.. !
-

4 files changed, 326 insertions, 165 deletions

diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface-nsview.m b/src/jogl/native/macosx/MacOSXWindowSystemInterface-nsview.m
new file mode 100644
index 000000000..7233f40ce
--- /dev/null
+++ b/src/jogl/native/macosx/MacOSXWindowSystemInterface-nsview.m
@@ -0,0 +1,140 @@
+
+@interface MyNSOpenGLLayer: NSOpenGLLayer
+{
+@protected
+    NSOpenGLContext*     ctxShared;
+    NSView*              view;
+    NSOpenGLPixelFormat* fmt;
+@public
+    volatile BOOL        shallDraw;
+}
+
+- (id) initWithContext: (NSOpenGLContext*) ctx
+       pixelFormat: (NSOpenGLPixelFormat*) pfmt
+       view: (NSView*) v
+       opaque: (Bool) opaque;
+
+@end
+
+@implementation MyNSOpenGLLayer
+
+- (id) initWithContext: (NSOpenGLContext*) _ctx
+       pixelFormat: (NSOpenGLPixelFormat*) _fmt
+       view: (NSView*) _view
+       opaque: (Bool) opaque
+{
+    self = [super init];
+    ctxShared = _ctx;
+    [ctxShared retain];
+
+    fmt = _fmt;
+    [fmt retain];
+
+    view = _view;
+    [view retain];
+    [self setView: view];
+    [view setLayer: self];
+    [view setWantsLayer: YES];
+
+    [self setAsynchronous: NO];
+    // [self setAsynchronous: YES]; // FIXME: JAU
+    [self setNeedsDisplayOnBoundsChange: NO];
+    [self setOpaque: opaque ? YES : NO];
+    shallDraw = NO;
+    textureID = 0;
+    DBG_PRINT("MyNSOpenGLLayer::init %p, ctx %p, pfmt %p, view %p, opaque %d\n", self, ctx, fmt, view, opaque);
+    return self;
+}
+
+- (void)dealloc
+{
+    [fmt release];
+    [ctxShared release];
+    [view release];
+    DBG_PRINT("MyNSOpenGLLayer::dealloc %p\n", self);
+    [super dealloc];
+}
+
+- (void) setOpenGLContext: (NSOpenGLContext*) _ctx
+{
+    DBG_PRINT("MyNSOpenGLLayer::setOpenGLContext: %p %p -> %p\n", self, [self openGLContext], _ctx);
+    [super setOpenGLContext: _ctx];
+}
+
+- (void) setOpenGLPixelFormat: (NSOpenGLPixelFormat*) _fmt
+{
+    DBG_PRINT("MyNSOpenGLLayer::setOpenGLPixelFormat %p %p -> %p\n", self, fmt, _fmt);
+    [super setOpenGLPixelFormat: fmt];
+}
+
+- (NSOpenGLPixelFormat *) openGLPixelFormat
+{
+    return fmt;
+}
+
+- (void) setView: (NSView*) v
+{
+    DBG_PRINT("MyNSOpenGLLayer::setView %p %p -> %p (ignored/propagated)\n", self, view, v);
+    [super setView: view]; // propagate
+}
+
+- (NSOpenGLPixelFormat *)openGLPixelFormatForDisplayMask:(uint32_t)mask
+{
+    DBG_PRINT("MyNSOpenGLLayer::openGLPixelFormatForDisplayMask %p %d -> %p\n", self, mask, fmt);
+    return fmt;
+}
+
+- (NSOpenGLContext *)openGLContextForPixelFormat:(NSOpenGLPixelFormat *)pixelFormat
+{
+    NSOpenGLContext* ctx = NULL;
+    if(NULL == ctx) {
+        int viewNotReady[] = { 0 };
+        ctx = createContext(ctxShared, view, true, fmt, [self isOpaque], viewNotReady);
+    }
+    DBG_PRINT("MyNSOpenGLLayer::openGLContextForPixelFormat %p, fmt %p/%p, view %p, shared %p -> %p\n", 
+        self, fmt, pixelFormat, view, ctxShared, ctx);
+    return ctx;
+}
+
+- (BOOL)canDrawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
+        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
+{
+    DBG_PRINT("MyNSOpenGLLayer::canDrawInOpenGLContext %p: %d\n", self, self->shallDraw);
+    return self->shallDraw;
+}
+
+- (void)drawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
+        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
+{
+    self->shallDraw = NO;
+
+    DBG_PRINT("MyNSOpenGLLayer::drawInOpenGLContext %p, ctx %p, pfmt %p\n", self, context, pixelFormat);
+
+    [super drawInOpenGLContext: context pixelFormat: pixelFormat forLayerTime: timeInterval displayTime: timeStamp];
+}
+
+@end
+
+NSOpenGLLayer* createNSOpenGLLayer(NSOpenGLContext* ctx, NSOpenGLPixelFormat* fmt, NSView* view, Bool opaque) {
+  return [[MyNSOpenGLLayer alloc] initWithContext:ctx pixelFormat: fmt view: view opaque: opaque];
+}
+
+void setNSOpenGLLayerNeedsDisplay(NSOpenGLLayer* layer) {
+  MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  l->shallDraw = YES;
+  [l performSelectorOnMainThread:@selector(setNeedsDisplay) withObject:nil waitUntilDone:YES];
+  // NSView* view = [l view];
+  // [view setNeedsDisplay: YES]; // FIXME: JAU
+  // [view performSelectorOnMainThread:@selector(setNeedsDisplay:) withObject:YES waitUntilDone:YES];
+  // [view performSelectorOnMainThread:@selector(display) withObject:nil waitUntilDone:YES];
+  DBG_PRINT("MyNSOpenGLLayer::setNSOpenGLLayerNeedsDisplay %p\n", l);
+  [pool release];
+}
+
+void releaseNSOpenGLLayer(NSOpenGLLayer* l) {
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  [l release];
+  [pool release];
+}
+
diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m b/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m
new file mode 100644
index 000000000..16e5829ba
--- /dev/null
+++ b/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m
@@ -0,0 +1,151 @@
+#import "MacOSXWindowSystemInterface.h"
+
+@interface MyNSOpenGLLayer: NSOpenGLLayer
+{
+@protected
+    NSOpenGLPixelBuffer* pbuffer;
+    int width;
+    int height;
+    GLuint textureID;
+@public
+    volatile BOOL        shallDraw;
+}
+
+- (id) initWithContext: (NSOpenGLContext*) ctx
+       pixelFormat: (NSOpenGLPixelFormat*) pfmt
+       pbuffer: (NSOpenGLPixelBuffer*) p
+       opaque: (Bool) opaque
+       width: (int) width 
+       height: (int) height;
+
+@end
+
+@implementation MyNSOpenGLLayer
+
+- (id) initWithContext: (NSOpenGLContext*) _ctx
+       pixelFormat: (NSOpenGLPixelFormat*) _fmt
+       pbuffer: (NSOpenGLPixelBuffer*) p
+       opaque: (Bool) opaque
+       width: (int) _width 
+       height: (int) _height;
+{
+    self = [super init];
+    pbuffer = p;
+    [pbuffer retain];
+
+    [self setAsynchronous: NO];
+    // [self setAsynchronous: YES]; // FIXME: JAU
+    [self setNeedsDisplayOnBoundsChange: NO];
+    [self setOpaque: opaque ? YES : NO];
+    width = _width;
+    height = _height;
+    textureID = 0;
+    shallDraw = NO;
+    DBG_PRINT("MyNSOpenGLLayer::init %p, ctx %p, pfmt %p, pbuffer %p, opaque %d, %dx%d -> %dx%d\n", 
+        self, _ctx, _fmt, pbuffer, opaque, width, height, [pbuffer pixelsWide], [pbuffer pixelsHigh]);
+    return self;
+}
+
+- (void)dealloc
+{
+    [pbuffer release];
+    DBG_PRINT("MyNSOpenGLLayer::dealloc %p\n", self);
+    [super dealloc];
+}
+
+- (BOOL)canDrawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
+        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
+{
+    DBG_PRINT("MyNSOpenGLLayer::canDrawInOpenGLContext %p: %d\n", self, self->shallDraw);
+    return self->shallDraw;
+}
+
+- (void)drawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
+        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
+{
+    self->shallDraw = NO;
+
+    [context makeCurrentContext];
+   
+    GLenum textureTarget = [pbuffer textureTarget];
+    GLsizei pwidth = [pbuffer pixelsWide];
+    GLsizei pheight = [pbuffer pixelsHigh];
+    GLfloat tWidth = textureTarget == GL_TEXTURE_2D ? (GLfloat)width/(GLfloat)pwidth : pwidth;
+    GLfloat tHeight = textureTarget == GL_TEXTURE_2D ? (GLfloat)height/(GLfloat)pheight : pheight;
+   
+    DBG_PRINT("MyNSOpenGLLayer::drawInOpenGLContext %p, ctx %p, pfmt %p %dx%d -> %fx%f 0x%X\n", 
+        self, context, pixelFormat, width, height, tWidth, tHeight, textureTarget);
+
+    if(0 == textureID) {
+        glGenTextures(1, &textureID);
+    }
+    glBindTexture(textureTarget, textureID);
+
+    [context setTextureImageToPixelBuffer: pbuffer colorBuffer: GL_FRONT];
+
+    glTexParameteri(textureTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(textureTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+   
+    glEnable(textureTarget);
+   
+    static GLfloat verts[] = {
+    -1.0, -1.0,
+    -1.0,  1.0,
+     1.0,  1.0,
+     1.0, -1.0
+    };
+   
+    GLfloat tex[] = {
+     0.0,    0.0,
+     0.0,    tHeight,
+     tWidth, tHeight,
+     tWidth, 0.0
+    };
+   
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, verts);
+    glTexCoordPointer(2, GL_FLOAT, 0, tex);
+   
+    glDrawArrays(GL_QUADS, 0, 4);
+   
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+   
+    glDisable(textureTarget);
+   
+    [super drawInOpenGLContext: context pixelFormat: pixelFormat forLayerTime: timeInterval displayTime: timeStamp];
+}
+
+@end
+
+NSOpenGLLayer* createNSOpenGLLayer(NSOpenGLContext* ctx, NSOpenGLPixelFormat* fmt, NSOpenGLPixelBuffer* p, Bool opaque, int width, int height) {
+  return [[MyNSOpenGLLayer alloc] initWithContext:ctx pixelFormat: fmt pbuffer: p opaque: opaque width: width height: height];
+}
+
+void setNSOpenGLLayerNeedsDisplay(NSOpenGLLayer* layer) {
+  MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  l->shallDraw = YES;
+  if ( [NSThread isMainThread] == YES ) {
+      [l setNeedsDisplay];
+  } else {
+      // [l performSelectorOnMainThread:@selector(setNeedsDisplay) withObject:nil waitUntilDone:YES];
+      [l performSelectorOnMainThread:@selector(setNeedsDisplay) withObject:nil waitUntilDone:NO];
+  }
+  // NSView* view = [l view];
+  // [view setNeedsDisplay: YES]; // FIXME: JAU
+  // [view performSelectorOnMainThread:@selector(setNeedsDisplay:) withObject:YES waitUntilDone:YES];
+  // [view performSelectorOnMainThread:@selector(display) withObject:nil waitUntilDone:YES];
+  DBG_PRINT("MyNSOpenGLLayer::setNSOpenGLLayerNeedsDisplay %p\n", l);
+  [pool release];
+}
+
+void releaseNSOpenGLLayer(NSOpenGLLayer* l) {
+  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+  [l release];
+  [pool release];
+}
+
diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface.h b/src/jogl/native/macosx/MacOSXWindowSystemInterface.h
new file mode 100644
index 000000000..763930e37
--- /dev/null
+++ b/src/jogl/native/macosx/MacOSXWindowSystemInterface.h
@@ -0,0 +1,20 @@
+#import <Cocoa/Cocoa.h>
+#import <OpenGL/gl.h>
+#import <OpenGL/CGLTypes.h>
+#import <jni.h>
+
+#define VERBOSE_ON 1
+
+#ifdef VERBOSE_ON
+    // #define DBG_PRINT(...) NSLog(@ ## __VA_ARGS__)
+    #define DBG_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
+#else
+    #define DBG_PRINT(...)
+#endif
+
+#ifndef CGL_VERSION_1_3
+    #warning this SDK doesn't support OpenGL profile
+#endif
+
+#import "macosx-window-system.h"
+
diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface.m b/src/jogl/native/macosx/MacOSXWindowSystemInterface.m
index 7c10545f3..af269a4b5 100644
--- a/src/jogl/native/macosx/MacOSXWindowSystemInterface.m
+++ b/src/jogl/native/macosx/MacOSXWindowSystemInterface.m
@@ -14,28 +14,10 @@
 #endif
 */
 
-#import <Cocoa/Cocoa.h>
-#import <OpenGL/gl.h>
-#import <OpenGL/CGLTypes.h>
-#import <jni.h>
-
-#define VERBOSE_ON 1
-
-#ifdef VERBOSE_ON
-    // #define DBG_PRINT(...) NSLog(@ ## __VA_ARGS__)
-    #define DBG_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
-#else
-    #define DBG_PRINT(...)
-#endif
-
-#ifndef CGL_VERSION_1_3
-    #warning this SDK doesn't support OpenGL profile
-#endif
+#import "MacOSXWindowSystemInterface.h"
 
 #import "ContextUpdater.h"
 
-#import "macosx-window-system.h"
-
 // see MacOSXPbufferGLContext.java createPbuffer
 #define USE_GL_TEXTURE_RECTANGLE_EXT
 
@@ -399,6 +381,18 @@ NSOpenGLPixelFormat* createPixelFormat(int* iattrs, int niattrs, int* ivalues) {
   for (i = 0; i < niattrs && iattrs[i]>0; i++) {
     int attr = iattrs[i];
     switch (attr) {
+      case NSOpenGLPFANoRecovery:
+        if (ivalues[i] != 0) {
+          attribs[idx++] = NSOpenGLPFANoRecovery;
+        }
+        break;
+
+      case NSOpenGLPFAAccelerated:
+        if (ivalues[i] != 0) {
+          attribs[idx++] = NSOpenGLPFAAccelerated;
+        }
+        break;
+
       case NSOpenGLPFAPixelBuffer:
         if (ivalues[i] != 0) {
           attribs[idx++] = NSOpenGLPFAPixelBuffer;
@@ -678,153 +672,9 @@ void setContextPBuffer(NSOpenGLContext* ctx, NSOpenGLPixelBuffer* pBuffer) {
   [pool release];
 }
 
-void setContextTextureImageToPBuffer(NSOpenGLContext* ctx, NSOpenGLPixelBuffer* pBuffer, int colorBuffer) {
-  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-  [ctx setTextureImageToPixelBuffer: pBuffer
-             colorBuffer: (unsigned long) colorBuffer];
-  [pool release];
-}
-
-@interface MyNSOpenGLLayer: NSOpenGLLayer
-{
-@protected
-    NSOpenGLContext*     ctx;
-    NSView*              nsView;
-    NSOpenGLPixelFormat* fmt;
-@public
-    volatile BOOL        shallDraw;
-}
-
-- (id) initWithContext: (NSOpenGLContext*) ctx
-       pixelFormat: (NSOpenGLPixelFormat*) pfmt
-       view: (NSView*) v
-       opaque: (Bool) opaque;
-
-@end
-
-@implementation MyNSOpenGLLayer
-
-- (id) initWithContext: (NSOpenGLContext*) _ctx
-       pixelFormat: (NSOpenGLPixelFormat*) pfmt
-       view: (NSView*) view
-       opaque: (Bool) opaque
-{
-    self = [super init];
-    self->ctx = _ctx;
-    if(NULL != ctx) {
-        [ctx retain];
-    }
-    fmt = pfmt;
-    if(NULL != fmt) {
-        [fmt retain];
-    }
-    if(NULL != view) {
-        [view retain];
-        [self setView: view];
-        [view setWantsLayer: YES];
-    }
-    [self setAsynchronous: NO];
-    [self setNeedsDisplayOnBoundsChange: NO];
-    [self setOpaque: opaque ? YES : NO];
-    self->shallDraw=NO;
-    DBG_PRINT("MyNSOpenGLLayer::init %p, ctx %p, pfmt %p, view %p, opaque %d\n", self, ctx, fmt, nsView, opaque);
-    return self;
-}
-
-- (void)dealloc
-{
-    if(NULL != ctx) {
-        [ctx release];
-    }
-    if(NULL != fmt) {
-        [fmt release];
-    }
-    if(NULL != nsView) {
-        [nsView release];
-    }
-    DBG_PRINT("MyNSOpenGLLayer::dealloc %p\n", self);
-    [super dealloc];
-}
-
-- (void) setOpenGLContext: (NSOpenGLContext*) _ctx
-{
-    DBG_PRINT("MyNSOpenGLLayer::setOpenGLContext: %p %p -> %p (ignored)\n", self, ctx, _ctx);
-}
-
-- (NSOpenGLContext *) openGLContext
-{
-    return ctx;
-}
-
-- (void) setOpenGLPixelFormat: (NSOpenGLPixelFormat*) pfmt
-{
-    DBG_PRINT("MyNSOpenGLLayer::setOpenGLPixelFormat %p %p\n", self, pfmt);
-}
-
-- (NSOpenGLPixelFormat *) openGLPixelFormat
-{
-    return fmt;
-}
-
-- (void) setView: (NSView*) v
-{
-    DBG_PRINT("MyNSOpenGLLayer::setView %p %p\n", self, v);
-    nsView = v;
-    [super setView: nsView]; // propagate
-}
-
-- (NSView *) view
-{
-    return nsView;
-}
-
-- (NSOpenGLPixelFormat *)openGLPixelFormatForDisplayMask:(uint32_t)mask
-{
-    DBG_PRINT("MyNSOpenGLLayer::openGLPixelFormatForDisplayMask %p %d\n", self, mask);
-    return fmt;
-}
-
-- (NSOpenGLContext *)openGLContextForPixelFormat:(NSOpenGLPixelFormat *)pixelFormat
-{
-    DBG_PRINT("MyNSOpenGLLayer::openGLContextForPixelFormat %p %p\n", self, pixelFormat);
-    return ctx;
-}
-
-- (BOOL)canDrawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
-        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
-{
-    DBG_PRINT("MyNSOpenGLLayer::canDrawInOpenGLContext %p: %d\n", self, self->shallDraw);
-    return self->shallDraw;
-}
-
-- (void)drawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
-        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
-{
-    self->shallDraw = NO;
-    DBG_PRINT("MyNSOpenGLLayer::drawInOpenGLContext %p, ctx %p, pfmt %p\n", self, context, pixelFormat);
-    [super drawInOpenGLContext: context pixelFormat: pixelFormat forLayerTime: timeInterval displayTime: timeStamp];
-}
-
-@end
-
-NSOpenGLLayer* createNSOpenGLLayer(NSOpenGLContext* ctx, NSOpenGLPixelFormat* fmt, NSView* view, Bool opaque) {
-  return [[MyNSOpenGLLayer alloc] initWithContext:ctx pixelFormat: fmt view: view opaque: opaque];
-}
-
-void setNSOpenGLLayerNeedsDisplay(NSOpenGLLayer* glLayer) {
-  NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-  MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) glLayer;
-  l->shallDraw = YES;
-  // [l setNeedsDisplay];
-  [l performSelectorOnMainThread:@selector(setNeedsDisplay) withObject:nil waitUntilDone:YES];
-  DBG_PRINT("MyNSOpenGLLayer::setNSOpenGLLayerNeedsDisplay %p\n", l);
-  [pool release];
-}
-
-void releaseNSOpenGLLayer(NSOpenGLLayer* glLayer) {
+void setContextTextureImageToPBuffer(NSOpenGLContext* ctx, NSOpenGLPixelBuffer* pBuffer, GLenum colorBuffer) {
   NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-  MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) glLayer;
-  [l release];
+  [ctx setTextureImageToPixelBuffer: pBuffer colorBuffer: colorBuffer];
   [pool release];
 }