iOS: Initial working commit supporting iOS (ipad pro 11)

using our OpenJFK 9 x86_64 and arm64 build.

Test demo class is 'com.jogamp.opengl.demos.ios.Hello',
residing in the new demo folder 'src/demos/com/jogamp/opengl/demos/ios/Hello.java'.

This commit does not yet include a working NEWT
specialization for iOS, but it shall followup soon.

Instead this commit demonstrates JOGL operating on
native UIWindow, UIView and CAEAGLLayer as provided by
Nativewindow's IOSUtil.

Test Video https://www.youtube.com/watch?v=Z4lUQNFTGMI

+++

Notable bug: The FBO used and sharing the COLORBUFFER RENDERBUFFER
memory resources with CAEAGLLayer to be displayed in the UIView
seemingly cannot handle GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24
or GL_DEPTH_COMPONENT32 depth buffer - none at all (Device + Simulation).

Therefor the default demo GLEventListener chosen here
don't require a depth buffer ;-)

This issue can hopefully be mitigated with other means
than using a flat FBO sink similar to FBO multisampling.

1 files changed, 74 insertions, 3 deletions

diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
index dfe6bdd9f..2e108d3ce 100644
--- a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
+++ b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
@@ -68,12 +68,16 @@ import com.jogamp.opengl.GLOffscreenAutoDrawable;
 import com.jogamp.opengl.GLProfile;
 
 import com.jogamp.common.ExceptionUtils;
+import com.jogamp.common.os.Platform;
 import com.jogamp.nativewindow.MutableGraphicsConfiguration;
 import com.jogamp.nativewindow.DelegatedUpstreamSurfaceHookWithSurfaceSize;
+import com.jogamp.nativewindow.GenericUpstreamSurfacelessHook;
 import com.jogamp.nativewindow.UpstreamSurfaceHookMutableSize;
 import com.jogamp.opengl.GLAutoDrawableDelegate;
 import com.jogamp.opengl.GLRendererQuirks;
 
+import jogamp.common.os.PlatformPropsImpl;
+
 
 /** Extends GLDrawableFactory with a few methods for handling
     typically software-accelerated offscreen rendering (Device
@@ -275,8 +279,18 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
     GLDrawable result = null;
     adevice.lock();
     try {
+        final boolean forceOnscreenFBOLayer;
+        final boolean useFBORendertarget;
+        if( chosenCaps.isOnscreen() && Platform.OSType.IOS == PlatformPropsImpl.OS_TYPE )  // FIXME: avoid hardcoding?
+        {
+            forceOnscreenFBOLayer = true;
+            useFBORendertarget = true;
+        } else {
+            forceOnscreenFBOLayer = false;
+            useFBORendertarget = false;
+        }
         final OffscreenLayerSurface ols = NativeWindowFactory.getOffscreenLayerSurface(target, true);
-        if(null != ols) {
+        if(null != ols || forceOnscreenFBOLayer ) {
             final GLCapabilitiesImmutable chosenCapsMod = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(chosenCaps, this, adevice);
 
             // layered surface -> Offscreen/[FBO|PBuffer]
@@ -284,12 +298,15 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
                 throw new GLException("Neither FBO nor Pbuffer is available for "+chosenCapsMod+", "+target);
             }
             config.setChosenCapabilities(chosenCapsMod);
-            ols.setChosenCapabilities(chosenCapsMod);
+            if( null != ols ) {
+                ols.setChosenCapabilities(chosenCapsMod);
+            }
             if(DEBUG) {
                 System.err.println("GLDrawableFactoryImpl.createGLDrawable -> OnscreenDrawable -> Offscreen-Layer");
                 System.err.println("chosenCaps:    "+chosenCaps);
                 System.err.println("chosenCapsMod: "+chosenCapsMod);
                 System.err.println("OffscreenLayerSurface: **** "+ols);
+                System.err.println("forceOnscreenFBOLayer: **** "+forceOnscreenFBOLayer+", useFBORendertarget "+useFBORendertarget);
                 System.err.println("Target: **** "+target);
                 ExceptionUtils.dumpStack(System.err);
             }
@@ -297,7 +314,7 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
                 throw new IllegalArgumentException("Passed NativeSurface must implement SurfaceChangeable for offscreen layered surface: "+target);
             }
             if( chosenCapsMod.isFBO() ) {
-                result = createFBODrawableImpl(target, chosenCapsMod, 0);
+                result = createFBODrawableImpl(target, chosenCapsMod, useFBORendertarget?-1:0);
             } else {
                 result = createOffscreenDrawableImpl(target);
             }
@@ -433,6 +450,60 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
                                                                  new UpstreamSurfaceHookMutableSize(width, height) ) );
   }
 
+  /**
+   * Quick path to produce a Surfaceless resizable FBO Drawable.
+   * <p>
+   * Caller has to be sure Surfaceless context as well as FBO is supported
+   * on the platform, no checks will be made.
+   * </p>
+   * @param device2Use actual device to be used
+   * @param capsRequested
+   * @param width
+   * @param height
+   */
+  protected final GLFBODrawableImpl createSurfacelessFBODrawable(final AbstractGraphicsDevice device2Use,
+                                                                 final GLCapabilitiesImmutable capsRequested,
+                                                                 final int width, final int height) {
+    if(width<=0 || height<=0) {
+        throw new GLException("initial size must be positive (were (" + width + " x " + height + "))");
+    }
+    final GLCapabilities capsChosen = (GLCapabilities) capsRequested.cloneMutable();
+    {
+        capsChosen.setOnscreen(false);
+        capsChosen.setFBO( true );
+        capsChosen.setPBuffer( false );
+        capsChosen.setBitmap( false );
+    }
+    // final ProxySurface surface = createSurfacelessImpl(device2Use, false, glCapsMin, capsRequested, null, width, height);
+    final GLCapabilitiesImmutable surfaceCaps = GLGraphicsConfigurationUtil.fixOnscreenGLCapabilities(capsRequested);
+    final ProxySurface surface = createMutableSurfaceImpl(device2Use, false /* createNewDevice */, surfaceCaps, capsRequested, null, new GenericUpstreamSurfacelessHook(width, height));
+
+    final GLDrawableImpl dummyDrawable = createOnscreenDrawableImpl(surface);
+    return new GLFBODrawableImpl.ResizeableImpl(this, dummyDrawable, surface, capsChosen, 0);
+  }
+  /**
+   * Quick path to produce a Surfaceless Drawable.
+   * <p>
+   * Caller has to be sure Surfaceless context is supported
+   * on the platform, no checks will be made.
+   * </p>
+   * @param device2Use actual device to be used
+   * @param capsRequested
+   * @param width
+   * @param height
+   */
+  protected final GLDrawableImpl createSurfacelessDrawable(final AbstractGraphicsDevice device2Use,
+                                                              final GLCapabilitiesImmutable capsRequested,
+                                                              final int width, final int height) {
+    if(width<=0 || height<=0) {
+        throw new GLException("initial size must be positive (were (" + width + " x " + height + "))");
+    }
+    // final ProxySurface surface = createSurfacelessImpl(device2Use, false, glCapsMin, capsRequested, null, width, height);
+    final GLCapabilitiesImmutable surfaceCaps = GLGraphicsConfigurationUtil.fixOnscreenGLCapabilities(capsRequested);
+    final ProxySurface surface = createMutableSurfaceImpl(device2Use, false /* createNewDevice */, surfaceCaps, capsRequested, null, new GenericUpstreamSurfacelessHook(width, height));
+    return createOnscreenDrawableImpl(surface);
+  }
+
   @Override
   public final GLDrawable createDummyDrawable(final AbstractGraphicsDevice deviceReq, final boolean createNewDevice, final GLCapabilitiesImmutable capsRequested, final GLCapabilitiesChooser chooser) {
     final AbstractGraphicsDevice device = createNewDevice ? getOrCreateSharedDevice(deviceReq) : deviceReq;