diff options
Diffstat (limited to 'src/jogl/classes/jogamp')
10 files changed, 371 insertions, 215 deletions
diff --git a/src/jogl/classes/jogamp/opengl/GLContextImpl.java b/src/jogl/classes/jogamp/opengl/GLContextImpl.java index 050c619fd..e164dfe44 100644 --- a/src/jogl/classes/jogamp/opengl/GLContextImpl.java +++ b/src/jogl/classes/jogamp/opengl/GLContextImpl.java @@ -46,6 +46,7 @@ import java.util.HashMap; import java.util.Map; import com.jogamp.common.os.DynamicLookupHelper; +import com.jogamp.common.os.Platform; import com.jogamp.common.util.ReflectionUtil; import com.jogamp.common.util.VersionNumber; import com.jogamp.gluegen.runtime.FunctionAddressResolver; @@ -53,6 +54,7 @@ import com.jogamp.gluegen.runtime.ProcAddressTable; import com.jogamp.gluegen.runtime.opengl.GLNameResolver; import com.jogamp.gluegen.runtime.opengl.GLProcAddressResolver; import com.jogamp.opengl.GLExtensions; +import com.jogamp.opengl.GLRendererQuirks; import javax.media.nativewindow.AbstractGraphicsConfiguration; import javax.media.nativewindow.AbstractGraphicsDevice; @@ -162,7 +164,7 @@ public abstract class GLContextImpl extends GLContext { additionalCtxCreationFlags = 0; glRenderer = ""; - glRendererLowerCase = glRenderer; + glRendererLowerCase = glRenderer; if (boundFBOTarget != null) { // <init> boundFBOTarget[0] = 0; // draw @@ -1116,13 +1118,6 @@ public abstract class GLContextImpl extends GLContext { } } - protected final String getGLVersionString() { - return glVersion; - } - protected final String getGLRendererString(boolean lowerCase) { - return lowerCase ? glRendererLowerCase : glRenderer; - } - /** * Sets the OpenGL implementation class and * the cache of which GL functions are available for calling through this @@ -1264,6 +1259,8 @@ public abstract class GLContextImpl extends GLContext { // Set GL Version (complete w/ version string) // setContextVersion(major, minor, ctxProfileBits, true); + + setRendererQuirks(); setDefaultSwapInterval(); @@ -1272,7 +1269,45 @@ public abstract class GLContextImpl extends GLContext { } } - protected static final boolean hasFBOImpl(int major, int ctp, ExtensionAvailabilityCache extCache) { + private final void setRendererQuirks() { + int[] quirks = new int[GLRendererQuirks.COUNT]; + int i = 0; + + // OS related quirks + if( Platform.getOSType() == Platform.OSType.MACOS ) { + final int quirk = GLRendererQuirks.NoOffscreenBitmap; + if(DEBUG) { + System.err.println("Quirk: "+GLRendererQuirks.toString(quirk)+": cause: OS "+Platform.getOSType()); + } + quirks[i++] = quirk; + } else if( Platform.getOSType() == Platform.OSType.WINDOWS ) { + final int quirk = GLRendererQuirks.NoDoubleBufferedBitmap; + if(DEBUG) { + System.err.println("Quirk: "+GLRendererQuirks.toString(quirk)+": cause: OS "+Platform.getOSType()); + } + quirks[i++] = quirk; + } + + // Renderer related quirks, may also involve OS + if( Platform.OSType.ANDROID == Platform.getOSType() && glRendererLowerCase.contains("powervr") ) { + final int quirk = GLRendererQuirks.NoSetSwapInterval; + if(DEBUG) { + System.err.println("Quirk: "+GLRendererQuirks.toString(quirk)+": cause: OS "+Platform.getOSType() + " / Renderer " + glRenderer); + } + quirks[i++] = quirk; + } + if( glRendererLowerCase.contains("intel(r)") && glRendererLowerCase.contains("mesa") ) { + final int quirk = GLRendererQuirks.NoDoubleBufferedPBuffer; + if(DEBUG) { + System.err.println("Quirk: "+GLRendererQuirks.toString(quirk)+": cause: Renderer " + glRenderer); + } + quirks[i++] = quirk; + } + glRendererQuirks = new GLRendererQuirks(quirks, 0, i); + } + + + private static final boolean hasFBOImpl(int major, int ctp, ExtensionAvailabilityCache extCache) { return ( 0 != (ctp & CTX_PROFILE_ES) && major >= 2 ) || // ES >= 2.0 major >= 3 || // any >= 3.0 GL ctx @@ -1288,7 +1323,7 @@ public abstract class GLContextImpl extends GLContext { extCache.isExtensionAvailable(GLExtensions.OES_framebuffer_object) ) ; // OES_framebuffer_object excluded } - protected final void removeCachedVersion(int major, int minor, int ctxProfileBits) { + private final void removeCachedVersion(int major, int minor, int ctxProfileBits) { if(!isCurrentContextHardwareRasterizer()) { ctxProfileBits |= GLContext.CTX_IMPL_ACCEL_SOFT; } diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java index 4f965f620..bd2db1b81 100644 --- a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java +++ b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java @@ -63,6 +63,7 @@ import javax.media.opengl.GLProfile; import com.jogamp.nativewindow.MutableGraphicsConfiguration; import com.jogamp.nativewindow.DelegatedUpstreamSurfaceHookWithSurfaceSize; import com.jogamp.nativewindow.UpstreamSurfaceHookMutableSize; +import com.jogamp.opengl.GLRendererQuirks; /** Extends GLDrawableFactory with a few methods for handling @@ -78,6 +79,15 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory { super(); } + @Override + public GLRendererQuirks getRendererQuirks(AbstractGraphicsDevice device) { + final GLContext ctx = getOrCreateSharedContextImpl(device); + if(null != ctx) { + return ctx.getRendererQuirks(); + } + return null; + } + /** * Returns the shared context mapped to the <code>device</code> {@link AbstractGraphicsDevice#getConnection()}, * either a pre-existing or newly created, or <code>null</code> if creation failed or not supported.<br> @@ -102,24 +112,15 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory { * @param device which {@link javax.media.nativewindow.AbstractGraphicsDevice#getConnection() connection} denotes the shared device to be used, may be <code>null</code> for the platform's default device. */ protected final AbstractGraphicsDevice getOrCreateSharedDevice(AbstractGraphicsDevice device) { - if(null==device) { - device = getDefaultDevice(); - if(null==device) { - throw new InternalError("no default device"); - } - if (GLProfile.DEBUG) { - System.err.println("Info: GLDrawableFactoryImpl.getOrCreateSharedContext: using default device : "+device); - } - } else if( !getIsDeviceCompatible(device) ) { - if (GLProfile.DEBUG) { - System.err.println("Info: GLDrawableFactoryImpl.getOrCreateSharedContext: device not compatible : "+device); - } - return null; + device = validateDevice(device); + if( null != device) { + return getOrCreateSharedDeviceImpl(device); } - return getOrCreateSharedDeviceImpl(device); + return null; } protected abstract AbstractGraphicsDevice getOrCreateSharedDeviceImpl(AbstractGraphicsDevice device); + /** * Returns the GLDynamicLookupHelper * @param profile if EGL/ES, profile <code>1</code> refers to ES1 and <code>2</code> to ES2, @@ -144,12 +145,11 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory { try { final OffscreenLayerSurface ols = NativeWindowFactory.getOffscreenLayerSurface(target, true); if(null != ols) { + final GLCapabilitiesImmutable chosenCapsMod = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(chosenCaps, this, adevice); // layered surface -> Offscreen/[FBO|PBuffer] - final boolean isPbufferAvailable = canCreateGLPbuffer(adevice) ; - if(!isPbufferAvailable && !isFBOAvailable) { - throw new GLException("Neither FBO nor Pbuffer is available for "+target); + if( !chosenCapsMod.isFBO() && !chosenCapsMod.isPBuffer() ) { + throw new GLException("Neither FBO nor Pbuffer is available for "+chosenCapsMod+", "+target); } - final GLCapabilitiesImmutable chosenCapsMod = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(chosenCaps, isFBOAvailable, isPbufferAvailable); config.setChosenCapabilities(chosenCapsMod); ols.setChosenCapabilities(chosenCapsMod); if(DEBUG) { @@ -163,7 +163,7 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory { if( ! ( target instanceof MutableSurface ) ) { throw new IllegalArgumentException("Passed NativeSurface must implement SurfaceChangeable for offscreen layered surface: "+target); } - if( chosenCapsMod.isFBO() && isFBOAvailable ) { + if( chosenCapsMod.isFBO() ) { // target surface is already a native one result = createFBODrawableImpl(target, chosenCapsMod, 0); } else { @@ -294,9 +294,7 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory { throw new GLException("No shared device for requested: "+deviceReq); } - final GLCapabilitiesImmutable capsChosen = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(capsRequested, - GLContext.isFBOAvailable(device, capsRequested.getGLProfile()), - canCreateGLPbuffer(device)); + final GLCapabilitiesImmutable capsChosen = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(capsRequested, this, device); if( capsChosen.isFBO() ) { device.lock(); diff --git a/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java b/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java index 13c95b0dd..31e52b86c 100644 --- a/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java +++ b/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java @@ -32,8 +32,9 @@ import javax.media.nativewindow.AbstractGraphicsDevice; import javax.media.opengl.GLCapabilities; import javax.media.opengl.GLCapabilitiesImmutable; import javax.media.opengl.GLContext; +import javax.media.opengl.GLDrawableFactory; -import com.jogamp.common.os.Platform; +import com.jogamp.opengl.GLRendererQuirks; public class GLGraphicsConfigurationUtil { public static final String NV_coverage_sample = "NV_coverage_sample"; @@ -138,16 +139,25 @@ public class GLGraphicsConfigurationUtil { return caps; } - public static GLCapabilitiesImmutable fixGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean fboAvailable, boolean pbufferAvailable) - { + /** + * Fixes the requested {@link GLCapabilitiesImmutable} according to on- and offscreen usage. + * <p> + * No modification will be made for onscreen usage, for offscreen usage see + * {@link #fixOffscreenGLCapabilities(GLCapabilitiesImmutable, GLDrawableFactory, AbstractGraphicsDevice)}. + * </p> + * @param capsRequested the requested {@link GLCapabilitiesImmutable} + * @param factory the {@link GLDrawableFactory} used to validate the requested capabilities and later used to create the drawable. + * @param device the device on which the drawable will be created, maybe null for the {@link GLDrawableFactory#getDefaultDevice() default device}. + * @return either the given requested {@link GLCapabilitiesImmutable} instance if no modifications were required, or a modified {@link GLCapabilitiesImmutable} instance. + */ + public static GLCapabilitiesImmutable fixGLCapabilities(GLCapabilitiesImmutable capsRequested, + GLDrawableFactory factory, AbstractGraphicsDevice device) { if( !capsRequested.isOnscreen() ) { - return fixOffscreenGLCapabilities(capsRequested, fboAvailable, pbufferAvailable); - } /* we maintain the offscreen mode flags in onscreen mode - else { - return fixOnscreenGLCapabilities(capsRequested); - } */ + return fixOffscreenGLCapabilities(capsRequested, factory, device); + } return capsRequested; } - + public static GLCapabilitiesImmutable fixOnscreenGLCapabilities(GLCapabilitiesImmutable capsRequested) { if( !capsRequested.isOnscreen() || capsRequested.isFBO() || capsRequested.isPBuffer() || capsRequested.isBitmap() ) { @@ -162,25 +172,68 @@ public class GLGraphicsConfigurationUtil { return capsRequested; } - public static boolean isGLCapabilitiesOffscreenAutoSelection(GLCapabilitiesImmutable capsRequested) { - return !capsRequested.isOnscreen() && - !capsRequested.isFBO() && !capsRequested.isPBuffer() && !capsRequested.isBitmap() ; + public static GLCapabilitiesImmutable fixOffscreenBitOnly(GLCapabilitiesImmutable capsRequested) + { + if( capsRequested.isOnscreen() ) { + // fix caps .. + final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable(); + caps2.setOnscreen(false); + return caps2; + } + return capsRequested; } - - public static GLCapabilitiesImmutable fixOffscreenGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean fboAvailable, boolean pbufferAvailable) { - final boolean auto = !capsRequested.isFBO() && !capsRequested.isPBuffer() && !capsRequested.isBitmap() ; - - final boolean requestedPBuffer = capsRequested.isPBuffer() || Platform.getOSType() == Platform.OSType.MACOS ; // no native bitmap for OSX + + /** + * Fixes the requested {@link GLCapabilitiesImmutable} according to: + * <ul> + * <li>offscreen usage</li> + * <li>availability of FBO, PBuffer, Bitmap</li> + * <li>{@link GLRendererQuirks}</li> + * </ul> + * @param capsRequested the requested {@link GLCapabilitiesImmutable} + * @param factory the {@link GLDrawableFactory} used to validate the requested capabilities and later used to create the drawable. + * @param device the device on which the drawable will be created, maybe null for the {@link GLDrawableFactory#getDefaultDevice() default device}. + * @return either the given requested {@link GLCapabilitiesImmutable} instance if no modifications were required, or a modified {@link GLCapabilitiesImmutable} instance. + */ + public static GLCapabilitiesImmutable fixOffscreenGLCapabilities(GLCapabilitiesImmutable capsRequested, + GLDrawableFactory factory, AbstractGraphicsDevice device) { + if(null == device) { + device = factory.getDefaultDevice(); + } + final boolean fboAvailable = GLContext.isFBOAvailable(device, capsRequested.getGLProfile()); + final boolean pbufferAvailable = factory.canCreateGLPbuffer(device); + + final GLRendererQuirks glrq = factory.getRendererQuirks(device); + final boolean bitmapAvailable; + final boolean doubleBufferAvailable; + + if(null != glrq) { + bitmapAvailable = !glrq.exist(GLRendererQuirks.NoOffscreenBitmap); + if( capsRequested.getDoubleBuffered() && + ( capsRequested.isPBuffer() && glrq.exist(GLRendererQuirks.NoDoubleBufferedPBuffer) ) || + ( capsRequested.isBitmap() && glrq.exist(GLRendererQuirks.NoDoubleBufferedBitmap) ) ) { + doubleBufferAvailable = false; + } else { + doubleBufferAvailable = true; + } + } else { + bitmapAvailable = true; + doubleBufferAvailable = true; + } - final boolean useFBO = fboAvailable && ( auto || capsRequested.isFBO() ) ; - final boolean usePbuffer = !useFBO && pbufferAvailable && ( auto || requestedPBuffer ) ; - final boolean useBitmap = !useFBO && !usePbuffer && ( auto || capsRequested.isBitmap() ) ; + final boolean auto = !( fboAvailable && capsRequested.isFBO() ) && + !( pbufferAvailable && capsRequested.isPBuffer() ) && + !( bitmapAvailable && capsRequested.isBitmap() ) ; + + final boolean useFBO = fboAvailable && ( auto || capsRequested.isFBO() ) ; + final boolean usePbuffer = !useFBO && pbufferAvailable && ( auto || capsRequested.isPBuffer() ) ; + final boolean useBitmap = !useFBO && !usePbuffer && bitmapAvailable && ( auto || capsRequested.isBitmap() ) ; if( capsRequested.isOnscreen() || useFBO != capsRequested.isFBO() || usePbuffer != capsRequested.isPBuffer() || useBitmap != capsRequested.isBitmap() || - useBitmap && capsRequested.getDoubleBuffered() ) + !doubleBufferAvailable && capsRequested.getDoubleBuffered() ) { // fix caps .. final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable(); @@ -188,7 +241,7 @@ public class GLGraphicsConfigurationUtil { caps2.setFBO( useFBO ); caps2.setPBuffer( usePbuffer ); caps2.setBitmap( useBitmap ); - if( useBitmap ) { + if( !doubleBufferAvailable ) { caps2.setDoubleBuffered(false); } return caps2; diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLContext.java b/src/jogl/classes/jogamp/opengl/egl/EGLContext.java index 06953a8e1..84aeaa94a 100644 --- a/src/jogl/classes/jogamp/opengl/egl/EGLContext.java +++ b/src/jogl/classes/jogamp/opengl/egl/EGLContext.java @@ -51,9 +51,10 @@ import jogamp.opengl.GLContextImpl; import jogamp.opengl.GLDrawableImpl; import com.jogamp.common.nio.Buffers; -import com.jogamp.common.os.Platform; import com.jogamp.gluegen.runtime.ProcAddressTable; import com.jogamp.gluegen.runtime.opengl.GLProcAddressResolver; +import com.jogamp.nativewindow.egl.EGLGraphicsDevice; +import com.jogamp.opengl.GLRendererQuirks; public abstract class EGLContext extends GLContextImpl { private boolean eglQueryStringInitialized; @@ -269,14 +270,7 @@ public abstract class EGLContext extends GLContextImpl { @Override protected boolean setSwapIntervalImpl(int interval) { - // FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - // eglSwapInterval(..) issued: - // Android 4.0.3 / Pandaboard ES / PowerVR SGX 540: crashes - // FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - if( Platform.OSType.ANDROID == Platform.getOSType() && getGLRendererString(true).contains("powervr") ) { - if(DEBUG) { - System.err.println("Ignored: eglSwapInterval("+interval+") - cause: OS "+Platform.getOSType() + " / Renderer " + getGLRendererString(false)); - } + if( hasRendererQuirk(GLRendererQuirks.NoSetSwapInterval) ) { return false; } return EGL.eglSwapInterval(drawable.getNativeSurface().getDisplayHandle(), interval); @@ -286,20 +280,11 @@ public abstract class EGLContext extends GLContextImpl { // Accessible .. // - /** - * If context is an ES profile, map it to the given device - * via {@link GLContext#mapAvailableGLVersion(AbstractGraphicsDevice, int, int, int, int, int)}. - * <p> - * We intentionally override a non native EGL device ES profile mapping, - * i.e. this will override/modify an already 'set' X11/WGL/.. mapping. - * </p> - * - * @param device - */ - protected void mapCurrentAvailableGLVersion(AbstractGraphicsDevice device) { - mapCurrentAvailableGLVersionImpl(device, ctxMajorVersion, ctxMinorVersion, ctxOptions); - } - protected static void mapStaticGLESVersion(AbstractGraphicsDevice device, GLCapabilitiesImmutable caps) { + /* pp */ void mapCurrentAvailableGLVersion(AbstractGraphicsDevice device) { + mapStaticGLVersion(device, ctxMajorVersion, ctxMinorVersion, ctxOptions); + } + /* pp */ int getContextOptions() { return ctxOptions; } + /* pp */ static void mapStaticGLESVersion(AbstractGraphicsDevice device, GLCapabilitiesImmutable caps) { final GLProfile glp = caps.getGLProfile(); final int[] reqMajorCTP = new int[2]; GLContext.getRequestMajorAndCompat(glp, reqMajorCTP); @@ -309,21 +294,27 @@ public abstract class EGLContext extends GLContextImpl { if(!caps.getHardwareAccelerated()) { reqMajorCTP[1] |= GLContext.CTX_IMPL_ACCEL_SOFT; } - mapCurrentAvailableGLVersionImpl(device, reqMajorCTP[0], 0, reqMajorCTP[1]); - } - protected static void mapStaticGLESVersion(AbstractGraphicsDevice device, int major) { + mapStaticGLVersion(device, reqMajorCTP[0], 0, reqMajorCTP[1]); + } + /* pp */ static void mapStaticGLESVersion(AbstractGraphicsDevice device, int major) { int ctp = ( 2 == major ) ? ( GLContext.CTX_PROFILE_ES | GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ) : ( GLContext.CTX_PROFILE_ES ); - mapCurrentAvailableGLVersionImpl(device, major, 0, ctp); + mapStaticGLVersion(device, major, 0, ctp); } - private static void mapCurrentAvailableGLVersionImpl(AbstractGraphicsDevice device, int major, int minor, int ctp) { + /* pp */ static void mapStaticGLVersion(AbstractGraphicsDevice device, int major, int minor, int ctp) { if( 0 != ( ctp & GLContext.CTX_PROFILE_ES) ) { // ES1 or ES2 final int reqMajor = major; final int reqProfile = GLContext.CTX_PROFILE_ES; - GLContext.mapAvailableGLVersion(device, reqMajor, reqProfile, - major, minor, ctp); + GLContext.mapAvailableGLVersion(device, reqMajor, reqProfile, major, minor, ctp); + if(! ( device instanceof EGLGraphicsDevice ) ) { + final EGLGraphicsDevice eglDevice = new EGLGraphicsDevice(device.getHandle(), EGL.EGL_NO_DISPLAY, device.getConnection(), device.getUnitID(), null); + GLContext.mapAvailableGLVersion(eglDevice, reqMajor, reqProfile, major, minor, ctp); + } } } + protected static String getGLVersion(int major, int minor, int ctp, String gl_version) { + return GLContext.getGLVersion(major, minor, ctp, gl_version); + } protected static boolean getAvailableGLVersionsSet(AbstractGraphicsDevice device) { return GLContext.getAvailableGLVersionsSet(device); diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java index e98d69140..a907c4aff 100644 --- a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java +++ b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java @@ -43,6 +43,7 @@ import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; +import java.util.Set; import javax.media.nativewindow.AbstractGraphicsConfiguration; import javax.media.nativewindow.AbstractGraphicsDevice; @@ -77,11 +78,11 @@ import com.jogamp.common.nio.PointerBuffer; import com.jogamp.common.os.Platform; import com.jogamp.common.util.ReflectionUtil; import com.jogamp.nativewindow.egl.EGLGraphicsDevice; +import com.jogamp.opengl.GLRendererQuirks; public class EGLDrawableFactory extends GLDrawableFactoryImpl { protected static final boolean DEBUG = GLDrawableFactoryImpl.DEBUG; - /* package */ static final boolean QUERY_EGL_ES = !Debug.isPropertyDefined("jogl.debug.EGLDrawableFactory.DontQuery", true); /* package */ static final boolean QUERY_EGL_ES_NATIVE_TK = Debug.isPropertyDefined("jogl.debug.EGLDrawableFactory.QueryNativeTK", true); private static GLDynamicLookupHelper eglES1DynamicLookupHelper = null; @@ -113,36 +114,11 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { } catch (JogampRuntimeException jre) { /* n/a .. */ } } - defaultDevice = new EGLGraphicsDevice(); - // FIXME: Probably need to move EGL from a static model // to a dynamic one, where there can be 2 instances // for each ES profile with their own ProcAddressTable. synchronized(EGLDrawableFactory.class) { - /** - * Currently AMD's EGL impl. crashes at eglGetDisplay(EGL_DEFAULT_DISPLAY) - * - // Check Desktop ES2 Availability first (AMD, ..) - if(null==eglES2DynamicLookupHelper) { - GLDynamicLookupHelper tmp=null; - try { - tmp = new GLDynamicLookupHelper(new DesktopES2DynamicLibraryBundleInfo()); - } catch (GLException gle) { - if(DEBUG) { - gle.printStackTrace(); - } - } - if(null!=tmp && tmp.isLibComplete()) { - eglES2DynamicLookupHelper = tmp; - EGL.resetProcAddressTable(eglES2DynamicLookupHelper); - if (GLProfile.DEBUG) { - System.err.println("Info: EGLDrawableFactory: Desktop ES2 - OK"); - } - } else if (GLProfile.DEBUG) { - System.err.println("Info: EGLDrawableFactory: Desktop ES2 - NOPE"); - } - } */ final boolean hasDesktopES2 = null != eglES2DynamicLookupHelper; if(!hasDesktopES2 && null==eglES1DynamicLookupHelper) { @@ -188,8 +164,9 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { } } if(null != eglES2DynamicLookupHelper || null != eglES1DynamicLookupHelper) { - sharedMap = new HashMap<String /*connection*/, SharedResource>(); + sharedMap = new HashMap<String /*uniqueKey*/, SharedResource>(); sharedMapCreateAttempt = new HashSet<String>(); + defaultDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(EGL.EGL_DEFAULT_DISPLAY, AbstractGraphicsDevice.DEFAULT_CONNECTION, AbstractGraphicsDevice.DEFAULT_UNIT); } } } @@ -203,6 +180,10 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { @Override protected final void destroy() { if(null != sharedMap) { + if(DEBUG) { + System.err.println("EGLDrawableFactory.destroy() .. "); + dumpMap(); + } Collection<SharedResource> srl = sharedMap.values(); for(Iterator<SharedResource> sri = srl.iterator(); sri.hasNext(); ) { SharedResource sr = sri.next(); @@ -216,7 +197,13 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { sharedMap = null; sharedMapCreateAttempt = null; } - defaultDevice = null; + if(null != defaultSharedResource) { + defaultSharedResource = null; + } + if(null != defaultDevice) { + defaultDevice.close(); + defaultDevice = null; + } /** * Pulling away the native library may cause havoc .. */ @@ -231,39 +218,63 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { EGLGraphicsConfigurationFactory.unregisterFactory(); EGLDisplayUtil.shutdown(DEBUG); } + + private void dumpMap() { + synchronized(sharedMap) { + System.err.println("EGLDrawableFactory.map "+sharedMap.size()); + int i=0; + Set<String> keys = sharedMap.keySet(); + for(Iterator<String> keyI = keys.iterator(); keyI.hasNext(); i++) { + String key = keyI.next(); + SharedResource sr = sharedMap.get(key); + System.err.println("EGLDrawableFactory.map["+i+"] "+key+" -> "+sr.getDevice()+", "+ + "es1 [avail "+sr.wasES1ContextAvailable()+", pbuffer "+sr.hasES1PBuffer()+", quirks "+sr.getGLRendererQuirksES1()+", ctp "+EGLContext.getGLVersion(1, 0, sr.getCtpES1(), null)+"], "+ + "es2 [avail "+sr.wasES2ContextAvailable()+", pbuffer "+sr.hasES2PBuffer()+", quirks "+sr.getGLRendererQuirksES1()+", ctp "+EGLContext.getGLVersion(2, 0, sr.getCtpES2(), null)+"]"); + } + ; + } + } - private HashMap<String /*connection*/, SharedResource> sharedMap = null; + private HashMap<String /*uniqueKey*/, SharedResource> sharedMap = null; private HashSet<String> sharedMapCreateAttempt = null; - - private EGLGraphicsDevice defaultDevice; + private EGLGraphicsDevice defaultDevice = null; + private SharedResource defaultSharedResource = null; static class SharedResource { private final EGLGraphicsDevice device; - // private final EGLDrawable drawable; // private final EGLContext contextES1; // private final EGLContext contextES2; + private final GLRendererQuirks rendererQuirksES1; + private final GLRendererQuirks rendererQuirksES2; + private final int ctpES1; + private final int ctpES2; private final boolean wasES1ContextCreated; private final boolean wasES2ContextCreated; private final boolean hasPBufferES1; private final boolean hasPBufferES2; SharedResource(EGLGraphicsDevice dev, - boolean wasContextES1Created, boolean hasPBufferES1, - boolean wasContextES2Created, boolean hasPBufferES2 - /*EGLDrawable draw, EGLContext ctxES1, EGLContext ctxES2 */) { + boolean wasContextES1Created, boolean hasPBufferES1, GLRendererQuirks rendererQuirksES1, int ctpES1, + boolean wasContextES2Created, boolean hasPBufferES2, GLRendererQuirks rendererQuirksES2, int ctpES2) { this.device = dev; - // this.drawable = draw; // this.contextES1 = ctxES1; // this.contextES2 = ctxES2; + this.rendererQuirksES1 = rendererQuirksES1; + this.rendererQuirksES2 = rendererQuirksES2; + this.ctpES1 = ctpES1; + this.ctpES2 = ctpES2; this.wasES1ContextCreated = wasContextES1Created; this.wasES2ContextCreated = wasContextES2Created; this.hasPBufferES1= hasPBufferES1; this.hasPBufferES2= hasPBufferES2; } final EGLGraphicsDevice getDevice() { return device; } - // final EGLDrawable getDrawable() { return drawable; } // final EGLContext getContextES1() { return contextES1; } // final EGLContext getContextES2() { return contextES2; } + final GLRendererQuirks getGLRendererQuirksES1() { return rendererQuirksES1; } + final GLRendererQuirks getGLRendererQuirksES2() { return rendererQuirksES2; } + final int getCtpES1() { return ctpES1; } + final int getCtpES2() { return ctpES2; } final boolean wasES1ContextAvailable() { return wasES1ContextCreated; } final boolean wasES2ContextAvailable() { return wasES2ContextCreated; } final boolean hasES1PBuffer() { return hasPBufferES1; } @@ -297,12 +308,23 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { return new ArrayList<GLCapabilitiesImmutable>(0); } - private boolean mapAvailableEGLESConfig(AbstractGraphicsDevice adevice, EGLGraphicsDevice sharedEGLDevice, String profileString, boolean[] hasPBuffer) { - if( !GLProfile.isAvailable(adevice, profileString) ) { + private boolean mapAvailableEGLESConfig(AbstractGraphicsDevice adevice, int esProfile, + boolean[] hasPBuffer, GLRendererQuirks[] rendererQuirks, int[] ctp) { + final String profileString; + switch( esProfile ) { + case 1: + profileString = GLProfile.GLES1; break; + case 2: + default: + profileString = GLProfile.GLES2; break; + } + if ( !GLProfile.isAvailable(adevice, profileString) ) { return false; } final GLProfile glp = GLProfile.get(adevice, profileString) ; final GLDrawableFactoryImpl desktopFactory = (GLDrawableFactoryImpl) GLDrawableFactory.getDesktopFactory(); + final boolean mapsADeviceToDefaultDevice = !QUERY_EGL_ES_NATIVE_TK || null == desktopFactory || adevice instanceof EGLGraphicsDevice ; + EGLGraphicsDevice eglDevice = null; NativeSurface surface = null; ProxySurface upstreamSurface = null; // X11, GLX, .. @@ -312,27 +334,49 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { final GLCapabilities reqCapsAny = new GLCapabilities(glp); reqCapsAny.setRedBits(5); reqCapsAny.setGreenBits(5); reqCapsAny.setBlueBits(5); reqCapsAny.setAlphaBits(0); reqCapsAny.setDoubleBuffered(false); - final GLCapabilitiesImmutable reqCapsPBuffer = GLGraphicsConfigurationUtil.fixGLPBufferGLCapabilities(reqCapsAny); - final List<GLCapabilitiesImmutable> availablePBufferCapsL = getAvailableEGLConfigs(sharedEGLDevice, reqCapsPBuffer); - hasPBuffer[0] = availablePBufferCapsL.size() > 0; - if(adevice instanceof EGLGraphicsDevice || null == desktopFactory || !QUERY_EGL_ES_NATIVE_TK) { - eglDevice = sharedEGLDevice; // reuse + if( mapsADeviceToDefaultDevice ) { + // In this branch, any non EGL device is mapped to EGL default shared resources (default behavior). + // Only one default shared resource instance is ever be created. + final GLCapabilitiesImmutable reqCapsPBuffer = GLGraphicsConfigurationUtil.fixGLPBufferGLCapabilities(reqCapsAny); + final List<GLCapabilitiesImmutable> availablePBufferCapsL = getAvailableEGLConfigs(defaultDevice, reqCapsPBuffer); + hasPBuffer[0] = availablePBufferCapsL.size() > 0; + + // 1st case: adevice is not the EGL default device, map default shared resources + if( adevice != defaultDevice ) { + if(null == defaultSharedResource) { + return false; + } + switch(esProfile) { + case 1: + rendererQuirks[0] = defaultSharedResource.rendererQuirksES1; + ctp[0] = defaultSharedResource.ctpES1; + break; + case 2: + rendererQuirks[0] = defaultSharedResource.rendererQuirksES2; + ctp[0] = defaultSharedResource.ctpES2; + break; + } + EGLContext.mapStaticGLVersion(adevice, esProfile, 0, ctp[0]); + return true; + } + + // attempt to created the default shared resources .. + + eglDevice = defaultDevice; // reuse + if( hasPBuffer[0] ) { + // 2nd case create defaultDevice shared resource using pbuffer surface surface = createDummySurfaceImpl(eglDevice, false, reqCapsPBuffer, null, 64, 64); // egl pbuffer offscreen upstreamSurface = (ProxySurface)surface; upstreamSurface.createNotify(); deviceFromUpstreamSurface = false; } else { + // 3rd case fake creation of defaultDevice shared resource, no pbuffer available final List<GLCapabilitiesImmutable> capsAnyL = getAvailableEGLConfigs(eglDevice, reqCapsAny); if(capsAnyL.size() > 0) { final GLCapabilitiesImmutable chosenCaps = capsAnyL.get(0); EGLContext.mapStaticGLESVersion(eglDevice, chosenCaps); - if(eglDevice != adevice) { - EGLContext.mapStaticGLESVersion(adevice, chosenCaps); - } - final EGLGraphicsDevice adeviceEGLDevice = new EGLGraphicsDevice(adevice.getHandle(), EGL.EGL_NO_DISPLAY, adevice.getConnection(), adevice.getUnitID(), null); - EGLContext.mapStaticGLESVersion(adeviceEGLDevice, chosenCaps); success = true; } if(DEBUG) { @@ -341,6 +385,7 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { } } } else { + // 4th case always creates a true mapping of given device to EGL surface = desktopFactory.createDummySurface(adevice, reqCapsAny, null, 64, 64); // X11, WGL, .. dummy window upstreamSurface = ( surface instanceof ProxySurface ) ? (ProxySurface)surface : null ; if(null != upstreamSurface) { @@ -365,8 +410,8 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { if(eglDevice != adevice) { context.mapCurrentAvailableGLVersion(adevice); } - final EGLGraphicsDevice adeviceEGLDevice = new EGLGraphicsDevice(adevice.getHandle(), EGL.EGL_NO_DISPLAY, adevice.getConnection(), adevice.getUnitID(), null); - context.mapCurrentAvailableGLVersion(adeviceEGLDevice); + rendererQuirks[0] = context.getRendererQuirks(); + ctp[0] = context.getContextOptions(); success = true; } else { // Oops .. something is wrong @@ -393,7 +438,7 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { } success = false; } finally { - if(eglDevice == sharedEGLDevice) { + if(eglDevice == defaultDevice) { if(null != upstreamSurface) { upstreamSurface.destroyNotify(); } @@ -416,67 +461,101 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { return success; } - /* package */ SharedResource getOrCreateEGLSharedResource(AbstractGraphicsDevice adevice) { - if(null == sharedMap) { // null == eglES1DynamicLookupHelper && null == eglES2DynamicLookupHelper - return null; - } - final String connection = adevice.getConnection(); - SharedResource sr; - boolean createAttempted; + private final boolean needsToCreateSharedResource(String key, SharedResource[] existing) { synchronized(sharedMap) { - sr = sharedMap.get(connection); + final SharedResource sr = sharedMap.get(key); if( null == sr ) { - createAttempted = sharedMapCreateAttempt.contains(connection); + final boolean createAttempted = sharedMapCreateAttempt.contains(key); if(!createAttempted) { - sharedMapCreateAttempt.add(connection); + sharedMapCreateAttempt.add(key); } + return !createAttempted; } else { - createAttempted = true; - } - } - if(null==sr && !createAttempted) { - final boolean madeCurrentES1; - final boolean madeCurrentES2; - final EGLGraphicsDevice sharedDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(EGL.EGL_DEFAULT_DISPLAY, AbstractGraphicsDevice.DEFAULT_CONNECTION, AbstractGraphicsDevice.DEFAULT_UNIT); - boolean[] hasPBufferES1 = new boolean[1]; - boolean[] hasPBufferES2 = new boolean[1]; - - if(QUERY_EGL_ES) { - madeCurrentES1 = mapAvailableEGLESConfig(adevice, sharedDevice, GLProfile.GLES1, hasPBufferES1); - madeCurrentES2 = mapAvailableEGLESConfig(adevice, sharedDevice, GLProfile.GLES2, hasPBufferES2); - } else { - madeCurrentES1 = true; - madeCurrentES2 = true; - hasPBufferES1[0] = true; - hasPBufferES2[0] = true; - EGLContext.mapStaticGLESVersion(sharedDevice, 1); - if(sharedDevice != adevice) { - EGLContext.mapStaticGLESVersion(adevice, 1); - } - EGLContext.mapStaticGLESVersion(sharedDevice, 2); - if(sharedDevice != adevice) { - EGLContext.mapStaticGLESVersion(adevice, 2); + if(null != existing) { + existing[0] = sr; } + return false; } - - if( !EGLContext.getAvailableGLVersionsSet(adevice) ) { - // Even though we override the non EGL native mapping intentionally, - // avoid exception due to double 'set' - carefull exception of the rule. - EGLContext.setAvailableGLVersionsSet(adevice); + } + } + + /* package */ SharedResource getOrCreateEGLSharedResource(AbstractGraphicsDevice adevice) { + if(null == sharedMap) { // null == eglES1DynamicLookupHelper && null == eglES2DynamicLookupHelper + return null; + } + + if( needsToCreateSharedResource(defaultDevice.getUniqueID(), null) ) { + if (DEBUG) { + System.err.println("EGLDrawableFactory.createShared: (defaultDevice): req. device: "+adevice+", defaultDevice "+defaultDevice); + Thread.dumpStack(); } - sr = new SharedResource(sharedDevice, madeCurrentES1, hasPBufferES1[0], madeCurrentES2, hasPBufferES2[0]); - - synchronized(sharedMap) { - sharedMap.put(connection, sr); - if(adevice != sharedDevice) { - sharedMap.put(sharedDevice.getConnection(), sr); - } + if(null != defaultSharedResource) { + dumpMap(); + throw new InternalError("defaultSharedResource already exist: "+defaultSharedResource); } - if (DEBUG) { - System.err.println("EGLDrawableFactory.createShared: devices: queried " + QUERY_EGL_ES + "[nativeTK "+QUERY_EGL_ES_NATIVE_TK+"], " + adevice + ", " + sharedDevice); - System.err.println("EGLDrawableFactory.createShared: context ES1: " + madeCurrentES1 + ", hasPBuffer "+hasPBufferES1[0]); - System.err.println("EGLDrawableFactory.createShared: context ES2: " + madeCurrentES2 + ", hasPBuffer "+hasPBufferES2[0]); + defaultSharedResource = createEGLSharedResourceImpl(defaultDevice); + } + + final String key = adevice.getUniqueID(); + if( defaultDevice.getUniqueID().equals(key) ) { + return defaultSharedResource; + } else { + if( null == defaultSharedResource) { // defaultDevice must be initialized before host-device + dumpMap(); + throw new InternalError("defaultSharedResource does not exist"); } + final SharedResource[] existing = new SharedResource[] { null }; + if ( !needsToCreateSharedResource(key, existing) ) { + return existing[0]; + } + return createEGLSharedResourceImpl(adevice); + } + } + + private SharedResource createEGLSharedResourceImpl(AbstractGraphicsDevice adevice) { + final boolean madeCurrentES1; + final boolean madeCurrentES2; + boolean[] hasPBufferES1 = new boolean[] { false }; + boolean[] hasPBufferES2 = new boolean[] { false }; + // EGLContext[] eglCtxES1 = new EGLContext[] { null }; + // EGLContext[] eglCtxES2 = new EGLContext[] { null }; + GLRendererQuirks[] rendererQuirksES1 = new GLRendererQuirks[] { null }; + GLRendererQuirks[] rendererQuirksES2 = new GLRendererQuirks[] { null }; + int[] ctpES1 = new int[] { -1 }; + int[] ctpES2 = new int[] { -1 }; + + + if (DEBUG) { + System.err.println("EGLDrawableFactory.createShared(): device "+adevice); + } + + if( null != eglES1DynamicLookupHelper ) { + madeCurrentES1 = mapAvailableEGLESConfig(adevice, 1, hasPBufferES1, rendererQuirksES1, ctpES1); + } else { + madeCurrentES1 = false; + } + if( null != eglES2DynamicLookupHelper ) { + madeCurrentES2 = mapAvailableEGLESConfig(adevice, 2, hasPBufferES2, rendererQuirksES2, ctpES2); + } else { + madeCurrentES2 = false; + } + + if( !EGLContext.getAvailableGLVersionsSet(adevice) ) { + // Even though we override the non EGL native mapping intentionally, + // avoid exception due to double 'set' - carefull exception of the rule. + EGLContext.setAvailableGLVersionsSet(adevice); + } + final SharedResource sr = new SharedResource(defaultDevice, madeCurrentES1, hasPBufferES1[0], rendererQuirksES1[0], ctpES1[0], + madeCurrentES2, hasPBufferES2[0], rendererQuirksES2[0], ctpES2[0]); + + synchronized(sharedMap) { + sharedMap.put(adevice.getUniqueID(), sr); + } + if (DEBUG) { + System.err.println("EGLDrawableFactory.createShared: devices: queried nativeTK "+QUERY_EGL_ES_NATIVE_TK+", adevice " + adevice + ", defaultDevice " + defaultDevice); + System.err.println("EGLDrawableFactory.createShared: context ES1: " + madeCurrentES1 + ", hasPBuffer "+hasPBufferES1[0]); + System.err.println("EGLDrawableFactory.createShared: context ES2: " + madeCurrentES2 + ", hasPBuffer "+hasPBufferES2[0]); + dumpMap(); } return sr; } @@ -504,9 +583,18 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { @Override protected final GLContext getOrCreateSharedContextImpl(AbstractGraphicsDevice device) { - return null; // n/a for EGL .. since we don't keep the resources + return null; // FIXME: n/a .. } - + + @Override + public GLRendererQuirks getRendererQuirks(AbstractGraphicsDevice device) { + SharedResource sr = getOrCreateEGLSharedResource(device); + if(null!=sr) { + return null != sr.getGLRendererQuirksES2() ? sr.getGLRendererQuirksES2() : sr.getGLRendererQuirksES1() ; + } + return null; + } + @Override protected AbstractGraphicsDevice getOrCreateSharedDeviceImpl(AbstractGraphicsDevice device) { SharedResource sr = getOrCreateEGLSharedResource(device); @@ -596,9 +684,7 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl { @Override public final ProxySurface createDummySurfaceImpl(AbstractGraphicsDevice deviceReq, boolean createNewDevice, GLCapabilitiesImmutable requestedCaps, GLCapabilitiesChooser chooser, int width, int height) { - final GLCapabilitiesImmutable chosenCaps = - GLGraphicsConfigurationUtil.fixDoubleBufferedGLCapabilities( - GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(requestedCaps, false, canCreateGLPbuffer(deviceReq)), false); + final GLCapabilitiesImmutable chosenCaps = GLGraphicsConfigurationUtil.fixOffscreenBitOnly(requestedCaps); // complete validation in EGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(..) above return createMutableSurfaceImpl(deviceReq, createNewDevice, chosenCaps, requestedCaps, chooser, new EGLDummyUpstreamSurfaceHook(width, height)); } diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java index e72255108..a2ac22fa5 100644 --- a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java +++ b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java @@ -247,9 +247,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact } final GLProfile glp = capsChosen.getGLProfile(); - final EGLDrawableFactory factory = (EGLDrawableFactory) GLDrawableFactory.getEGLFactory(); - capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLContext.isFBOAvailable(absDevice, glp), factory.canCreateGLPbuffer(absDevice) ); - + capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLDrawableFactory.getEGLFactory(), absDevice); EGLGraphicsConfiguration res = eglChooseConfig(eglDevice, capsChosen, capsReq, chooser, absScreen, nativeVisualID, forceTransparentFlag); if(null==res) { if(DEBUG) { diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java index e174d38f4..06f8c0c25 100644 --- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java +++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java @@ -45,7 +45,6 @@ import java.util.HashMap; import java.util.HashSet; import java.util.List; -import javax.media.nativewindow.AbstractGraphicsConfiguration; import javax.media.nativewindow.AbstractGraphicsDevice; import javax.media.nativewindow.AbstractGraphicsScreen; import javax.media.nativewindow.DefaultGraphicsScreen; @@ -64,7 +63,6 @@ import javax.media.opengl.GLProfile; import jogamp.nativewindow.WrappedSurface; import jogamp.nativewindow.macosx.OSXDummyUpstreamSurfaceHook; import jogamp.opengl.DesktopGLDynamicLookupHelper; -import jogamp.opengl.GLContextImpl; import jogamp.opengl.GLDrawableFactoryImpl; import jogamp.opengl.GLDrawableImpl; import jogamp.opengl.GLDynamicLookupHelper; @@ -148,7 +146,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { static class SharedResource { // private MacOSXCGLDrawable drawable; - // private MacOSXCGLContext context; + private MacOSXCGLContext context; MacOSXGraphicsDevice device; boolean wasContextCreated; boolean hasNPOTTextures; @@ -157,9 +155,9 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { SharedResource(MacOSXGraphicsDevice device, boolean wasContextCreated, boolean hasNPOTTextures, boolean hasRECTTextures, boolean hasAppletFloatPixels - /* MacOSXCGLDrawable draw, MacOSXCGLContext ctx */) { + /* MacOSXCGLDrawable draw */, MacOSXCGLContext ctx) { // drawable = draw; - // context = ctx; + this.context = ctx; this.device = device; this.wasContextCreated = wasContextCreated; this.hasNPOTTextures = hasNPOTTextures; @@ -167,6 +165,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { this.hasAppleFloatPixels = hasAppletFloatPixels; } final MacOSXGraphicsDevice getDevice() { return device; } + final MacOSXCGLContext getContext() { return context; } final boolean wasContextAvailable() { return wasContextCreated; } final boolean isNPOTTextureAvailable() { return hasNPOTTextures; } final boolean isRECTTextureAvailable() { return hasRECTTextures; } @@ -213,6 +212,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { if(null==sr && !getDeviceTried(connection)) { addDeviceTried(connection); final MacOSXGraphicsDevice sharedDevice = new MacOSXGraphicsDevice(adevice.getUnitID()); + final MacOSXCGLContext sharedContext; boolean madeCurrent = false; boolean hasNPOTTextures = false; boolean hasRECTTextures = false; @@ -225,7 +225,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { final GLDrawableImpl sharedDrawable = createOnscreenDrawableImpl(createDummySurfaceImpl(sharedDevice, false, new GLCapabilities(glp), null, 64, 64)); sharedDrawable.setRealized(true); - final GLContextImpl sharedContext = (GLContextImpl) sharedDrawable.createContext(null); + sharedContext = (MacOSXCGLContext) sharedDrawable.createContext(null); if (null == sharedContext) { throw new GLException("Couldn't create shared context for drawable: "+sharedDrawable); } @@ -256,7 +256,7 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { } sharedDrawable.setRealized(false); } - sr = new SharedResource(sharedDevice, madeCurrent, hasNPOTTextures, hasRECTTextures, hasAppleFloatPixels); + sr = new SharedResource(sharedDevice, madeCurrent, hasNPOTTextures, hasRECTTextures, hasAppleFloatPixels, sharedContext); synchronized(sharedMap) { sharedMap.put(connection, sr); } @@ -293,7 +293,10 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl { @Override protected final GLContext getOrCreateSharedContextImpl(AbstractGraphicsDevice device) { - // FIXME: not implemented .. needs a dummy OSX surface + SharedResource sr = getOrCreateOSXSharedResource(device); + if(null!=sr) { + return sr.getContext(); + } return null; } diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java index 43a9d0d1a..3bbba2c52 100644 --- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java +++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java @@ -35,7 +35,6 @@ package jogamp.opengl.macosx.cgl; import jogamp.opengl.GLGraphicsConfigurationFactory; import jogamp.opengl.GLGraphicsConfigurationUtil; -import jogamp.opengl.x11.glx.X11GLXDrawableFactory; import javax.media.nativewindow.AbstractGraphicsConfiguration; import javax.media.nativewindow.AbstractGraphicsDevice; @@ -45,7 +44,6 @@ import javax.media.nativewindow.CapabilitiesImmutable; import javax.media.nativewindow.GraphicsConfigurationFactory; import javax.media.opengl.GLCapabilitiesChooser; import javax.media.opengl.GLCapabilitiesImmutable; -import javax.media.opengl.GLContext; import javax.media.opengl.GLDrawableFactory; @@ -91,10 +89,8 @@ public class MacOSXCGLGraphicsConfigurationFactory extends GLGraphicsConfigurati if (absScreen == null) { throw new IllegalArgumentException("AbstractGraphicsScreen is null"); } - final MacOSXCGLDrawableFactory factory = (MacOSXCGLDrawableFactory) GLDrawableFactory.getDesktopFactory(); final AbstractGraphicsDevice device = absScreen.getDevice(); - - capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLContext.isFBOAvailable(device, capsChosen.getGLProfile()), factory.canCreateGLPbuffer(device) ); + capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLDrawableFactory.getDesktopFactory(), device); return new MacOSXCGLGraphicsConfiguration(absScreen, (GLCapabilitiesImmutable)capsChosen, (GLCapabilitiesImmutable)capsRequested); } diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java index d2d1dafc8..10d7fb22b 100644 --- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java +++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java @@ -105,10 +105,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat absScreen = DefaultGraphicsScreen.createDefault(NativeWindowFactory.TYPE_WINDOWS); } final AbstractGraphicsDevice absDevice = absScreen.getDevice(); - final GLDrawableFactory factory = GLDrawableFactory.getDesktopFactory(); - capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( - capsChosen, GLContext.isFBOAvailable(absDevice, capsChosen.getGLProfile()), factory.canCreateGLPbuffer(absDevice) ); - + capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLDrawableFactory.getDesktopFactory(), absDevice); return new WindowsWGLGraphicsConfiguration( absScreen, capsChosen, capsReq, (GLCapabilitiesChooser)chooser ); } diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java index 431706e24..ef2d3283d 100644 --- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java +++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java @@ -45,7 +45,6 @@ import javax.media.opengl.DefaultGLCapabilitiesChooser; import javax.media.opengl.GLCapabilities; import javax.media.opengl.GLCapabilitiesChooser; import javax.media.opengl.GLCapabilitiesImmutable; -import javax.media.opengl.GLContext; import javax.media.opengl.GLDrawableFactory; import javax.media.opengl.GLException; import javax.media.opengl.GLProfile; @@ -213,9 +212,9 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF } X11GraphicsDevice x11Device = (X11GraphicsDevice) x11Screen.getDevice(); X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory(); - - capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLContext.isFBOAvailable(x11Device, capsChosen.getGLProfile()), factory.canCreateGLPbuffer(x11Device) ); - boolean usePBuffer = !capsChosen.isOnscreen() && capsChosen.isPBuffer(); + + capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, factory, x11Device); + final boolean usePBuffer = !capsChosen.isOnscreen() && capsChosen.isPBuffer(); X11GLXGraphicsConfiguration res = null; if( factory.isGLXVersionGreaterEqualOneThree(x11Device) ) { |