Seamless Integration of an FBObject based GLFBODrawable as GLOffscreenAutoDrawable.FBO and as an OffscreenLayerSurface's drawable (OSX) - Fix Bugs 569 and 599

Summary:
=========
The new FBObject based GLFBODrawable implementation allows the seamless utilization of
FBO offscreen rendering in single buffer, double buffer and MSAA mode.

The GLFBODrawable uses a parent drawable based on a
dummy surface to allow a GLOffscreenAutoDrawable.FBO creation
or a mutable surface supporting an existing offscreen layer surface (OSX CALayer).

Offscreen GLDrawable's and GLOffscreenAutoDrawable's can be selected via the
GLCapabilities. If simply !onscreen is selected in the caps instance w/o enabling FBO, PBuffer or Bitmap,
the factory will automatically choose regarding availability:
   FBO > PBuffer > Bitmap

Double buffering is supported in MSAA more (intrinsic) and explicit in non MSAA.
It is preferred when delivering resources (texture id's or framebuffer names)
to a shared GLContext.
This is demonstrated in (emulates our OSX CALayer implementation):
  TestFBOOffThreadSharedContextMix2DemosES2NEWT,
  TestFBOOnThreadSharedContext1DemoES2NEWT
and with the OSX JAWT OffscreenLayerSurface itself. FBO is the preferred choice.

+++

Offscreen drawables can be resized while maintaining a bound GLContext (e.g. w/ GLAutoDrawable).
Previously both, drawable and context, needed to be destroyed and recreated at offscreen resize.
Common implementation in GLDrawableHelper is used in the implementations
(NEWT's GLWindow, AWT GLCanvas, SWT GLCanvas).

+++

Tested:
=======

Manually run all unit tests on:
  - Linux x86_64 NVidia/AMD/Mesa3d(ES)
  - OSX x86_64 NVidia
  - Windows x86_64 NVidia
  - Android arm Mali-400/Tegra-2

No regressions.

Disclaimer:
===========
This feature is committed almost in one patch.

Both previous commits were introducing / fixing the capabilities behavior:
 90d45928186f2be99999461cfe45f76a783cc961
 9036376b7806a5fc61590bf49404eb71830de92f

I have to appologize for the huge size and impact (files and platforms) of this commit
however, I could not find a better way to inject this feature in one sane piece.

NativeWindow Details:
=====================

Complete decoupling of platform impl. detail of surfaces
implementing ProxySurface. Used to generalize dummy surfaces and EGL surfaces
on top of a native platform surface.
  - ProxySurface.UpstreamSurfaceHook -> UpstreamSurfaceHook
  - abstract class ProxySurface -> interface ProxySurface + ProxySurfaceImpl
  - Misc. implementations

JOGL Details:
=====================

FBOObject: API Change / Simplification & Usability
  - Removed reference counter to remove complexity, allow user to choose.
  - Add 'dispose' flag for detachColorbuffer(..), allowing to keep attachment alive
  - Fix equals operation of Attachment
  - Check pre-exising GL errors
  - Interface Colobuffer gets lifecycle methods
  - Add static factory methods to create Attachments w/o FBObject instance
  - Reset:
    - Clip min size to 1
    - Keep alive samplingSink, i.e. don't issue resetMSAATexture2DSink(..).
      It gets called at syncFramebuffer()/use(..) later on before actual usage.
      This allows the consumer to utilize the GL_FRONT buffer until (e.g.) swap.
  - misc bugfixes

GLOffscreenAutoDrawable: API Change
  - Reloc and interfacing
  - class com.jogamp.opengl.OffscreenAutoDrawable -> javax.media.opengl.*
    interfaces GLOffscreenAutoDrawable extends GLAutoDrawable
               GLOffscreenAutoDrawable.FBO extends GLOffscreenAutoDrawable, GLFBODrawable
  - Added general implementation and FBO specialization
  - Replacing GLPBuffer (deprecated) .. usable for any offscreen GLDrawable via factory

GLAutoDrawable:
  - Add 'GLDrawable getDelegatedDrawable()'
  - Refine documentation of setContext(..), remove disclaimer and fixme tags

GLDrawableFactory:
  - Refine API doc and it's selection mechanism for offscreen.
  - Add createOffscreenDrawable(..)
  - Add createOffscreenAutoDrawable(..)
  - Add canCreateFBO(..)
  - Mark createGLPbuffer(..) deprectated

Mark GLPBuffer deprecated

New: GLFBODrawable extends GLDrawable

GLCanvas (AWT and SWT): Add offscreen resize support w/o GLContext recreation

GLAutoDrawableBase .. GLWindow:
  - Add offscreen resize support w/o GLContext recreation
  - Remove double swapBuffer call
  -

GLBase/GLContext:
  - Add:
    - boolean hasBasicFBOSupport()
    - boolean hasFullFBOSupport()
    - int getMaxRenderbufferSamples()
    - boolean isTextureFormatBGRA8888Available()

GLContext: Fix version detection and hasGLSL()
  - Version detection in setGLFunctionAvailability(..)
    - Query GL_VERSION ASAP and parse it and compare w/ given major/minor
    - Use parsed version if valid and lower than given _or_ given is invalid.
    - Use validated version for caching (procaddr, ..), version number, etc.

  - Fix hasGLSL()
    Since 'isGL2ES2()' is true if 'isGL2()'
    and the latter simply alows GL 1.*, we confine the result to a GL >= 2.0
    on desktops. FIXME: May consider GL 1.5 w/ extensions.
    -  return isGL2ES2();
    +      return isGLES2() ||
    +             isGL3() ||
    +             isGL2() && ctxMajorVersion>1 ;

GLDrawableImpl:
  - Add 'associateContext(GLContext, boolean)' allowing impl.
    to have a (weak) reference list of bound context.
    This is was pulled up from the OSX specific drawable impl.
  - swapBuffersImpl() -> swapBuffersImpl(boolean doubleBuffered)
    and call it regardless of single buffering.
    This is required to propagate this event to impl. properly,
    i.e. FBODrawable requires a swap notification.
  - Clarify 'contextMadeCurrent(..)' protocol

GLDrawableHelper:
  - Add resize and recreate offscreen drawable util method
  - Simplify required init/reshape calls for GLEventListener
  -

GLGraphicsConfigurationUtil:
  - fixWinAttribBitsAndHwAccel: Reflect sharede context hw-accel bits
  - OSX has no offscreen bitmap, use pbuffer
  - use proper offscreen auto selection if offscreen and no modes are set

EGL Context/Drawable/DrawableFactory: Abstract native platform code out of base classes
  - Use EGLWrappedSurface w/ UpstreamSurfaceHook to handle upstream (X11, WGL, ..)
    lifecycle - in case the EGL resource is hooked up on it.

Invisible dummy surfaces: All platforms
  - size is now reduced to 64x64 and decoupled of actual generic mutable size
  - fix device  lifecycle, no more leaks

+++

OSX
====

Enable support for GLFBODrawableImpl in offscreen CALayer mode
  - NSOpenGLImpl: hooks to calayer native code
  - calayer code:
    - allows pbuffer and texures (FBO)
    - decouple size and draw calls avoiding flickering
    - enable auto resize of calayer tree

MacOSXCGLContext:
  - NSOpenGLImpl:
  - Fix false pbuffer 'usage', validate the pointer
  - If !pbuffer, copy other window mode bits of caps
  -

MacOSXCGLGraphicsConfiguration:
  - Only assume pbuffer if !onscreen
  - Remove reference of native pixelformat pointer

Native code:
  - use 'respondsToSelector:' query before calling 'new' methods
    avoiding an error message where unsuported (prev. OSX versions)
  - if monitor refresh-rate is queried 0, set to default 60hz
  - add missing NSAutoreleasePool decoration

+++

Android / NEWT:
===============

Issue setVisible(..) w/o wait, i.e. queue on EDT,
@Android surfaceChanged() callback. Otherwise we could deadlock:
   setVisible(..) -> EDT -> setVisibleImpl(..) -> 'GL-display'.
the latter may may cause havoc while Android-EDT is blocked [until it's return].

1 files changed, 0 insertions, 494 deletions

diff --git a/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m b/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m
deleted file mode 100644
index b81b43e54..000000000
--- a/src/jogl/native/macosx/MacOSXWindowSystemInterface-pbuffer.m
+++ /dev/null
@@ -1,494 +0,0 @@
-#import "MacOSXWindowSystemInterface.h"
-#import <QuartzCore/QuartzCore.h>
-#import <pthread.h>
-#include "timespec.h"
-
-// 
-// CADisplayLink only available on iOS >= 3.1, sad, since it's convenient.
-// Use CVDisplayLink otherwise.
-//
-// #define HAS_CADisplayLink 1
-//
-
-// lock/sync debug output
-//
-// #define DBG_SYNC 1
-//
-#ifdef DBG_SYNC
-    // #define SYNC_PRINT(...) NSLog(@ ## __VA_ARGS__)
-    #define SYNC_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
-#else
-    #define SYNC_PRINT(...)
-#endif
-
-// fps debug output
-//
-// #define DBG_PERF 1
-
-@interface MyNSOpenGLLayer: NSOpenGLLayer
-{
-@protected
-    NSOpenGLPixelBuffer* pbuffer;
-    int texWidth;
-    int texHeight;
-    GLuint textureID;
-#ifdef HAS_CADisplayLink
-    CADisplayLink* displayLink;
-#else
-    CVDisplayLinkRef displayLink;
-#endif
-    int tc;
-    struct timespec t0;
-@public
-    struct timespec lastWaitTime;
-    GLint swapInterval;
-    GLint swapIntervalCounter;
-    pthread_mutex_t renderLock;
-    pthread_cond_t renderSignal;
-    BOOL shallDraw;
-}
-
-- (id) setupWithContext: (NSOpenGLContext*) ctx
-       pixelFormat: (NSOpenGLPixelFormat*) pfmt
-       pbuffer: (NSOpenGLPixelBuffer*) p
-       opaque: (Bool) opaque
-       texWidth: (int) texWidth 
-       texHeight: (int) texHeight;
-
-- (void)deallocTex;
-- (void)disableAnimation;
-- (void)releaseLayer;
-- (void)dealloc;
-- (int)getSwapInterval;
-- (void)setSwapInterval:(int)interval;
-- (void)tick;
-
-@end
-
-#ifndef HAS_CADisplayLink
-
-static CVReturn renderMyNSOpenGLLayer(CVDisplayLinkRef displayLink, 
-                                      const CVTimeStamp *inNow, 
-                                      const CVTimeStamp *inOutputTime, 
-                                      CVOptionFlags flagsIn, 
-                                      CVOptionFlags *flagsOut, 
-                                      void *displayLinkContext)
-{
-    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-    MyNSOpenGLLayer* l = (MyNSOpenGLLayer*)displayLinkContext;
-    pthread_mutex_lock(&l->renderLock);
-    #ifdef DBG_PERF
-        [l tick];
-    #endif
-    if(0 < l->swapInterval) {
-        l->swapIntervalCounter++;
-        if(l->swapIntervalCounter>=l->swapInterval) {
-            l->swapIntervalCounter = 0;
-            pthread_cond_signal(&l->renderSignal);
-            SYNC_PRINT("S");
-        }
-    }
-    pthread_mutex_unlock(&l->renderLock);
-    [pool release];
-    return kCVReturnSuccess;
-}
-
-#endif
-
-@implementation MyNSOpenGLLayer
-
-- (id) setupWithContext: (NSOpenGLContext*) _ctx
-       pixelFormat: (NSOpenGLPixelFormat*) _fmt
-       pbuffer: (NSOpenGLPixelBuffer*) p
-       opaque: (Bool) opaque
-       texWidth: (int) _texWidth 
-       texHeight: (int) _texHeight;
-{
-    pthread_mutexattr_t renderLockAttr;
-    pthread_mutexattr_init(&renderLockAttr);
-    pthread_mutexattr_settype(&renderLockAttr, PTHREAD_MUTEX_RECURSIVE);
-    pthread_mutex_init(&renderLock, &renderLockAttr); // recursive
-    pthread_cond_init(&renderSignal, NULL); // no attribute
-
-    textureID = 0;
-    swapInterval = 1; // defaults to on (as w/ new GL profiles)
-    swapIntervalCounter = 0;
-    timespec_now(&lastWaitTime);
-    shallDraw = NO;
-    texWidth = _texWidth;
-    texHeight = _texHeight;
-    pbuffer = p;
-    [pbuffer retain];
-
-    {
-        CGRect lRect = CGRectMake(0, 0, texWidth, texHeight);
-        [self setFrame:lRect];
-
-        // no animations for add/remove/swap sublayers etc 
-        // doesn't work: [self removeAnimationForKey: kCAOnOrderIn, kCAOnOrderOut, kCATransition]
-        [self removeAllAnimations];
-    }
-
-    // instantiate a deactivated displayLink
-#ifdef HAS_CADisplayLink
-    displayLink = [[CVDisplayLink displayLinkWithTarget:self selector:@selector(setNeedsDisplay)] retain];
-    [displayLink setPaused: YES];
-#else
-    CVReturn cvres;
-    {
-        int allDisplaysMask = 0;
-        int virtualScreen, accelerated, displayMask;
-        for (virtualScreen = 0; virtualScreen < [_fmt  numberOfVirtualScreens]; virtualScreen++) {
-            [_fmt getValues:&displayMask forAttribute:NSOpenGLPFAScreenMask forVirtualScreen:virtualScreen];
-            [_fmt getValues:&accelerated forAttribute:NSOpenGLPFAAccelerated forVirtualScreen:virtualScreen];
-            if (accelerated) {
-                allDisplaysMask |= displayMask;
-            }
-        }
-        cvres = CVDisplayLinkCreateWithOpenGLDisplayMask(allDisplaysMask, &displayLink);
-        if(kCVReturnSuccess != cvres) {
-            DBG_PRINT("MyNSOpenGLLayer::init %p, CVDisplayLinkCreateWithOpenGLDisplayMask %X failed: %d\n", self, allDisplaysMask, cvres);
-            displayLink = NULL;
-        }
-    }
-    if(NULL != displayLink) {
-        cvres = CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(displayLink, [_ctx CGLContextObj], [_fmt CGLPixelFormatObj]);
-        if(kCVReturnSuccess != cvres) {
-            DBG_PRINT("MyNSOpenGLLayer::init %p, CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext failed: %d\n", self, cvres);
-            displayLink = NULL;
-        }
-    }
-    if(NULL != displayLink) {
-        cvres = CVDisplayLinkSetOutputCallback(displayLink, renderMyNSOpenGLLayer, self);
-        if(kCVReturnSuccess != cvres) {
-            DBG_PRINT("MyNSOpenGLLayer::init %p, CVDisplayLinkSetOutputCallback failed: %d\n", self, cvres);
-            displayLink = NULL;
-        }
-    }
-    if(NULL != displayLink) {
-        CVDisplayLinkStop(displayLink);
-    }
-#endif
-    [self setAsynchronous: YES];
-
-    [self setNeedsDisplayOnBoundsChange: YES];
-
-    [self setOpaque: opaque ? YES : NO];
-
-    CGRect lRect = [self frame];
-    DBG_PRINT("MyNSOpenGLLayer::init %p, ctx %p, pfmt %p, pbuffer %p, opaque %d, pbuffer %dx%d -> tex %dx%d, frame: %lf/%lf %lfx%lf (refcnt %d)\n", 
-        self, _ctx, _fmt, pbuffer, opaque, [pbuffer pixelsWide], [pbuffer pixelsHigh], texWidth, texHeight,
-        lRect.origin.x, lRect.origin.y, lRect.size.width, lRect.size.height, (int)[self retainCount]);
-    return self;
-}
-
-- (void)disableAnimation
-{
-    DBG_PRINT("MyNSOpenGLLayer::disableAnimation: %p (refcnt %d) - displayLink %p\n", self, (int)[self retainCount], displayLink);
-    pthread_mutex_lock(&renderLock);
-    [self setAsynchronous: NO];
-    if(NULL != displayLink) {
-#ifdef HAS_CADisplayLink
-        [displayLink setPaused: YES];
-        [displayLink release];
-#else
-        CVDisplayLinkStop(displayLink);
-        CVDisplayLinkRelease(displayLink);
-#endif
-        displayLink = NULL;
-    }
-    pthread_mutex_unlock(&renderLock);
-}
-
-- (void)deallocTex
-{
-    pthread_mutex_lock(&renderLock);
-    NSOpenGLContext* context = [self openGLContext];
-    DBG_PRINT("MyNSOpenGLLayer::deallocTex %p (refcnt %d) - context %p, pbuffer %p\n", self, (int)[self retainCount], context, pbuffer);
-    if(NULL != pbuffer) {
-        if(NULL!=context) {
-            [context makeCurrentContext];
-            if(0 != textureID) {
-                glDeleteTextures(1, &textureID);
-                textureID = 0;
-            }
-            [context clearDrawable];
-        }
-        [pbuffer release];
-        pbuffer = NULL;
-    }
-    pthread_mutex_unlock(&renderLock);
-}
-
-- (void)releaseLayer
-{
-    DBG_PRINT("MyNSOpenGLLayer::releaseLayer.0: %p (refcnt %d)\n", self, (int)[self retainCount]);
-    pthread_mutex_lock(&renderLock);
-    [self disableAnimation];
-    [self deallocTex];
-    [self release];
-    DBG_PRINT("MyNSOpenGLLayer::releaseLayer.X: %p (refcnt %d)\n", self, (int)[self retainCount]);
-    pthread_mutex_unlock(&renderLock);
-}
-
-- (void)dealloc
-{
-    DBG_PRINT("MyNSOpenGLLayer::dealloc.0 %p (refcnt %d)\n", self, (int)[self retainCount]);
-    // NSLog(@"MyNSOpenGLLayer::dealloc: %@",[NSThread callStackSymbols]);
-
-    [self disableAnimation];
-    [self deallocTex];
-    pthread_cond_destroy(&renderSignal);
-    pthread_mutex_destroy(&renderLock);
-    [super dealloc];
-    DBG_PRINT("MyNSOpenGLLayer::dealloc.X %p\n", self);
-}
-
-- (BOOL)canDrawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
-        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
-{
-    // assume both methods 'canDrawInOpenGLContext' and 'drawInOpenGLContext' 
-    // are called from the same thread subsequently
-    pthread_mutex_lock(&renderLock);
-    Bool res = NULL != pbuffer && YES == shallDraw;
-    if(!res) {
-        SYNC_PRINT("0");
-        pthread_mutex_unlock(&renderLock);
-    } else {
-        SYNC_PRINT("1");
-    }
-    return res;
-}
-
-- (void)drawInOpenGLContext:(NSOpenGLContext *)context pixelFormat:(NSOpenGLPixelFormat *)pixelFormat 
-        forLayerTime:(CFTimeInterval)timeInterval displayTime:(const CVTimeStamp *)timeStamp
-{
-    [context makeCurrentContext];
-   
-    GLenum textureTarget = [pbuffer textureTarget];
-    GLfloat texCoordWidth, texCoordHeight;
-    {
-        GLsizei pwidth = [pbuffer pixelsWide];
-        GLsizei pheight = [pbuffer pixelsHigh];
-        texCoordWidth  = textureTarget == GL_TEXTURE_2D ? (GLfloat)pwidth /(GLfloat)texWidth  : pwidth;
-        texCoordHeight = textureTarget == GL_TEXTURE_2D ? (GLfloat)pheight/(GLfloat)texHeight : pheight;
-    }
-    Bool texCreated = 0 == textureID;
-   
-    if(texCreated) {
-        glGenTextures(1, &textureID);
-
-        CGRect lRect = [self frame];
-        DBG_PRINT("MyNSOpenGLLayer::drawInOpenGLContext %p, pbuffer %p %dx%d -> tex %dx%d [%fx%f] id 0x%X target 0x%X, frame: %lf/%lf %lfx%lf (refcnt %d)\n", 
-            self, pbuffer, [pbuffer pixelsWide], [pbuffer pixelsHigh], texWidth, texHeight, texCoordWidth, texCoordHeight, textureID, textureTarget,
-            lRect.origin.x, lRect.origin.y, lRect.size.width, lRect.size.height, (int)[self retainCount]);
-    }
-
-    glBindTexture(textureTarget, textureID);
-
-    /**
-    if(texCreated) {
-      // proper tex size setup
-      glTexImage2D(textureTarget, 0, GL_RGB, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-    } */
-
-    [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,           texCoordHeight,
-     texCoordWidth, texCoordHeight,
-     texCoordWidth, 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);
-    glBindTexture(textureTarget, 0);
-   
-    [super drawInOpenGLContext: context pixelFormat: pixelFormat forLayerTime: timeInterval displayTime: timeStamp];
-    shallDraw = NO;
-    if(0 >= swapInterval) {
-        pthread_cond_signal(&renderSignal); // just to wake up
-        SYNC_PRINT("s");
-    }
-    SYNC_PRINT("$");
-    pthread_mutex_unlock(&renderLock);
-}
-
-- (int)getSwapInterval
-{
-    return swapInterval;
-}
-
-- (void)setSwapInterval:(int)interval
-{
-    /**
-     * v-sync doesn't works w/ NSOpenGLLayer's context .. well :(
-     * Using CVDisplayLink .. see setSwapInterval() below.
-     *
-        GLint si;
-        [context getValues: &si forParameter: NSOpenGLCPSwapInterval];
-        if(si != swapInterval) {
-            DBG_PRINT("MyNSOpenGLLayer::drawInOpenGLContext %p setSwapInterval: %d -> %d\n", self, si, swapInterval);
-            [context setValues: &swapInterval forParameter: NSOpenGLCPSwapInterval];
-        }
-    } */
-
-    pthread_mutex_lock(&renderLock);
-    DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.0: %d - displayLink %p\n", interval, displayLink);
-    swapInterval = interval;
-    swapIntervalCounter = 0;
-    pthread_mutex_unlock(&renderLock);
-
-    if(NULL!=displayLink) {
-        if(0 < swapInterval) {
-            tc = 0;
-            timespec_now(&t0);
-
-            [self setAsynchronous: NO];
-            #ifdef HAS_CADisplayLink
-                [displayLink setPaused: NO];
-                [displayLink setFrameInterval: interval];
-            #else
-                DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.1.b.1\n");
-                CVDisplayLinkStart(displayLink);
-                DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.1.b.X\n");
-            #endif
-        } else {
-            #ifdef HAS_CADisplayLink
-                [displayLink setPaused: YES];
-            #else
-                DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.0.b.1\n");
-                CVDisplayLinkStop(displayLink);
-                DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.0.b.X\n");
-            #endif
-            [self setAsynchronous: YES];
-        }
-    }
-    DBG_PRINT("MyNSOpenGLLayer::setSwapInterval.X: %d\n", interval);
-}
-
--(void)tick
-{
-    tc++;
-    if(tc%60==0) {
-        struct timespec t1, td;
-        timespec_now(&t1);
-        timespec_subtract(&td, &t1, &t0);
-        long td_ms = timespec_milliseconds(&td);
-        fprintf(stderr, "NSOpenGLLayer: %ld ms / %d frames, %ld ms / frame, %f fps\n",
-            td_ms, tc, td_ms/tc, (tc * 1000.0) / (float)td_ms );
-        fflush(NULL);
-    }
-}
-
-@end
-
-NSOpenGLLayer* createNSOpenGLLayer(NSOpenGLContext* ctx, NSOpenGLPixelFormat* fmt, NSOpenGLPixelBuffer* p, Bool opaque, int texWidth, int texHeight) {
-  // This simply crashes after dealloc() has been called .. ie. ref-count -> 0 too early ?
-  // However using alloc/init, actual dealloc happens at JAWT destruction, hence too later IMHO.
-  // return [[MyNSOpenGLLayer layer] setupWithContext:ctx pixelFormat: fmt pbuffer: p opaque: opaque texWidth: texWidth texHeight: texHeight];
-
-  return [[[MyNSOpenGLLayer alloc] init] setupWithContext:ctx pixelFormat: fmt pbuffer: p opaque: opaque texWidth: texWidth texHeight: texHeight];
-}
-
-void setNSOpenGLLayerSwapInterval(NSOpenGLLayer* layer, int interval) {
-  MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
-  [l setSwapInterval: interval];
-}
-
-void waitUntilNSOpenGLLayerIsReady(NSOpenGLLayer* layer, long to_micros) {
-    MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
-    BOOL ready = NO;
-    int wr = 0;
-    pthread_mutex_lock(&l->renderLock);
-    SYNC_PRINT("{");
-    do {
-        if([l getSwapInterval] <= 0) {
-            ready = !l->shallDraw;
-        }
-        if(NO == ready) {
-            if(0 < to_micros) {
-                #ifdef DBG_SYNC
-                    struct timespec t0, t1, td, td2;
-                    timespec_now(&t0);
-                #endif
-                struct timespec to_abs = l->lastWaitTime;
-                timespec_addmicros(&to_abs, to_micros);
-                #ifdef DBG_SYNC
-                    timespec_subtract(&td, &to_abs, &t0);
-                    fprintf(stderr, "(%ld) / ", timespec_milliseconds(&td));
-                #endif
-                wr = pthread_cond_timedwait(&l->renderSignal, &l->renderLock, &to_abs);
-                #ifdef DBG_SYNC
-                    timespec_now(&t1);
-                    timespec_subtract(&td, &t1, &t0);
-                    timespec_subtract(&td2, &t1, &l->lastWaitTime);
-                    fprintf(stderr, "(%ld) / (%ld) ms", timespec_milliseconds(&td), timespec_milliseconds(&td2));
-                #endif
-            } else {
-                pthread_cond_wait (&l->renderSignal, &l->renderLock);
-            }
-            ready = !l->shallDraw;
-        }
-    } while (NO == ready && 0 == wr) ;
-    SYNC_PRINT("-%d}", ready);
-    timespec_now(&l->lastWaitTime);
-    pthread_mutex_unlock(&l->renderLock);
-}
-
-void setNSOpenGLLayerNeedsDisplay(NSOpenGLLayer* layer) {
-    MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
-    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-    pthread_mutex_lock(&l->renderLock);
-    l->shallDraw = YES;
-    if ( [NSThread isMainThread] == YES ) {
-      [l setNeedsDisplay];
-    } else {
-      // can't wait, otherwise we may deadlock AWT
-      [l performSelectorOnMainThread:@selector(setNeedsDisplay) withObject:nil waitUntilDone:NO];
-    }
-    SYNC_PRINT(".");
-    pthread_mutex_unlock(&l->renderLock);
-    // DBG_PRINT("MyNSOpenGLLayer::setNSOpenGLLayerNeedsDisplay %p\n", l);
-    [pool release];
-}
-
-void releaseNSOpenGLLayer(NSOpenGLLayer* layer) {
-    MyNSOpenGLLayer* l = (MyNSOpenGLLayer*) layer;
-    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-    DBG_PRINT("MyNSOpenGLLayer::releaseNSOpenGLLayer.0: %p\n", l);
-
-    if ( [NSThread isMainThread] == YES ) {
-        [l releaseLayer];
-    } else { 
-        [l performSelectorOnMainThread:@selector(releaseLayer) withObject:nil waitUntilDone:NO];
-    }
-
-    DBG_PRINT("MyNSOpenGLLayer::releaseNSOpenGLLayer.X: %p\n", l);
-    [pool release];
-}
-